Java基础学习总结

Java基础知识总结，在学习这一门语言新知识点新技术的过程中很枯燥很不容易很有压力，但它必须要经历这些过程，它就是要从认识、模仿、练习、总结、理解与掌握并实际运用的历程；废话少说，请看以下详细文档：

一、基本概念：

1、java语言特点：简单、面向对象、分布式、解析型、稳定、安全、结构中立、易移值、高性能、多线程、动态语言....

2、java环境的搭建

cmd运行java文件

jdk与myeclipse的和Notepad++(超文本编辑器)安装

java编码规范介绍

myeclipse快捷键的使用

java数据类型

数据类型的转换

算数运算符

循环以及分支结构

3、JAVASE的架构：JVM(虚拟机)+JRE(java核心类库)+java编程工具=JDK

4、JDK、SDK、JRE、JVM概念详解：

JDK:(Java 开发包) SDK(软件开发工具) JRE(其实就是java基础类+JVM) JVM(java虚拟机)

5、java语言平台版本：

(1)、javaSE(标准版) 是为开发普通桌面和商务应用程序提供的解决方案，该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发

(2)、javaME小型版(是为开发电子消费产品和嵌入式设备提供的解决方案)

(3)、javaEE(是为开发企业环境下的应用程序提供的一套解决方案,该技术体系中包含的技术如 Servlet、Jsp等，主要针对于Web应用程序开发)

6、跨平台解析：有虚拟机（JVM）的出现，只要在不同的电脑装上不同版本的虚拟机就可以到处运行Java的代码

7、编写简单的java程序：

(1)、新建一个文本型的文件

(2)、在文本编写一个类例如：class Demo{}

(3)、转换文本格式例如：123.java

(4)、打开cmd 找到该目录下的文件此刻

(5)、编写主方法main 例如：public static void main (String [] args){}

(6)、在主方法输出要显示的内容：System.out.println("Hello World");

8、java运行代码步骤：

(1)、首先cmd运行，接着找磁盘(如e:)成功切换到对应的磁盘

(2)、输入cd 并找到对应的文件输入：E:\mycode

(3)、找到文件之后，输入javac 并输入文件里的.java的超文本(超文本的类方法用 Notepad++自己编辑)

(4)、在同文件夹下生成一个同名不同类型的文本（如:A.class）

(5)、输入java 后再输入类方法名（如：A）回车运行即可输入在文本写的结果

cmd模本代码:

Microsoft Windows [版本 10.0.17134.228]

C:\Users\QX>e:

E:\>cd E:\mycode

E:\mycode>javac A.java

E:\mycode>java A

Welcome to java

E:\mycode>

9、新建项目步骤：

（1）任务栏右键点击new找到java project 新建

（2）在src里面建包，命名规则(公司域名的倒写，全部小写)如:(com.gx.type)

（3）新建类如(TypeDemo) 命名规则：类名首字母大写(TypeDemo)

（4）新建方法main 命名规则：首字母小写(main、userAdd) 常量命名规则(全部大写)

10、Java语言的基础组成：关键字（被赋予特殊含义的单词，都是小写形式）

标识符（用于标识某些东西的符号，由26位大小写组成、数字0-9、_或$组成）

注释（注释：/** 文档注释 */ java特有的）

常量和变量

运算符

语句

函数

数组

11、整数的四表现形式：

二进制：0，1 满2进1

八进制：0-7 满8进1.用0开头表示

十进制：0-9 满10进1 默认进制

十六进制：0-9 A-F 满16进1.用0x开头表示

二、基本数据类型：

基本数据类型取值范围：

数据类型关键字内存占用字节数取值范围默认值

布尔型 boolean 1个字节（8位） true,false false

字节型 byte 1个字节（8位） -128~127 0

字符型 char 2个字节（16） 0~2的16次方-1 '\u0000'

短整型 short 2个字节（16） -2的15~2的15次方-1 0

整形 int 4个字节（32） -2的31~2的31次方-1 0

长整形 long 8个字节（64） -2的63~2的63次方-1 0

单精度浮点型 float 4个字节（32） 1.40131E-45~3.4028E-38 0.0F

