目录
1.文档注释
2.类
3.main方法
4.输出println
5.变量和数据类型
6.进制与补码
7.运算符
8.流程控制
9.数组
10.类与对象
11.object类
12.单元测试编辑13.基本数据类型、包装类、String、Object转换
14.static 关键字
15. 单例设计模式
16.代码块
1.文档注释
可以生成介绍的网页用浏览器打开。
形式区别于多行注射。多行注释以*/结束 ，
可以生成介绍的网页用浏览器打开。
形式区别于多行注射。多行注释以*/结束 ，
ecilipse中写/**再回车可以自动生成，点击windows——preferences——java——code Styles——code templates——comments——types设置
2.类
一个源文件可以有无数个类，但是不能都用public，只有和源文件名相同的一个类才可以用public修饰。
在ecipse中，
3.main方法
main(String[] args)的args名字可变，[]前后可变。在控制台cmd时，可以在java 文件名后输入空格隔开的字符串作为args的元素，在eclipse中的run configuration中的argument可以同样输入。一个源文件中的类都可以有main函数，可以用类.main的方式调用。
4.输出println
4.1.System.out.println();可以不写东西单纯换行，输出时先输出后换行。
4.2用print的方式输出时，System.out.print(“%d”,变量)，为了对齐也可以%20d，%15d，表示占据了多少个格子
4.3 n这类，可以用\n来取消，“1n2”这种会直接换行
5.变量和数据类型
5.1其他语言可以用var表示变量，JAVA只能申明类型（强和弱） 。
5.2变量的声明和赋值可以分开进行。Java中的变量声明必须在使用前面，也就是顺序必须由上到下，而方法却可以在使用之处的下方；若想在变量声明顺序前使用变量，就把变量用方法return出来。
5.3变量若未赋值，使用会提示未初始而不能使用。区别于数组，数组new动态初始化后，其元素都有默认值，可以打印出来。
5.4引用数据类型包括了类、数组、接口，但都和基本数据的声明规则一样：数据类型 名称，所以int a与Person p、String str、Person persons[]这些都差不多，都是变量，指向内存中一个储存区域。
5.5浮点数
float类型的小数点后只有七位有效数字，四舍五入了。但表示数的范围比long（2的63次方）还大。
浮点数默认为double而不是float，比如12.2是个double类型，就不能
float a=12.2+1；
若不加f，float b=（float）12.2；
5.6自动类型转换：小的数据可以直接用大的接收。
5.6.1 char与int、short、byte计算，自动转成int，即使是同类型的运算也是，包括两个char相加也是int，’a’+’n’不能实现换行效果。
5.6.2 Long l = 12;没有加L也不报错，这是把右边的数据类型当成了int而提升了，若数的位数很多则会报错。
5.6.3 char类型和int类型一般来说，char要用‘’括起来，int类型的则只有数字，如：
char a = ‘a’; int zero = 48；
可以直接把数字按ASC码赋给char，把字符赋给int：
char a =97；int zero =‘0’；//打印后，a是字符a，zero是数字48 char b=‘a’+1；int forty_nine=‘0’+1；//b=‘b’（先用ASC加和再转），forty_nine=49
Note：上图中，char a =97，后续a参与运算时，都是用的97，比如
char a =97；int b =97；//a==b是true
对于变量赋值，char变量可以直接到int，int变量到char却需要强转（char） b。
char类型的数字换成int技巧：读到的字符减去48或‘0’：
char c9 = '1'; int num9 = c9 - '0'；//字符1得到数字1，或减去48 int num10 = 1;char c10 = (char)(num10 + '0');//数字1得到字符1，或+48 字符a~z用数字1~26表示的技巧：对于1-9，int aNum=‘a’-96；
5.7强制类型转换:大的数据类型用小的数据类型接收。
5.7.1基本数据类型，用（目标数据类型）变量的方式，有精度损失的风险，如double a=12.2;int b =（int）a;//a=12
5.7.2 String:String str = “123”;不能int a=（int）str，只能int a=Interger.parseInt(str);
5.8 String
String与其他类型相加，是拼接，全部变成String类型，但是String+1+1变成String11，而1+1+String变成2String，若不想他们变成加，就在最开头放上字符串或加空字符串或1+(1+String)。Char与String可以直接拼接。
5.9 byte
不考虑原码补码的话，0111 1111 代表127，1000 0000只代表128（2^7），1111 1111代表255（八位的最大值）；考虑原码补码，1000 0000只代表-128（-128的绝对值补数为128），1111 1111代表-1；1000 0000在int中，第32位一直到倒数第9位都是0，故为128，用byte接收int型数字128，从尾向前截断8位成了负数的补码
1111 1111（-127原码）， 1000 000（反码）+1=1000 0001（-127的补码）
1 1000 0000（-128原码进位舍去第9位的1，第八位1变成符号位不变），
1111 1111（反码） +1=1 0000 0000（-128的补码再舍弃一个第9位，第八位变成符号位即1000 0000）
结论：除了-128，其余都可以正常进行补码和原码之间的运算。
6.进制与补码
6.1 8bit原码：第一位为符号位，所以后面七位组成了0~127的数。唯独-128因为位数溢出而用-0即1000 0000表示。
计算机底层中，每一个数据类型只能有一个固定的内存空间，若结果产生了进位而溢出，则舍弃最高位，从0开始，也就是取模。以100为模数，（30-2）%100=（30+98）%100=[30+（100-2）]%100=28，所以减一个数等于加上用模数减去该数，也就不需要减法运算了，在此例中，减去2的效果和加98的效果相同，故-2=98，同理50~99的都可以表示-50~-1
对于8位二进制而言，原本应该是从0000 0000 到1111 1111 表示0~127,128~255共256个数，以十进制为例，128~255的数为-128~-1的绝对值的补数，负数的保存方式为补码，实际上是他们补数的绝对值的二进制码，比如X-1=X+（256-1），-1的补码如果直接读，是255，与-1取反码加一的结果一样。
储存负数时，原码符号位为1，其余位先取反得反码，再在末尾加一，结果为补码；得知一个首位为1的二进制数，反推其原码，补码减一再取反。
6.2进制转换的java类库：Interger中比如toOctalString转八进制
7.运算符
7.1算数运算符
a.除法，两个int相除，结果为int，舍弃小数并且不四舍五入。如下，先有了int的结果再提升为double的。
a=2,b=3; double c=a/b;//c=0.0
b.自增++、自减--、+=、-=这些可以对short、byte这些使用而不变数据类型，而short=short+1则不行。
note1：
int i=1； i*=0.1;//i=0 //int j=i*0.1；报错
note2：即使是在同一条语句之中，变量的值依旧是在变而且不会统一变动，i前面拿到的值为10，之后i变为了11、12但是不会更新i的值。
int i = 10; i += (i++) +(++i);//i = i + (i++) +(++i) // 10 + 10 +（11+1）=32
c.boolean型变量也可以赋值。
7.2 位运算符
a.只能对整型（int、short、byte、long）的进行二进制的操作。<
b.取反“~”，跟原码无关了，都按补码来按位取反，符号位也跟着动。~6 = -7，~（-7）=6
c.异或^，a^b^a=b,a^b^b=a,可以实现交换a、b两数的功能，也可以实现给a加锁的功能。
7.3三元运算符
（条件判断）？表达式1：表达式2；其中1、2的类型要相同，若一个为double一个为int，则自动提升为double。
三元运算符的优先级高于赋值，下图中先执行true?…，再用表达式1给01赋值，结果为1.0。
8.流程控制
8.1if ……else if……else中的else不是必须的，但else if和if、else if之间互斥，只要满足一个条件就直接退出if结构了。若条件之间有包含关系，比如大于30和大于40，若大于30写在上边，则不会执行大于40这一条，所以要把条件更小的写在上边。同时如果if和else后面没有写括号，则只会跟一句话，其余语句不属于这个结构。
if（a>1）
a=1;
b=2;//和if无关
8.2.a.Switch语句中，case后一般要加上break，否则其他选项都会接着执行且不判断。
switch（i）{
case 1:
语句；
break；
……
default：//相当于if-else中的else，是可选的，如果都匹配不上，就跟if条件都不满足自动跳过一样。位置无所谓，但是执行时都是最后执行
break；
}
b. i 的类型不能是boolean、float、double（eg.3.5）、long，必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)
c.case后值必须是常量，不能是变量名（case i ：）或不确定的表达式值（case age>18：）
d.多个case执行语句相同，可以考虑合并，相当于没有break而执行下一条。
case 1：
case 2：
case 3：
执行语句1；
break；
8.3循环结构
a.for循环的格式为for（初始化条件；循环条件；迭代部分）{执行语句；}
int i = 0 ，a = 2；
for（System.out.println(i)；i<3；a++，i++）{}//这种结构也是允许的
b.while和for循环都是先判断后执行，do-while是先执行后判断，至少一次执行，而for的条件不符合就可以一次都不执行 。所以while和for循环如果以int i=0；i<2为例，终止时i是2，共执行了2次执行语句，迭代了2次，进行了3次循环条件判断。而do-while会执行2次语句，2次迭代，2次判断。
c.无限循环：while（true）和for（；；）
d.嵌套循环，相当于n维数组和n层树结构的逻辑，2重循环，外层控制行，内层控制列。先执行完一次内层循环，再给外层迭代次数加一，进行外层下一次循环。
e.break结束本次本层循环，若想结束其他外层循环，可以用如下方式：
X：for（int i ……）{
for（int j……）{
break X；//X为任意名字，一般是label，可以多个：label1、label2
//continue X；结束某层的当次循环
}
}
9.数组
9.1一维初始化以及默认值
int a[];
a[]=new int[]{1,2};
int a[];
a[]={1,2};//不合法，换行后就要加new
int a[]={1,2};//类型推断，不是标准写法，可以用，二维的也可以
数组动态初始化后，其各个元素都有默认值，若元素是数组（引用类型） ，默认为null。
char型数组的元素初始化值不是'0'，而是unicode的或ASCII的数字0，但又不是int的0，打印出来是空白。
boolean型数组元素默认值为false，因为底层的false也是用0来代替的。
9.2一维内存解析
int a[] =new int[3];
对于在方法中声明的数组，数组的名字a放在栈空间中，其值为所代表的数组对象在堆的首元素地址值，若使用新的数组给a赋值，则a的值变为新数组首位地址值，原先的数组无被引用处，自动回收。同时方法使用完毕，栈中的名字a出栈，堆中的数组对象一样回收。
9.3二维数组
a.定义：一维数组的各个元素也是一维数组,静态初始化时，都是{{}}而不是{（）}。
note：不需要第二层数组之间一样的个数，比如{{1,2,3}，{1,2}，{1,2,3,4}}
b.动态初始化时可以int a[] []=new int [3] [2]也可以int a[] []=new int [3] []，若后者，此时a[0] = null,因为还没有造第二层的数组，所以没有第二层数组的首地址传给第一层数组的元素，也可以这样认为：第一层数组的每个元素都是数组为引用数据类型，默认为null；同时也不能引用a[i][j],相当于是null.[j],第二层数组还没有声明，会报空指针异常。
int a[] []=new int [3] [2]，此时a[i]是地址值，a[i][j]默认为0，打印a，则一样是第一层数组的地址值。
c.a.length是第一层数组的长度，a[i].length才是第二层的长度。
9.4数组赋值和复制
int array1={1,2,3};
int array2 = array1;
上式中，堆空间其实只有一个数组的连续地址，但是同时指向array1和array2，两个变量的地址值相同；array2=array1的操作是把数组的首地址值给到array2，当array2对数组进行修改时，用array1调用的数组也会变。并没有实现复制的功能，只能是共享或者创建了快捷方式。
真正实现复制，需要新建一个对象，两个数组的地址不一样，逐一遍历赋值就行 。
9.5空指针异常
a.数组的某个元素为null，打印该数。
b.数组的某个String元素为null，对该String元素调用toString方法。
10.类与对象
10.1对象的赋值
Person p1 = new person():
Person p3 = p1;
栈中存放局部变量、对象引用（即对象名对应的对象在堆中的首地址值，引用数据类型的变量只能储存两种值，1是null，2是地址值），而对象实例都储存在堆中，p3=p1相当于把p1的地址值传递给了p3，一个堆中的对象指向栈中两个对象名，修改时，p3、p1都能对对象进行修改。这和数组的赋值是一样的。
Note：基本数据的赋值，是直接把变量的值复制给对方一份,此次的改动都不会影响对方。实参给形参的值内存解析见10.7。
int a =10;
int b = a;
a++;//a：11，b：10
b++;//a：11，b：11
10.2局部变量和属性（成员变量）区别
a.局部变量包括形参（方法传入的和方法内定义的、构造器内定义的和传入的、代码块里定义的），都不允许加入权限修饰符（public、privite等），可以理解为方法本身的权限修饰符已经定义了，而属性（定义在类的一对{}中）允许加入修饰符。
b.属性有默认值，只用声明就可以使用，而且属性为了让对象自己去给属性赋值，类中一般都不会对属性进行显示赋值；而局部变量没有初始化值，必须初始化后才能使用，也就是前面提到的，在main方法中定义的变量都是局部变量，都是要先赋值才能使用，而在main以外，类以内定义的成员变量都有默认值。特别的：形参在方法中调用时赋值即可，如下。
class ATest{
int i;//为了不同的对象有不同的i，此处不显示初始化。
void prt(c) {
boolean a;
System.out.println(i);//0
System.out.println(a);//报错System.out.println(c);
}
}
c.内存区域不同，非static的属性存在堆空间中，static的属性在方法区中，而局部变量在栈空间。
10.3类的格式
类中只有两种东西，属性和方法，因此也就不能在类中直接写执行语句，所有的执行语句必须写进方法内，比如写进main方法中。
class ATest{
int i;System.out.println(i);//错误，甚至连System都不能调用
void prt(b) {
boolean a = b;
}
}
10.4方法的声明和调用
如果有返回值，但是有if这种结构，任何分支情况都要考虑到return否则报错。若返回是void类型，额可以用‘’return；‘’来结束。
public void eat(int i){
eat（10）；
}
如上，方法中如果调用自己，就是递归，若无尽头，则会在栈空间里无限声明局部变量，最终导致栈溢出而报错。
10.4匿名对象
new xxx（）.xx来调用其中功能，或用来给形参传递值，前者匿名对象只能用一次，后者可以用多次。
public class HelloWorld(){
……
Atest A =new ATest()；
A.show(new HelloWorld());//常用这种方式，此时匿名对象的地址值传递给了方法，方法中可以多次使用该对象
}
class ATest{
void show(HelloWorld aWorld) {
System.out.println("hello");
}
}自己
10.5方法的重载
public void Promise(){};权限修饰符和返回值类型、方法体变了也不构成重载。
10.6可变个数的形参
JDK5.0之后：参数列表格式为‘’数据类型…形参名‘’，public void Promise(String… 形参名){};调用时可以Promise("1","a")这样用逗号隔开多个同数据类型的形参，形参个数也可以为0。可变个数形参只能声明在参数列表的末尾。如（int i，String…str）
10.7形参的值传递
a.实参如果是基本数据类型，则把自身的值传递给形参m（形参）=m（实参），等同于复制了一份过去，两边的操作互不干扰。
b.实参如果是引用数据类型，也就是对象，把m和n当成一个对象的属性，再将形参的数据类型变为引用数据类型，则实参的地址值传递给形参，一个对象指向两个变量名，都可以对其更改。
Note：要想避免方法只变形参部分的基本数据类型的数据，就把方法改写为要对引用数据类型进行操作，比如要传递一个数组进来作为形参，方法体中也是直接对数组元素进行操作。或者用this关键字如下。
class A{
int age=1；
public void setAge（age）{
age=age；//不报错，但是无法对属性的age进行修改，要加this
}
}
10.8局部变量和对象名的出栈
随着main方法的进行，对象创建、方法中的局部变量开始赋值，栈空间开始储存变量名，随着方法的逐渐运行结束，后进栈、后运行的方法中的变量以及对象名都出栈了，于是堆中的内存成为垃圾被回收。重点在于一个方法结束后，堆中同名的不同地址的变量就会消失一个。
10.9引用数据类型的打印println
System.out.println()各种重载方法中，传递其他的对象或者数组a，println（a）都是其地址值，但若传递进来的是一个char[]，则是打印数组中的元素
10.10权限修饰符
private、缺省（同一个包）、protected（不同的包的子类）、public，最小是只能在本类中使用，最大是一个工程的包都能使用。
类只能用缺省和public两种修饰，如果用缺省，则不同包下，类也不可用，即使是引用也不行。
不同包下，非子类，不能用对方类中privite、缺省、protected的属性和方法。
通常只用private/public。
10.11构造器
作用：创建对象；初始化对象信息。
与方法、类的格式区别：
public class Atest{//类只能用缺省和public两种修饰，不能有括号（）和返回值
public Atest（形参列表）{}//可以多个构造器，不用再写class
public void test（形参列表）{}
}
构造器原本有默认无参的，如果自己重写了带参的构造器，那么原本无参的也不在了，所以如果重写了带参的构造器，要把无参的也一并定义了。
给类的属性赋值的先后顺序：默认初始化（int a；）、显示初始化（int a =0；）、构造器初始化、“对象.属性”或“对象.set方法”
10.12JavaBean
格式：1.公共类。2.公共无参构造器。3.属性带有get、set方法。
10.13 this关键字
this表示当前正在创建的对象或者当前对象。往往省略，当构造器、方法的形参名字和属性名字相同时必须调用。
当构造器需要考虑多种初始化情况（代码量大）并且有多个重载的构造器时，可以在无参构造器中把代码写好，用this（形参列表）的方式在其他构造器首行中调用（不能this（形参变量）调用自己），减少代码量。n个构造器，最多只有n-1个调用其他构造器，且不能回调成环（无限递归），也不能有多于1个this（形参列表）。
10.14 package
用于表示当前类所属的文件目录，在首行定义。
10.15 import
一般都只用来引入其他包下的类、接口，在包声明和类声明之间，也可以直接用“xxx.包.*”的方式引入一个包下的所有类。只用在ecilpse中点一下标红的类名引入即可。
Java.lang包下类不用引入，比如String和System、math，非lang都要调。
本包下定义的类也不用导，MVC设计模式下，都在不同包里，要引入。
引用不同包下的同名类，至少一个类要用“包名.类名”的方式，且不再import该包。
import static：引入类中的静态结构（不再是引入类），用法为import static 包名.类名.*，之后再在源代码中可以省略此类名，比如Math和System可以省略。
10.16继承
格式：class A extends B{}，子类获得父类生命的所有方法、属性。
当父类中有私有结构时，子类一样继承了，但是只有当父类声明了get、set方法才能对私有属性进行操作，封装性在起作用。所有类都直接或间接继承java.lang.object类
10.17重写
对父类方法重写，同名同参方法对父类方法进行覆盖。常常直接复制父类方法头或者写一半alt+/重写。
权限修饰符 返回值类型 名称（形参列表）{}
a.子类重写方法的权限大于或等于父类的。父类私有方法不能重写。
b.父类的方法是void类型不能改写为其他类型。若返回的是类（object）类型，则重写时可以把返回值写成它的子类。若返回是基本数据类型，则不能变，int——double不允许。
c.子类的抛出异常要小于或等于父类异常类型，比如父类抛出exception，子类抛出RunTimeException
d.只有非static类型的方法才能被重写，因为static的是随类而加载的不能被覆盖。
10.18 super
背景：子类可以对父类方法重写，子类也可以定义和父类名字相同的属性且不会被覆盖，此时想调用父类的属性和方法
可以在子类构造器中使用super（形参列表）调用父类构造器，如果不写，默认调用super（），super和this一样写在首行，二选一，最多n-1个this，所以最少一个super。子类会将其所有父类的构造器都调用，最终调用lang.object类构造器，所以子类的对象中才会有父类的所有属性和方法，才有了任何类的对象都可以直接使用math、System的方法，虽然调用了父类构造器，但是只有一个对象。
若子类用了super（）而直接父类没有写空参构造器，则会报错。
10.19 多态性
Person p = new man();父类的引用指向子类的对象。编译看父类（左）有哪些方法，只有父类有的东西，对象p才能引用，凡是子类自己加的东西都用不了，但是子类的所有属性和方法都已经在堆中加载了，只是用不出；运行时看子类（右）重写的方法。该过程叫虚拟方法调用。
多态只适用于方法不适合属性，属性都是调用父类的。
多态是运行时行为，也就是只有把子类传进来才能确认要使用哪种方法。多态时，父类方法也称虚拟方法，编译时不知道调用方法的地址、运行时调用子类方法的过程叫动态绑定。而编译时就已经知道调用方法的地址，叫静态绑定。
好处：可以只用在形参中声明一个父类，而不用根据不同的子类写重复的方法。
和基本数据类型double和int互相换一样，父类和子类对象也能转换，从子类变成父类对象，向上转型，是多态，自动进行；从父类Person对象到子类对象Man，是向下转型，属于强转，后者可以调用子类特有的属性和方法。Note：无子父类关系的类不能强转
强转时可能会报错，所以要用instanceof关键字,看a的本质是什么，a instanceof A对象a是否是类A的实例，返回boolean，如果A是，则a也是A的父类比如Person、object的实例。
Person p = new Man();//p的本质是man
if(p instanceof Man){
Man m =(Man) p;}
Person p = new Person();//报错，因为p根本没有子类Man的结构
Man m =(Man) p
Object p = new Man();//因为可以直接把父类object转成Man，Man又可以自动转成Person类的对象
Person m =(Person) p
11.object类
11.1 equals
==：运算符，用于基本数据类型和引用数据类型，不一定要求两边数据类型相同，比如'a' ==97、
10.0 == 10。比较前者，数值是否相同；比较后者，比较地址值。注意：String型变量的值如果不是用的new而是String i=“”这种，储存在常量池中而不是堆中，所以两个的值如果相同，则不会生产新的空间，两个地址值相同，两个String用==结果为true，但如果都是new出来的就不同。
// String i = new String("AA");
// String j = new String("AA");
String i ="aa";
String j ="aa";
System.out.println(i==j);
equals是类中的方法，只能用对象去调用而不能用基本数据类型变量调用，比如int i = 10；i.equals();
在Object类中的equals方法和==作用一样。在String、Date、File、包装类中重写了equals方法，只比较属性内容，也就是String型的变量.equals（），是比较属性内容。
Note：重写equals方法可以自动由eclipse生成，往往想要达到自己的想要比较成员变量是否相同的目的，此时，如果一个String类型变量使用了equals方法，则用的还是String重写的方法而不是递归，若比较的属性中含有对象的比较，则该对象对应的类中的equals也要重写。
int id；
String name；
Person p；
…
重写equals：
return this.id ==a.id && this.name.equals(a.name) && this.p.equals(a.p)
11.2 toString
Object中toString方法输出当前类的类名@16进制的虚拟地址，也就是任何对象点toString都是如此。当输出println一个对象的引用时，也就是调用一个对象的toString方法。
在String、Date、File、包装类中重写了toString方法，输出实体内容信息。可以重写以表示当前类的属性，在当前类重写toString后，本类的对象引用的不再是Object类的方法而是自定义的toString，同样可以自动生成。
12.单元测试13.基本数据类型、包装类、String、Object转换
包装类：Byte、Short、Integer、Long、Float、Double、Boolean、Character ，将基本数据类型作为属性封装在类中，在形参为Object的方法中可以传递进去。
基本数据类型转包装类：调用对应包装类的构造器。以前：Byte b =new Byte（数值或字符串），新的版本构造器名字已经隐去，叫自动装箱，只用Integer i =10；//或“10”这样就行。如果是数值的-128到正127，不用构造器,超出才用。 Not:1：当基本数据类型变量变成包装类作为属性时，默认值是null。 Note2：形参为Object类，JDK5.0之后可以直接把基本数据类型装进去。
包装类转基本数据类型：原本为——包装类的对象名 . xxx(基本数据类型名称)Value(空参)，再用新数据类型变量接收。如int i = aInteger.intValue();float f = aFloat . floatValue（）。JDK5.0后自动拆箱是直接用新变量接收就行，如下。
Integer i = 3;
int i1 = i;
基本数据类型转String：1.与“”拼接。2.用String中的valueOf方法。
String str = String.valueOf（i）；
*String转基本数据类型：途经包装类。包装类名. parseXxx（String str）方法，如：
int num = Integer.parseInt(str);
包装类转为String：1（常用）对象名. toString，再用String接收。 2.包装类名. toString（对象名），再用String接收。
Float j = 0.1f;
System.out.println(Float.toString(j));
String转包装类：同基本数据类型转包装类是同一方法，自动装箱即可。Integer i ="10"；
Object类转包装类，由于是子父类，直接强转，由Object到基本数据类型也要经由包装类，JDK5.0之后可以直接用基本数据类型来强转
Object obj = ……；
//integer i =（Integer） obj；
//int aInt = i；
int aInt = (int) obj;
14.static 关键字
来源：每一个实例对象共有的东西就不需要新建对象时都去声明，所有对象共享一份即可。
用途：修饰方法、属性（无法修饰局部变量）、代码块、内部类。
以有无static修饰，属性分为静态属性（类变量）和非静态属性（实例变量），前者所有对象的该属性一起被修改，后者对其他对象无影响。静态变量早于对象的创建，只加载一次，储存在方法区的静态域中。
被static修饰的方法、属性随类的加载而加载，可以不创建对象，直接类名点方法或属性直接调用。比如system、math。
静态方法中（比如main函数），只能调用静态方法或属性（不能使用this和super因为静态方法是属于类的而不是对象，所以不能通过对象调用，可以省略的是类名.方法中的类名、不能调用本类的实例变量因为它们都还没加载），对于非静态的方法、属性，必须通过对象去调；对于非静态方法，都可以调用。
Note：
15. 单例设计模式
让某个类只能存在一个实例对象，禁止外界通过构造器造多个对象，自己在类中生成一个静态对象给外界使用。
15.1饿汉模式（提前造好，可能会在内存中加载时间过长，但线程安全）
15.1懒汉式（用的时候再造，线程不安全，可能多个线程在调用方法时都判断没有对象，就会重复造出对象）
16.代码块
代码块、构造器的执行顺序：由父及子，静态先行。main方法也是静态方法，要先加载类，加载子类前要加载父类，所以执行子类静态结构main之前先把父类静态结构执行完，再由父类构造器到子类构造器。