双精度浮点型 double 8个字节（64） 4.9E-324~1.7977E+308 0.0D

byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0

short：短整型，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0

int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0

long：长整型，在内存中占64位，即8个字节-2^63~2^63-1，默认值0L

float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0

double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0

char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空

boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false

溢出：正的输出负的，负的输出正（主要原因是超出内存）

包装类：

(boolean Boolean) (byte Byte) (char Character) (short Short) (int Integer) (long Long) (float Float) (double Double)

三、流程控制语句：

if-eles可拆分3中语句：

1、if(){}

2、if(){}eles{}

3、eles if(){} if(){}

switch语句：

switch(表达式){case 表达式值1:语句块1;break;default:语句块;break;}

do while和while语句：

do{} while(){} 语句 (其中都要执行一次)

while(){} 语句

for语句：

for(int i =1;i <11;i++){执行语句;}

使用技巧：当对一个条件进行一次判断时，可以使用if语句。

当对一个条件进行多次判断时，可以使用while语句。

当对某些代码执行很多次是，可以使用循环结构语句

四、运算符：

java中的六种预算符：

1、算术运算符（+ - * / % ++ --）

2、赋值运算符（= += -= *= /= %=）

3、关系运算符（> < >= <= == !=）

4、逻辑运算符（&& || !）

5、位运算符（&与或| ~非异或^）

6、三元运算符（ ? :）

public static void main(String[] args) {

// 算术运算符：+ - * / % ++ --

// 算术运算符

// + 加同时也是字符串的连接运算符

int a = 19;

int b = 4;

int c = a + b;

System.out.println("a+b=" + c);

// - 减

int d = a - b;

System.out.println("a-b=" + d);

// * 乘

int e = a * b;

System.out.println("a*b=" + e);

// / 除

int f = a / b;

// 注：整数/整数=整数，是截断取整，而不是四舍五入取整

// ****java.lang.ArithmeticException: / by zero

// int g=a/0; //整数不能除0，

// 当除数或者被除数中有一个为浮点型的，那么结果就是自然除法的结果，

// 如果此时除数为0或者0.0，那么结果为正无穷或者负无穷

// 0.0除0.0结果为NaN 非数

System.out.println("a/b=" + f);

System.out.println("a/0.0=" + (a / 0.0));

System.out.println("-a/0.0=" + (-a / 0.0));

System.out.println("0.0/0.0=" + (0.0 / 0.0));

// % 取余

// 两个整数时第二个数不能是0

// 一个或者2个为浮点数，第二个数为0或者0.0时，结果为NaN，

// 第一个数为0或0.0时，结果为0.0

int h = a % b;

System.out.println("a % b=" + h);

System.out.println("a % 0.0=" + (a % 0.0));

System.out.println("0.0 & b=" + (0.0 % b));

// ++ 自加；单目运算符

int A = 20;

int B = 20;

int C = A++ + B;

System.out.println("++A=" + (++A));

System.out.println("B++=" + (B++));

System.out.println("C=" + C);

// -- 自减，单目运算符

int D = 20;

int E = 20;

System.out.println("--D=" + (--D));

System.out.println("E--=" + (E--));

// 复杂的数学运算在 java.lang.Math

System.out.println("2的3次方=" + Math.pow(2, 3));

System.out.println("4开平方=" + Math.sqrt(4));

// 比较运算符：> >= < <= == !=

System.out.println("5>4 = " + (5 > 4));

System.out.println("5>=4 = " + (5 >= 4));

System.out.println("5<4 = " + (5 < 4));

System.out.println("5<=4 = " + (5 <= 4));

System.out.println("5==4 = " + (5 == 4));

System.out.println("5!=4 = " + (5 != 4));

// == 和 equals 方法

String str = "123";

int intA = 123;

String strA = String.valueOf(intA);

System.out.println("str==strA = " + (str == strA));

System.out.println("str.equals(strA) = " + (str.equals(strA)));

// //逻辑运算符

// &&:与，前后两个操作数必须都是true才返回true，否则返回false。

// &:不短路与，作用与&&相同，但不会短路。

// ||：或，只要两个操作数中有一个是true，就可以返回true，否则返回false。

// |不短路或，作用与||相同，但不会短路。

// !:非，只需要一个操作数，如果操作数为true,则返回false;如果操作数为false，则返回true。

// ^:异或，当两个操作数不同时才返回true,如果两个操作数相同则返回false。

// 短路和不短路

int intB = 10;

if (intB > 11 && intB++ > 9) {

}

System.out.println(intB);

int intC=10;

if(intC<11 || intC++ >9){

}

//!

if (!(1>2)) {

System.out.println("!(1>2)");

}

//^

if (true ^ false) {

System.out.println("true ^ false");

}

System.out.println("intC =" +intC);

//三目运算符： ? :

System.out.println((5>4)?"5>4" :"5<4");

//==和equals

int intA1=10;

int intA2=20/2;

System.out.println("intA1==intA2 :" +(intA1==intA2));

// == 在基本数据类型的时候就是比较值是否相同

// 在引用类型时是比较地址

//equals 用于判断引用类型的值

String s1="123";

String s2="12"+"34"+"sss"+"sss"+e;

System.out.println(s2);

System.out.println("s1==s2 :" +(s1.equals(s2)));

}

五、数组：

概念：数组就是一种用于存储数据的方式

数据类型：基本数据类型(分:布尔类型和数值类型)、引用数据类型(分:类，接口，数组)

数组的定义：

方法一 type[] arrayName (推荐使用)

方法二 type arrayName[]

数组初始化

1、静态初始化(直接赋值):arrayIntA =new int[]{1,2,3,4,5}

2、动态初始化:arrayStringA =new String[5];

数组的格式：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例：int[] arr = new int[5];

实现：1声明数组变量(左边) =创建数组(要使用一个新的关键字.叫做new) (右边)

(注：“=”并不是数学中的“等号”，而是一个赋值运算符)

数组赋值

for(int i =0;i<arrayStringA.length;i++){arrayString.valueOf(i);}

取值

for(int i =0;arrayStringA.length;i++){system.out.println(i);}

foreach(这形式只能取值，不能赋值)

for(String s :arrayStringA){System.out.println(s);}

二维数组

int[][] int1

int1 =new int[][]{ {1,2,3,},{4,5,6}}

int1=new int[5][5];

数组的存储

1、定义数组 int[] numbers;

2、分配内存空间 numbers =new int[4]

3、维数组元素指定值 for(int i =0;i<numbers.length;i++){numbers[i]=i*10;}

六、myecilpse环境配置：

在“环境变量”的“系统变量”选项新建系统变量：JAVA_HOME，值为：C:\Program Files\Java\jdk1.7.0（填写你的JDK路径即可）。在系统变量中找到变量“PATH”，双击打开，把以下代码加到变量值末尾：“;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;”（注意最前的”;”不能少。

说明：

1，.表示当前路径，%JAVA_HOME%就是引用前面指定的JAVA_HOME；

2，JAVA_HOME指明JDK安装路径，此路径下包括lib，bin，jre等文件夹，tomcat，eclipse等的运行都需要依靠此变量。

3，PATH使得系统可以在任何路径下识别java命令。

配置成功之后，在cmd界面输入 java -version 可以查看信息

Tomcat环境配置

下载完成之后，我们解压缩到相应的目录。这里我解压缩到d盘下面

1、然后去配置系统的环境变量，新建系统变量:catalina_home

2、下面两个系统变量如果有，就直接在里面添加，如果没有，大家可以直接创建：将catalina_home加到path里

3、上面的步骤操作完成之后，我们回来Tomcat的bin目录下，找到startup.bat文件，双击运行，就会看到这个界面：Tomcat

4、当里面的命令执行完之后，我们就可以打开浏览器，在里面输入http://localhost:8080/ 就可以看到如下界面：

以上步骤完成后，我们的Tomcat就搭建好了,但是通过这种方式启动，在我们关闭命令行窗口时，Tomcat就停止了。

设置工作空间编码格式:

点击Windows → preference → WorkSpace(选择编码格式，默认为GBK，不过选择UTF-8为好)

更改字体：

点击Windows → preference → General →Appearence → Color and Fonts → Basic

或者搜索Colors and fonts

选择 Text font ，点击Edit编辑，就可以更改字体了，选择合适的就行

Class类的注释模板：

打开Eclipse/MyEclipse工具，点击 Window->Preferences弹出首选项设置窗口，Java->Code Style->Code Template选项列表，点击Types

添加Tomcat：

点击Windows → preference →MyEclipse →Server → Tomcat 或者搜索tomcat

选择tomcat的版本并导入响应版本的tomcat

显示行号：

右键代码最左边，选中Show line Number

导入项目：

在项目框右键import，选择General→Existing projects to workspace，然后选择项目的路径。如果是maven项目，则是用mavan导入就行。至于是否copy到工作空间，这看个人选择

导出项目：

如果只是项目普通的导出，那就直接右键项目，选择copy就行。如果是要在tomcat部署或者导出为架包，则选择war和jar方式导出

切换工作空间：

File→ switch workspace 然后选择要切换的路径。切换之后，myeclipse/eclipse回重启

Tomcat添加项目：

在server窗口中添加(选择tomcat，右键Add Deployment，选择要添加的项目，然后点击Finsh就OK了)

取消自动validation:

除开Manual下面的复选框全部选中之外，其他全部不选

七、所有变量：

成员变量：在类体里面定义的变量叫做成员变量；

如果在变量有static关键字修饰，就叫作静态变量或类变量；如果没有，就叫非静态变量或实例变量

1、类变量(以static修饰)

2、实例变量(不以static修饰)

局部变量：方法内定义的变量、形参、代码块中定义的变量都叫做局部变量；

1、形参(方法签名中的定义的变量)

2、方法局部变量(在方法内定义)

3、代码块局部变量(在代码块内定义)

另外，成员变量可以不显式初始化，它们可以由系统设定默认值；局部变量没有默认值，所以必须设定初始赋值。

还有，在内存中的位置也不一样。成员变量在所在类被实例化后，存在堆内存中；局部变量在所在方法调用时，存在栈内存空间中。

总结：

在类下面的以及有无static关键字修饰的都称为成员变量分别有两种方式定义：类变量、实例变量

在方法里面的形参定义及方法体里面的以及代码块里面的变量称为局部变量

八、封装：

封装：Encapsulation(是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法)

继承、封装、多态、抽象是面向对象编程的四大基本概念，其中封装尤为重要，因为从我们学习JAVA开始，就基本上接触了封装，因为JAVA中的所有程序都是写在类中的，类也能当做一种封装。

为什么要封装的解释：

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性

在面向对象中封装是指隐藏对象的属性和实现的细节，仅对外提供公共访问方式。在类定义中用private关键字来实现封装。封装有什么好处？

（一）、是用private把类的细节与外界隔离起来，从而实现数据项和方法的隐藏，而要访问这些数据项和方法唯一的途径就是通过类本身，类才有资格调用它所拥有的资源（方法，数据项属性等等）。所以第一个好处就是数据的安全性提高了。

（二）、是通过隐藏隔离，只允许外部对类做有限的访问，开发者可以自由的改变类的内部实现，而无需修改使用该类的那些程序。只要那些在类外部就能被调用的方法保持其外部特征不变，内部代码就可以自由改变，各取所需，利于分工。

（三）、就是提高了代码的重用性，封装成工具类以后能够减少很多繁琐的步骤

封装的优点：

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

* java封装示例

* get,set快捷键 alt+shift+s

* 重复三次使用要有封装的思想

public class Encapsulation {

private String name;

private int age;

private int sex;

//快捷键 alt+shift+s 然后选择....setters进行添加

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public int getSex() {

return sex;

}

public void setSex(int sex) {

this.sex = sex;

}

九、继承：

（一）、继承的概念：

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

（二）、类的继承格式：

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下

class 父类{}

class 子类 extends 父类 {}

（三）、继承类型：

需要注意的是 Java 不支持多继承，但支持多重继承

单继承多继承不同类型继承同一个类 (java不支持多继承)

（四）、继承的特性：

子类拥有父类非private的属性，方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

（五）、继承关键字：

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类

1、extends关键字(在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类)

示例：

public class Animal {

private String name;

private int id;

public Animal(String myName, String myid) {

//初始化属性值

}

public void eat() { //吃东西方法的具体实现 }

public void sleep() { //睡觉方法的具体实现 }

}

public class Penguin extends Animal{ }

2、implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）

示例：

public interface A {

public void eat();

public void sleep();

}

public interface B {

public void show();

}

public class C implements A,B {}

3、super与this关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用

4、final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写

声明类：final class 类名 {//类体}

声明方法：修饰符(public/private/default/protected) final 返回值类型方法名(){//方法体}

十、访问控制级别和修饰符

private (同一个类中)私有的

default (同一个类中、同一个包)受权限的

protected (同一个类中、同一个包、子类中)继承的类可以访问

public (同一个类中、同一个包、子类中、全局范围内)公有的

访问控制修饰符

**类：

* 访问修饰符：public

* 修饰符：abstract

final

**变量：

* 访问修饰符：

public (可以被任何类访问)

protected (可以被同一包中的所有类访问和被所有子类访问)

default (可以被同一包中的所有类访问注：如果子类没有在同一个包中，也不能访问)

private (只能够被当前类的方法访问)

* 修饰符：

static (静态变量（又称为类变量，其它的称为实例变量）,可以被类的所有实例共享。并不需要创建类的实例就可以访问静态变量)

final

**方法：

* 访问修饰符：

public (可以从所有类访问)

protected (可以被同一包中的所有类访问和被所有子类访问)

default (可以被同一包中的所有类访问注：如果子类没有在同一个包中，也不能访问)

private (只能够被当前类的方法访问)

* 修饰符：

static (静态方法（又称为类方法，其它的称为实例方法）,提供不依赖于类实例的服务,并不需要创建类的实例就可以访问静态方法)

final (防止任何子类重载该方法)

abstract (抽象方法，类中已声明而没有实现的方法,不能将static方法、final方法或者类的构造器方法声明为abstract)

十一、多态：

重载(overload)：

方法重载的作用：方法重载就是对不同数据类型的的数据实现相似的操作

方法重载的定义：对于同一个类，如果这个类里面有两个或者多个重名的方法，但是方法的参数个数、类型、顺序至少有一个不一样，这时候局构成方法重载

Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性

示例一：

public class Test{

public void a( ){

};

public void a( int i){

};

}

说明：在Test类中有两个方法，名字都相同，都是a。在调用方法a时，如果不传参数，则系统会自动调用第一个方法a，如果传入一个 int 类型的参数，则系统调用第二个方法a。

示例二：

public class Test{

public void a(int i){

};

public void a(String j){

};

}

说明：在Test类中有两个同名的方法a。在调用方法时，如果传入一个int类型的参数，则会自动调用第一个a方法，如果传入一个String类型的参数，则会自动调用第二个方法a。

示例三：

public class Test{

public void a(int i,String j){

}

public class a(String j,int i){

}

说明：在Test类中有两个同名的方法。在调用方法时，如果传入的第一个参数类型为int，第二个参数类型为String，则自动调用第一个方法a。如果传入的第一个参数为String类型，第二个参数类型为int，则自动调用第二个方法a。

重写(override)：

当一个类继承另一个类时，则可以拥有父类的成员方法和成员变量，在子类中，可以创建独有的成员，如果创建了一个与父类中相同名称，相同返回类型、相同参数列表的方法，只是方法体中的实现方法不同，以实现不同于父类的功能，这种方式就称为方法的重写，又称为方法的覆盖

解释：所谓方法重写就是子类的方法和父类中继承下来的方法具有完全相同的方法名、返回值类型、方法的参数个数以及参数类型，这样才能被称为方法重写

在进行方法重写的时候需要遵循以下规则才能实现方法重写：

1、子类方法的参数列表必须和父类中被重写的方法的参数列表相同（参数个数和参数类型），否则只能实现方法的重载。

2、子类方法的返回值类型必须和父类中被重写的方法返回值类型相同，否则只能实现方法重载。

3、在Java规定，子类方法的访问权限不能比父类中被重写的方法的访问权限更小，必须大于或等于父类的访问权限。

4、在重写的过程中，如果父类中被重写的方法抛出异常，则子类中的方法也要抛出异常。但是抛出的异常也有一定的约束--->子类不能抛出比父类更多的异常，只能抛出比父类更小的异常，或者不抛出异常。例如：父类方法抛出Exception，那么子类就只能抛出IOException或者抛出比Exception小的异常或者不抛出异常。

示例：

package com.gx.extendsdeom;

* 这是父类的定义

public class Person {

public void eat() {

System.out.println("=====你爸爸叫你吃饭了=======");

}

public void sleep(){

System.out.println("=====你爸爸叫你睡觉了=======");

}

package com.gx.extendsdeom;

* 这是子类的定义并输出结果

* 子类重写父类的方法后，在实例化子类的时候则调用的是子类中的方法，父类的方法就如同被覆盖了一样。

* 如果在子类中需要调用父类的方法，则在子类方法中使用super关键字调用父类的方法，格式：super.父类中的方法名(参数列表)

public class Student extends Person {

@Override

public void eat() {

System.out.println("===你爸爸叫你吃饭了===");

}

@Override

public void sleep(){

System.out.println("=====你爸爸叫你睡觉了=======");

}

// main方法测试

public static void main(String[] args) {

Student student = new Student();

student.eat(); //输出：===你爸爸叫你吃饭了===

student.sleep(); //=====你爸爸叫你睡觉了=======

}

十二、进制转换：

一二三四五六七八九十十一十二十三十四十五十六

0 1 2 3 4 5 6 7 8 9 A B C D E F

如何实现进制之间的转换，你可以选择任何一种进制为基准，然后在进行转换，本例主要是以10进制为中间位，根深蒂固的一些问题。一些具有特殊关系的进制之间转换可以，2进制和他的2N进制；例如8进制的12 ，我们可以把他搞成2进制来看待， 0001 0010 ，然后把10010这个就是8进制12转换为2进制的结果

实现过程：

1、把任意一个进制转换为10进制，这个是相当容易的。例如我有X进制的ABCD 。我把他转换为10进制就等于 A*X3+B*X2+C*X+D；

2、然后再把10进制转换成你要转换成的进制数，参考下图计算规则：

整数的四表现形式：

二进制：0，1 满2进1

八进制：0-7 满8进1.用0开头表示

十进制：0-9 满10进1 默认进制

十六进制：0-9 A-F 满16进1.用0x开头表示

十进制

2560=2*10^3+5*10^2+6*10^1+0*10^0

abcd=a*10^(4-1)+b*10^(3-1)+c*10^(2-1)+d*10^(1-1)

二进制

1111=1*2^(4-1)+1*2^(3-1)+1*2^(2-1)+1*1

=8+4+2+1

=15

八进制

7777=7*8^3+7*8^2+7*8^1+7*1

=7*512+7*64+7*8+7

=3584+448+56+7

=4095

十六进制

FF =15*16+15

=240+15

=255

二进制->十进制:

第一步：写2

第二步：标指数。从右向左，从0开始依次标记

第三步：乘系数。一一对应

第四步：相加。

例：二进制数：1101，转十进制。

第一步： 2 2 2 2

第二步： 2^3 2^2 2^1 2^0

第三步： 1*2^3 1*2^2 0*2^1 1*2^0

第四步： 1*2^3+1*2^2+0*2^1+1*2^0=13

口算方法：8 4 2 1

十进制->二进制：除2取余

第一步：用竖式，对十进制数依次除2，记录每一步余数。

第二步：一直除到商0为止，从下倒上记录余数，即是2进制数。

进制转换：

752=2*10(0)+5*10(1)+7*10(2)

1011=1*2(0)+1*2(1)+0*2(2)+1*2(3)

=1 + 2 + 0 + 8 =11

二进制数：0 1 0 1 0 1 1

结果： 64 32 16 8 4 2 1 =43

111=7 1111=15 11111=31 1111-1111

010-101-110

2 5 6 八进制表示：0256

-1010-1110

10 14 十六进制表示：0xAE

6 / 2 =2余：0

3 / 2 =1余：1

1 / 2 =0余：1

结果：6=110

结论：八进制数，其实就是二进制位3个二进制位一个八进制位。

十六进制：其实就是二进制中的四个二进制位为一个十六进制位。

负数的进制：

其实就是这个数的正数的二进制取反，加1

-6

0000-0110

取反1111-1001

+ 0000-0001

------------------

1111-1010 -6

负数的二进制的最高位是1

1011 =11

+0110 =6

----------

10001 ==17

11+6 = 17

十三、初始化块：

初始化块(initializationblock)

执行顺序：静态初始化块，初始化块，构造器

属性、方法、构造方法和自由块都是类中的成员，在创建类的对象时，类中各成员的执行顺序：

1.父类静态成员和静态初始化快，按在代码中出现的顺序依次执行。

2.子类静态成员和静态初始化块，按在代码中出现的顺序依次执行。

3. 父类的实例成员和实例初始化块，按在代码中出现的顺序依次执行。

4.执行父类的构造方法。

5.子类实例成员和实例初始化块，按在代码中出现的顺序依次执行。

6.执行子类的构造方法。

一个类中可以有多个静态初始化块和多个普通初始化块；

静态初始化块的执行要早于普通初始化块；

同一个类型的初始化块的执行顺序取决于定义的先后顺序

示例：

public class Test {

/**

* Description

* @param args

public static void main(String[] args) {

Son s = new Son();

}

class Parent{

{

System.out.println("parent中的初始化块");

}

static{

System.out.println("parent中static初始化块");

}

public Parent(){

System.out.println("parent构造方法");

}

class Son extends Parent{

{

System.out.println("son中的初始化块");

}

static{

System.out.println("son中的static初始化块");

}

public Son(){

System.out.println("son构造方法");

}

十四、单例类：

代码包名:singleton

单例模式有以下特点：

1、单例类只能有一个实例

2、单例类必须自己创建自己的唯一实例

3、单例类必须给所有其他对象提供这一实例

//懒汉式单例类.在第一次调用的时候实例化自己

public class Singleton {

//隐藏构造器

private Singleton() {}

//实例化

private static Singleton single=null;

//静态工厂方法

public static Singleton getInstance() {

if (single == null) {

single = new Singleton();

}

return single;

}

注意：Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问

1、在getInstance方法上加同步

public static synchronized Singleton getInstance() {

if (single == null) {

single = new Singleton();

}

return single;

}

2、双重检查锁定

public static Singleton getInstance() {

if (singleton == null) {

synchronized (Singleton.class) {

if (singleton == null) {

singleton = new Singleton();

}

return singleton;

}

3、静态内部类

public class Singleton {

private static class LazyHolder {

private static final Singleton INSTANCE = new Singleton();

}

private Singleton (){}

public static final Singleton getInstance() {

return LazyHolder.INSTANCE;

}

//饿汉式单例类.在类初始化时，已经自行实例化

public class Singleton1 {

private Singleton1() {}

private static final Singleton1 single = new Singleton1();

//静态工厂方法

public static Singleton1 getInstance() {

return single;

}

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的

两者之间的区别：

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例

以及线程安全和资源加载和性能的不同

十五、final修饰符：

final从字面上理解含义为“最后的，最终的”。在Java中也同样表示出此种含义

final修饰符：

1、final修饰成员变量（实例变量和类变量（静态变量））---无法赋值（可以初始化）

2、final修饰局部变量----只能赋值一次（相对于初始化变量）

3、final修饰方法----不能被重写override

4、final修饰类----Sting就是一个被final修饰的类，我们只能用，不用继承注意:(面试题经常问道)

final修饰成员变量示例：

public class FinalMemberVariables {

// final 修饰的实例变量

// 必须在非静态初始化块、声明该实例变量或构造器中指定初始值，

// 而且只能在三个地方的其中之一指定。

//声明该实例变量指定初始值

final int INT_A=10;

//初始化块指定初始值

Java基础学习总结

悦读