2022年全套详细笔记心血放出资料

1、目录 TOC o 1-3 h z u HYPERLINK l _Toc4 1.原码、反码、补码 PAGEREF _Toc4 h 1 HYPERLINK l _Toc5 1.1.原码 PAGEREF _Toc5 h 1 HYPERLINK l _Toc6 1.2.反码 PAGEREF _Toc6 h 1 HYPERLINK l _Toc7 1.3.补码 PAGEREF _Toc7 h 1 HYPERLINK l _Toc8 1.4.负数的补码转换为十进制数 PAGEREF _Toc8 h 2 HYPERLINK l _Toc9 2.char PAGEREF _Toc9 h 2 HYPERLINK

2、 l _Toc0 3.运算符 PAGEREF _Toc0 h 2 HYPERLINK l _Toc1 3.1.移位运算符 PAGEREF _Toc1 h 2 HYPERLINK l _Toc2 3.2.位运算符 PAGEREF _Toc2 h 3 HYPERLINK l _Toc3 3.3.逻辑运算符 PAGEREF _Toc3 h 3 HYPERLINK l _Toc4 4.流程控制 PAGEREF _Toc4 h 3 HYPERLINK l _Toc5 4.1.switch PAGEREF _Toc5 h 3 HYPERLINK l _Toc6 4.2.break和continue PAG

3、EREF _Toc6 h 4 HYPERLINK l _Toc7 5.方法 PAGEREF _Toc7 h 4 HYPERLINK l _Toc8 5.1.构造方法 PAGEREF _Toc8 h 4 HYPERLINK l _Toc9 5.2.方法重载 PAGEREF _Toc9 h 4 HYPERLINK l _Toc0 6.this PAGEREF _Toc0 h 5 HYPERLINK l _Toc1 7.继承 PAGEREF _Toc1 h 5 HYPERLINK l _Toc2 7.1.super PAGEREF _Toc2 h 5 HYPERLINK l _Toc3 7.2.多态

4、（polymorphism） PAGEREF _Toc3 h 6 HYPERLINK l _Toc4 7.3.instanceof PAGEREF _Toc4 h 6 HYPERLINK l _Toc5 8.static PAGEREF _Toc5 h 7 HYPERLINK l _Toc6 9.final PAGEREF _Toc6 h 7 HYPERLINK l _Toc7 10.abstract PAGEREF _Toc7 h 8 HYPERLINK l _Toc8 11.类的加载 PAGEREF _Toc8 h 8 HYPERLINK l _Toc9 11.1.触发类加载的几种情况 P

5、AGEREF _Toc9 h 8 HYPERLINK l _Toc0 11.2.类加载的顺序 PAGEREF _Toc0 h 8 HYPERLINK l _Toc1 12.接口（interface） PAGEREF _Toc1 h 9 HYPERLINK l _Toc2 13.访问控制 PAGEREF _Toc2 h 10 HYPERLINK l _Toc3 14.Object类 PAGEREF _Toc3 h 11 HYPERLINK l _Toc4 14.1.clone() PAGEREF _Toc4 h 11 HYPERLINK l _Toc5 14.1.1.对象克隆过程 PAGEREF

6、 _Toc5 h 11 HYPERLINK l _Toc6 14.1.2.浅复制和深复制概念 PAGEREF _Toc6 h 12 HYPERLINK l _Toc7 14.2.finalize() PAGEREF _Toc7 h 12 HYPERLINK l _Toc8 14.3.equals(Object obj) PAGEREF _Toc8 h 12 HYPERLINK l _Toc9 14.4.toString() PAGEREF _Toc9 h 12 HYPERLINK l _Toc0 15.String类及对象池 PAGEREF _Toc0 h 12 HYPERLINK l _To

7、c1 15.1.String a=hello; PAGEREF _Toc1 h 13 HYPERLINK l _Toc2 15.2.String c=new String(hello); PAGEREF _Toc2 h 13 HYPERLINK l _Toc3 16.StringBuffer和StringBuilder PAGEREF _Toc3 h 13 HYPERLINK l _Toc4 17.主方法参数 PAGEREF _Toc4 h 14 HYPERLINK l _Toc5 18.方法的可变长参数 PAGEREF _Toc5 h 14 HYPERLINK l _Toc6 19.包装类

8、PAGEREF _Toc6 h 14 HYPERLINK l _Toc7 19.1.Number PAGEREF _Toc7 h 15 HYPERLINK l _Toc8 19.2.自动封箱/自动解封（Autoboxing/Unboxing） PAGEREF _Toc8 h 15 HYPERLINK l _Toc9 19.3.对象池 PAGEREF _Toc9 h 15 HYPERLINK l _Toc0 20.内部类 PAGEREF _Toc0 h 16 HYPERLINK l _Toc1 20.1.意义 PAGEREF _Toc1 h 16 HYPERLINK l _Toc2 20.2.四

9、种形式的内部类 PAGEREF _Toc2 h 16 HYPERLINK l _Toc3 20.2.1.静态内部类 PAGEREF _Toc3 h 16 HYPERLINK l _Toc4 20.2.2.成员内部类 PAGEREF _Toc4 h 17 HYPERLINK l _Toc5 20.2.3.局部内部类 PAGEREF _Toc5 h 18 HYPERLINK l _Toc6 20.2.4.匿名内部类 PAGEREF _Toc6 h 18 HYPERLINK l _Toc7 20.3.内部类的应用 PAGEREF _Toc7 h 20 HYPERLINK l _Toc8 21.集合框

10、架(Collection Framework) PAGEREF _Toc8 h 20 HYPERLINK l _Toc9 21.1.Iterator接口和Iterable接口 PAGEREF _Toc9 h 21 HYPERLINK l _Toc0 21.2.Connection接口和Connections类 PAGEREF _Toc0 h 21 HYPERLINK l _Toc1 21.2.1.java.util.Collection PAGEREF _Toc1 h 21 HYPERLINK l _Toc2 21.2.2.java.util.Collections PAGEREF _Toc2

11、 h 21 HYPERLINK l _Toc3 21.3.List（列表）接口 PAGEREF _Toc3 h 21 HYPERLINK l _Toc4 21.3.1.ArrayList PAGEREF _Toc4 h 22 HYPERLINK l _Toc5 21.3.2.LinkedList PAGEREF _Toc5 h 22 HYPERLINK l _Toc6 21.3.3.Vector PAGEREF _Toc6 h 22 HYPERLINK l _Toc7 21.4.Set（集合）接口 PAGEREF _Toc7 h 22 HYPERLINK l _Toc8 21.4.1.Hash

12、Set PAGEREF _Toc8 h 23 HYPERLINK l _Toc9 21.4.2.TreeSet PAGEREF _Toc9 h 25 HYPERLINK l _Toc0 21.5.排序的两种办法 PAGEREF _Toc0 h 25 HYPERLINK l _Toc1 21.5.1.java.lang.Comparable（可比较的） PAGEREF _Toc1 h 25 HYPERLINK l _Toc2 21.5.2.java.util.Comparator(比较器) PAGEREF _Toc2 h 26 HYPERLINK l _Toc3 21.6.Map PAGEREF

13、 _Toc3 h 26 HYPERLINK l _Toc4 21.6.1.HashMap PAGEREF _Toc4 h 26 HYPERLINK l _Toc5 21.6.2.Hashtable PAGEREF _Toc5 h 27 HYPERLINK l _Toc6 21.6.3.Hashtable下的子类Properties类 PAGEREF _Toc6 h 27 HYPERLINK l _Toc7 21.6.4.SortedMap接口下的TreeMap类 PAGEREF _Toc7 h 27 HYPERLINK l _Toc8 22.泛型(Generic) PAGEREF _Toc8

14、h 28 HYPERLINK l _Toc9 22.1.泛型特点 PAGEREF _Toc9 h 28 HYPERLINK l _Toc0 22.2.通配符 PAGEREF _Toc0 h 28 HYPERLINK l _Toc1 22.2.1.上限通配符： PAGEREF _Toc1 h 28 HYPERLINK l _Toc2 22.2.2.下限通配符 PAGEREF _Toc2 h 29 HYPERLINK l _Toc3 22.2.3.总结： PAGEREF _Toc3 h 29 HYPERLINK l _Toc4 22.3.运用 PAGEREF _Toc4 h 30 HYPERLIN

15、K l _Toc5 23.异常 PAGEREF _Toc5 h 30 HYPERLINK l _Toc6 23.1.异常处理基础 PAGEREF _Toc6 h 30 HYPERLINK l _Toc7 23.2.异常的类继承结构 PAGEREF _Toc7 h 30 HYPERLINK l _Toc8 23.3.常见的未检查异常 PAGEREF _Toc8 h 31 HYPERLINK l _Toc9 23.4.throw PAGEREF _Toc9 h 31 HYPERLINK l _Toc0 23.5.自定义异常类 PAGEREF _Toc0 h 32 HYPERLINK l _Toc1

16、 24.反射（Reflection） PAGEREF _Toc1 h 33 HYPERLINK l _Toc2 24.1.反射需要用到的类 PAGEREF _Toc2 h 33 HYPERLINK l _Toc3 24.1.1.java.lang.Class PAGEREF _Toc3 h 33 HYPERLINK l _Toc4 24.1.2.java.lang.reflect.Field PAGEREF _Toc4 h 34 HYPERLINK l _Toc5 24.1.3.java.lang.Package PAGEREF _Toc5 h 34 HYPERLINK l _Toc6 24.

17、1.4.java.lang.relect.Modifier PAGEREF _Toc6 h 34 HYPERLINK l _Toc7 24.1.5.java.lang.reflect.Mothed PAGEREF _Toc7 h 34 HYPERLINK l _Toc8 24.1.6.java.lang.reflect.Array PAGEREF _Toc8 h 34 HYPERLINK l _Toc9 24.1.7.java.lang.reflect.Constructor PAGEREF _Toc9 h 34 HYPERLINK l _Toc0 24.2.三种获得某个类的Class对象的方

18、法 PAGEREF _Toc0 h 34 HYPERLINK l _Toc1 24.2.1.Class c=Class.forName(类名); PAGEREF _Toc1 h 34 HYPERLINK l _Toc2 24.2.2.Class c=类名.class; PAGEREF _Toc2 h 35 HYPERLINK l _Toc3 24.2.3.Class c=对象名.getClass(); PAGEREF _Toc3 h 35 HYPERLINK l _Toc4 24.3.所能探查出来的类的特征 PAGEREF _Toc4 h 35 HYPERLINK l _Toc5 24.4.通

19、过反射生成一个类的实例 PAGEREF _Toc5 h 35 HYPERLINK l _Toc6 24.4.1.第一种方法 PAGEREF _Toc6 h 36 HYPERLINK l _Toc7 24.4.2.第二种方法 PAGEREF _Toc7 h 36 HYPERLINK l _Toc8 25.File PAGEREF _Toc8 h 36 HYPERLINK l _Toc9 25.1.构造方法 PAGEREF _Toc9 h 36 HYPERLINK l _Toc0 25.2.重点方法 PAGEREF _Toc0 h 37 HYPERLINK l _Toc1 25.3.目录 PAGE

20、REF _Toc1 h 38 HYPERLINK l _Toc2 26.流 PAGEREF _Toc2 h 38 HYPERLINK l _Toc3 26.1.字节流 PAGEREF _Toc3 h 38 HYPERLINK l _Toc4 26.2.字符流 PAGEREF _Toc4 h 40 HYPERLINK l _Toc5 26.3.节点流(Node Stream)： PAGEREF _Toc5 h 41 HYPERLINK l _Toc6 26.4.过滤流 (Filter Stream) PAGEREF _Toc6 h 41 HYPERLINK l _Toc7 26.5.Object

21、InputStream和ObjectOutputStream PAGEREF _Toc7 h 42 HYPERLINK l _Toc8 26.6.字节流转化成字符流的桥转换器 PAGEREF _Toc8 h 44 HYPERLINK l _Toc9 26.7.文本文件和二进制文件 PAGEREF _Toc9 h 46 HYPERLINK l _Toc0 27.线程 PAGEREF _Toc0 h 46 HYPERLINK l _Toc1 27.1.概念与原理 PAGEREF _Toc1 h 46 HYPERLINK l _Toc2 27.1.1.操作系统中线程和进程的概念 PAGEREF _T

22、oc2 h 46 HYPERLINK l _Toc3 27.1.2.Java中的线程 PAGEREF _Toc3 h 47 HYPERLINK l _Toc4 27.1.3.Java中的线程模型 PAGEREF _Toc4 h 47 HYPERLINK l _Toc5 27.1.4.一些常见问题 PAGEREF _Toc5 h 47 HYPERLINK l _Toc6 27.2.线程状态的转换 PAGEREF _Toc6 h 48 HYPERLINK l _Toc7 27.2.1.线程的七种状态 PAGEREF _Toc7 h 48 HYPERLINK l _Toc8 27.2.2.阻止线程执

23、行 PAGEREF _Toc8 h 50 HYPERLINK l _Toc9 27.3.线程的同步与锁 PAGEREF _Toc9 h 51 HYPERLINK l _Toc0 27.3.1.同步和锁定 PAGEREF _Toc0 h 51 HYPERLINK l _Toc1 27.3.2.静态方法同步 PAGEREF _Toc1 h 56 HYPERLINK l _Toc2 27.3.3.如果线程不能获得锁会怎么样 PAGEREF _Toc2 h 56 HYPERLINK l _Toc3 27.3.4.何时需要同步 PAGEREF _Toc3 h 57 HYPERLINK l _Toc4 2

24、7.3.5.线程安全类 PAGEREF _Toc4 h 57 HYPERLINK l _Toc5 27.3.6.线程死锁 PAGEREF _Toc5 h 58 HYPERLINK l _Toc6 27.3.7.线程同步小结 PAGEREF _Toc6 h 59 HYPERLINK l _Toc7 27.4.线程的交互 PAGEREF _Toc7 h 60 HYPERLINK l _Toc8 27.4.1.线程交互的基础知识 PAGEREF _Toc8 h 60 HYPERLINK l _Toc9 27.4.2.多个线程在等待一个对象锁时候使用notifyAll() PAGEREF _Toc9

25、h 62 HYPERLINK l _Toc0 27.5.守护线程（后台服务线程） PAGEREF _Toc0 h 63 HYPERLINK l _Toc1 27.6.并发协作-生产者消费者模型 PAGEREF _Toc1 h 64 HYPERLINK l _Toc2 27.7.volatile关键字 PAGEREF _Toc2 h 64 HYPERLINK l _Toc3 28.网络编程 PAGEREF _Toc3 h 65 HYPERLINK l _Toc4 28.1.TCP Socket编程 PAGEREF _Toc4 h 65 HYPERLINK l _Toc5 28.1.1.Serve

26、rSocket PAGEREF _Toc5 h 66 HYPERLINK l _Toc6 28.1.2.Socket PAGEREF _Toc6 h 66 HYPERLINK l _Toc7 28.2.UDP Socket编程 PAGEREF _Toc7 h 67 HYPERLINK l _Toc8 28.2.1.DatagramSocket PAGEREF _Toc8 h 67 HYPERLINK l _Toc9 28.2.2.DatagramPacket PAGEREF _Toc9 h 67原码、反码、补码原码将最高位作为符号位（以0代表正，1代表负），其余各位代表数值本身的绝对值（以二进

27、制表示）。为了简单起见，我们用1个字节来表示一个整数：+7的原码为：00000111-7的原码为：问题：+0的原码为：00000000-0的原码为：反码一个数如果为正，则它的反码与原码相同；一个数如果为负，则符号位为1，其余各位是对原码取反。为了简单起见，我们用1个字节来表示一个整数：+7的反码为：00000111-7的反码为：问题：+0的反码为：00000000-0的反码为：补码利用溢出，我们可以将减法变成加法。对于十进制数，如果从9得到结果5，可以用减法：9-4=5；因为4+6=10，我们将6作为4的补数，将上式的减法改写为加法：9+6=15；去掉高位1（也就是减去10），得到结果5。对于

28、16进制数，如果从C得到结果5，可以用减法：C-7=5；因为7+9=16，我们将9作为7的补数，将上式的减法改写为加法：C+9=15；去掉高位1（也就是减去16），得到结果5。在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为：1 00000000，进位1被丢弃。一个数如果为正，则它的原码、反码、补码相同；一个数如果为负，则符号位为1，其余各位是对原码取反，然后整个数加1。为了简单起见，我们用1个字节来表示一个整数。+7的补码为：00000111-7的补码为：负数的补码转换为十进制数先对各位取反；将其转换为十进制数；加上负号，再减去1。例如：，最高位为1，

29、是负数，先对各位取反得00000101，转换为十进制数得5，加上负号得-5，再减1得-6。charchar类型（2字节）用于表示Unicode编码的字符单元；char类型用于表示单个字符，通常用来表示字符常量。例如：A是编码为65所对应的字符常量。Unicode编码单元可以表示为十六进制值，其范围从u0000到uffff。除了可以采用转义序列符u表示Unicode代码单元的编码之外，还有一些用于表示特殊字符的转义序列符。如：转义序列名称Unicode值b退格（Backspace）u0008t制表(Tab)u0009n换行（Linefeed）u000ar回车u000d”双引号(Double qu

30、ote)u0022单引号(Single quote)u0027反斜杠(Backslash)u005c尽管char不是整数，但在许多情况中你可以对它们进行运算操作就好像他们是整数一样，这允许你可以将2个字符相加，或对一个字符变量值进行增量操作。运算符移位运算符只能针对二进制数据（整数） 右移，右移一位相当于除2取整，两位相当于连续除2取整而不是除4取整，看正数还是负数，正数右移的话高位补0，负数的话补1； 无符号右移（算数右移），不考虑符号位，移进来的都补0。位运算符& 按位与，两个数按位与，全部转换成二进制后按位比较，全为1才是1，其它是0，返回一个新的整数；| 按位或，两个数按位或，全部转换

31、成二进制后按位比较，全为0才是0，其它是1，返回一个新的整数； 按位异或，两个数的二进制位数比较，相同结果为0，相异结果为1； 按位求反，把一个数二进制的每一位都反过来。逻辑运算符& 短路与，两边如果左边是假的话就不再判断右边的，直接返回假；| 短路或，两边如果有一个为真的就不再判断右边的，直接返回真；& 与，不管怎样两边都会判断，都为真才返回真；| 或，不管怎样两边都会判断，都为假才返回假。流程控制switchswitch后括号中的值必须是int，byte，char，short，枚举类型的变量之一，其它类型的就不行了；每个case后面的值必须是不相等的，而且必须是常量；如果每个case冒号后

32、面的语句执行完后没有break，还会继续执行后面case里的语句，所以在每个case的语句结束后加一个break；多个case可以可并到一起，表示或的关系；default代表如果和所有case后的值都不匹配，就执行这里的语句。无论default写哪都是最后执行的。public class Grade public static void main(String args) Scanner sca = new Scanner(System.in);System.out.println(请输入一个百分数：);int s = sca.nextInt();if (s 100) System.out.p

33、rintln(ERROR DATA:S);System.exit(0);/ 退出这个程序switch (s / 10) case 10:case 9:System.out.println(A);break;case 8:System.out.println(B);break;case 7:System.out.println(C);break;case 6:System.out.println(D);break;default:System.out.println(E);break;break和continuebreak退出当前的循环体，在嵌套循环中，只退出当前的一层循环；continue结束

34、当前本次循环，继续进行下一轮的循环。可以说，只是本次忽略循环内后面的语句；continue只能在循环体内用；break可以用在任意代码块中，表示退出当前程序块(配合标签使用，很好用)。方法构造方法每次在创建实例变量，对类中的所有变量都要初始化是很乏味的。如果在一个对象最初被创建时就把对它的设置做好，那样的话，程序将更简单并且更简明。因为对初始化的要求是共同的，Java允许对象在他们被创造时初始化自己。这种自动的初始化是通过使用构造方法来完成的。构造方法在对象创建时初始化。一旦定义了构造方法，在对象创建后，在new运算符完成前，构造方法立即自动调用。构造方法看起来有点奇怪，因为它没有任何返回值，

35、即使是void型的值也不返回。这是因为一个类的构造方法内隐藏的类型是它自己类的类型。构造方法的任务就是初始化一个对象的内部状态，以便使创建的实例变量能够完全初始化，可以被对象马上使用。方法重载在Java中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded）。当一个重载方法被调用时，Java用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。当一个重载的方法被调用时，Java在调用方法的参数和方法的自变量之间寻找匹配。但是，这种匹配并不总是精确的。在一些

36、情况下，Java的自动类型转换也适用于重载方法的自变量。例如： class OverloadDemo void test(double a) System.out.println(Inside test(double) a: + a); class Overload public static void main(String args) OverloadDemo ob = new OverloadDemo(); int i = 88; ob.test(i); OverloadDemo的这个版本没有定义test(int)。因此当在Overload内带整数参数调用test()时，找不到和它匹配的

37、方法。但是，Java可以自动地将整数转换为double型，这种转换就可以解决这个问题。因此，在test(int)找不到以后，Java将i扩大到double型，然后调用test(double)。当然，如果定义了test(int)，当然先调用test(int)而不会调用test(double)。只有在找不到精确匹配时，Java的自动转换才会起作用。thisthis等价于当前对象，调用当前对象的属性或方法就用this.属性名，或this.方法名()。当前对象：指谁在调用当前这个方法和属性，谁就是当前对象。在定义类的时候是不存在当前对象的。在局部变量与外部变量同名的时候，为了区分，就要在外部变量的前面

38、加一个this来表示这个变量是类的全局变量。继承尽管子类包括超类的所有成员，它不能访问超类中被声明成private的成员。子类的对象可以调用父类的一切公有的变量和方法，也可以扩展自己新的属性和方法，但是新扩展的部分父类的对象是无法调用的。super在子类的构造方法中调用父类的构造方法，并且super要放在第一行，不能与this一起用，主要用为在构造子类的时候给父类中定义的变量赋值：任何子类的构造方法都会调用父类的构造方法：因为调用构造方法和创建一个对象是绑在一起的，而一个子类对象的一部分可以看做是父类对象，所以当创建一个子类对象时一定是先创建一个父类的对象，再在父类对象的基础上扩展（exten

39、ds）成一个子类对象。注意：自始至终只创建了一个对象，因为创建的那一个子类对象的一部分是父类对象（上帝想创造一个科学家，肯定是先创造一个人，在人的基础上进行教育培训等，最终变成一个科学家，而最初的人和最后的科学家其实是一个对象）；任何子类的构造方法的第一行必须是this(.)或super(.)的调用，如果程序员不写，则系统会隐含的调用super()，也就是说子类无论如何都会调用父类的构造方法，没写就调用父类的无参构造方法；子类构造方法的第一行只能出现this（.），super(.)这两种情况，无论怎么调用，最终总能找到父类构造方法，否则造成死循环。因为如果子类的某个构造方法的第一行出现this

40、(.)，此时系统不会加上缺省的super()那么this(.)会调用子类的其他构造方法，所以子类的构造方法之间开始调用，如果子类的所有的构造方法的第一行全都是this(.)那便构成了一个死循环。多态（polymorphism）对象的多态：一个对象多种形态。方法的重载和覆盖就是方法多态的一种体现；对象多态的基础：子类对象可以当作父类对象来看，例如：Animal a=new Bird()；多态定理：如果我们把子类对象当作父类对象来看，那么就只能访问父类中已有定义的属性和方法（不能访问子类扩展的属性和方法）。如果子类覆盖了父类的方法，再把子类对象当作父类对象去调用该方法时，调用的是子类覆盖后的方法（

41、对象的行为不可能因为你把它当作什么来看而改变）；Animal a=new Bird()左边是编译时类型：在代码编译过程中，编译器把这个对象当作什么来看？（父类对象）。右边是运行时类型：在代码执行过程中，JVM把这个对象当作什么看？（子类对象）。左边是主观认为（我们把a当作什么看？），右边是客观存在（a实际是什么）。当你把鸟当动物看时，你知道它是动物，但你不知道它是鸟，所以你知道它会走会吃，但你不知道它会唱歌（相当于编译器把它当Animal），所以你不会试图去调用它的唱歌的方法，因为你根本就不知道它会唱歌。当你调用move()方法时，它会flying，因为它本质上还是个鸟，不会因为你把它当作动物

42、而不会飞用走的路。instanceof当发生多层次复杂的继承机构时，往往使程序员自己都搞不清楚最后这个对象到底是什么了，这时就需要提供一个方法来判断一下了。判断一个对象是不是某一个类型的实例，看这个对象能不能作为这个对象实例来看（看这个对象运行时的类型，即看这个对象的客观存在是什么）。static描述整体特征而不是个体特征的属性时，用静态修饰符；有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。成员的声明前面加上关键字static就能创建这样的成员。如果一个成员被声明为s

43、tatic，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static，static成员的最常见的例子是main()，因为在程序开始执行时必须调用main()，所以它被声明为static。声明为static的变量实质上就是全局变量，当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制它们仅能调用其他的static方法；它们只能访问static数据；它们不能以任何方式引用this或super。静态变量和非静态变量（实例变量）的差别空间分配时机：静态变量是在类加载的时候分

44、配空间，非静态对象是在生成对象的时候分配空间；空间分配方式：不管有多少对象静态变量只有一份（所有对象共享），非静态变量有多少对象就分配多少个空间；访问方式：静态变量是：类名.属性，比如Animal.COUNT；非静态变量：对象名.属性，比如。静态方法和非静态方法的区别静态方法是通过类名来调用，非静态方法是通过对象来调用；静态方法中不能访问本类的非静态成员，但非静态方法可以访问静态成员；静态方法不存在多态特性，也就是静态方法无法被子类覆盖，父类对象调用此方法还是父类的。静态代码块静态代码块会在类被加载时被系统自动执行；一般可以在静态代码块中给静态属性赋值；类的静态代码块只能有一个。final声明

45、为final的变量在实例中不占用内存；一个final变量实质上是一个常数；修饰属性时属性不可变，并且属性在声明的时候必须初始化，或者在构造方法中初始化一般与static一起用，一旦定义了，就不能再变了；修饰方法时方法不能被覆盖；修饰类是类不能被继承，表示最终的类，不能有子类；修饰局部变量时局部变量不可变（常量）。abstract用来修饰类和方法；修饰类的话表示这个类是个抽象类，抽象类不能被实例化（生成对象）；修饰方法的话表示这个方法是个抽象方法，抽象方法没有方法体；如果一个类包含有一个抽象方法，那么这个类必须是抽象类；如果一个类不包含抽象方法，那么该类也可以被定义成抽象类；抽象类不能被实例化，

46、但却可以定义引用；抽象类一般需要实现-定义一个子类，并实现抽象方法；抽象类也是有构造方法的，因为需要被子类调用；子类必须实现父类的抽象方法；abstract和final不能共同修饰一个类或方法；例如：定义一个Animal类，就可以定义成抽象类，move()方法可以定义成抽象方法，当具体的子类继承Animal时，再覆盖move()方法，鸟飞，鱼游类的加载触发类加载的几种情况调用静态成员时，会加载静态成员真正所在的类及其父类；通过子类调用父类的静态成员时，只会加载父类而不会加载子类；第一次new对象的时候加载(第二次再new同一个类时，不需再加载)；加载子类会先加载父类（覆盖父类方法时所抛出的异常

47、不能超过父类定义的范围）；如果静态属性有final修饰时，则不会加载，当成常量使用，例如：public static final int a =123;但是如果上面的等式右值改成表达式(且该表达式在编译时不能确定其值)时则会加载类，例如：public static final int a = math.PI如果访问的是类的公开静态常量，那么如果编译器在编译的时候能确定这个常量的值，就不会被加载，如果编译时不能确定其值的话，则运行时加载。类加载的顺序加载静态成员/代码块先递归地加载父类的静态成员/代码块(Object的最先)，再依次加载到本类的静态成员。同一个类里的静态成员/代码块，按写代码的顺

48、序加载。如果其间调用静态方法，则调用时会先运行静态方法，再继续加载。同一个类里调用静态方法时，可以不理会写代码的顺序。调用父类的静态成员，可以像调用自己的一样，但调用其子类的静态成员，必须使用“子类名.成员名”来调用。加载非静态成员/代码块（实例块在创建对象时才会被加载，而静态成员在不创建对象时可以加载）先递归地加载父类的非静态成员/代码块(Object的最先)，再依次加载到本类的非静态成员。同一个类里的非静态成员/代码块，按写代码的顺序加载。同一个类里调用方法时，可以不理会写代码的顺序。但调用属性时，必须注意加载顺序。一般编译不通过，如果能在加载前调用，值为默认初始值(如:null或者0)。

49、调用父类的非静态成员(private除外)，也可以像调用自己的一样。调用构造方法先递归地调用父类的构造方法(Object的最先)，默认调用父类空参的，也可在第一行写明调用父类某个带参的。再依次到本类的构造方法，构造方法内，也可在第一行写明调用某个本类其它的构造方法。注意：如果加载时遇到override的成员，可看作是所需创建的类型赋值给当前类型。其调用按多态用法：只有非静态方法有多态;而静态方法、静态属性、非静态属性都没有多态。假设子类override父类的所有成员，包括静态成员、非静态属性和非静态方法。由于构造子类时会先构造父类，而构造父类时，其所用的静态成员和非静态属性是父类的，但非静态方

50、法却是子类的，由于构造父类时，子类并未加载，如果此时所调用的非静态方法里有成员，则这个成员是子类的，且非静态属性是默认初始值的。1、加载父类静态成员/代码块2、加载子类静态成员/代码块3、加载父类非静态成员/代码块4、加载父类构造方法5、加载子类非静态成员/代码块6、加载子类构造方法接口（interface）接口可以通过运用关键字extends被其他接口继承；当一个类实现一个继承了另一个接口的接口时，它必须实现接口继承链表中定义的所有方法；是一种抽象的数据类型，特殊的抽象类；接口中的所有方法都是抽象方法，就算不写系统也会自动加上abstract，所以一般就省去不写了；接口中所有的属性都是fin

51、al static的（静态常量），就算不写系统也会自动加上，所以一般可以省去不写了；接口也不能被实例化，但可以定义的接口的引用；接口没有构造方法，接口的实现类在生成对象时不会调用接口的构造方法，类的子类在生成对象时一定要调用父类的构造方法（所以子类长的像父类，却不像接口）；一个类只能继承一个父类，但是可以实现多个接口，用逗号隔开；接口之间可以多继承；接口=标准：把服务的使用者和服务的提供者分开，降低系统的耦合，有效的提高软件的可扩展性和可维护性；接口声明中可以声明变量，它们一般是final和static型的，意思是它们的值不能通过实现类而改变，它们还必须以常量值初始化，如果接口本身定义成pub

52、lic，所有方法和变量都是public的。访问控制访问控制（access control）访问指示符（access specifier）staticfinalabstractpublicprotected默认private顶层类NYYYNYN属性YYNYNYY方法YYYYYYY局部变量NYNNNNN成员式内部类YYYYYYY局部式内部类NYYNNNNObject类构造方法只有唯一的一个，并且无参。clone()protected clone() throws 创建并返回一个当前对象的拷贝，得到和当前对象一模一样的对象。clone()方法满足：对任何的对象x，都有x.clone()!=x;克隆对

53、象与原对象不是同一个对象了；对任何的对象x，都有x.clone().getClass=x.getClass();克隆对象与原对象的类型一样；如果对象x的equals方法定义恰当，那么x.clone().equals(x)应该成立。对象克隆过程要让这个类实现java.lang.Cloneable接口Cloneable接口，指示方法可以合法地对该类实例进行按字段复制。如果在没有实现Cloneable接口的实例上调用Object的clone方法，则会导致抛出CloneNotSupportedException异常。按照惯例，实现此接口的类应该使用公共方法重写Object.clone（它是受保护的）。

54、注意，此接口不包含clone方法。因此，因为某个对象实现了此接口就克隆它是不可能的。即使clone方法是反射性调用的，也无法保证它将获得成功。Cloneable接口没有任何方法，像Cloneable这样的接口叫做标记接口，即标记这个类的实例可以调用clone方法，只是起到一个标记的作用。覆盖Object中的clone()方法，并将访问权限改为publicclone();方法的访问修饰符是protected，这意味着，在子类中直接去super.clone();是可以的，但是如果想在第三方类中去生成一个子类对象后再取调用clone()时就不可以了，所以这时就得在子类中去覆盖Object的clone

55、方法，并将访问控制修饰符改为public。如果只是希望浅复制，那么使用这样的代码就可以完成public Object clone() throws CloneNotSupportedException return super.clone();这段代码表示，覆盖Object中的clone方法，将访问控制修饰符改为public，然后再去调用Object的clone方法。clone方法有具体的实现步骤代码，这叫做是实现方法。因为clone方法涉及到底层数据的访问，一般的程序员是没有办法写出这些代码的，所以用这样的一个简单的步骤就可以达到clone的目的了。浅复制和深复制概念浅复制（浅克隆）被复制对

56、象的所有变量都含有原来的对象的相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不是复制它所引用的对象。深复制（深克隆）被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。例如：一个Student对象包含ID，姓名，Teacher等属性。其中ID为基本类型，姓名为String类型，Teacher为一个Teacher对象。浅复制只复制一个新的ID，而姓名和Teacher只复制地址。即，复制后的新对象姓

57、名和Teacher仍然指向原先的Stuent的姓名和Teacher。而深复制会连同姓名和Teacher也同样复制出来，并且与原对象的地址不同，指向不同的对象。finalize()构造方法负责对象创建后的初始化，finalize方法负责对象消亡时的资源释放；finalize方法被垃圾收集器自动调用，而垃圾收集器有可能根本不执行，所以没有办法保证finalize方法一定执行。equals(Object obj)下面是Object中的equals方法源码： public boolean equals(Object obj) return (this = obj); toString()返回该对象的字

58、符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：getClass().getName() + + Integer.toHexString(hashCode()String类及对象池在JDK5.0里面，Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别用来存储8种基本类型的包装类对象和Str

59、ing对象。对象池的存在是为了避免频繁的创建和销毁对象而影响系统性能。对象池是独立于栈空间和堆空间的，保存着指向一些对象的首地址。String a=hello;首先把hello这个对象创建出来，并保存在堆中。然后对象池会保存一个指向hello的首地址。如果a是某个方法内的局部变量，那么也会在栈中将hello的首地址保存在a中。如果a的地址值被赋为null，也就是a不再指向hello了，此时hello并没有成为垃圾，因为对象池中始终保存了hello的首地址指向hello。而对象池中的那些地址值，程序员是不能直接管理的，那是由JVM才能直接管理的。下次如果需要String b=hello;创建he

60、llo对象，那么b会去对象池中找那些地址值，如果找到了指向hello对象的地址，那么会将这个地址直接赋给b。如果没有与之匹配的，才会创建新的对象，并同样将这个对象的首地址保存在对象池中。String c=new String(hello);系统会直接在堆空间中创建一个新的hello对象，而不会去对象池中找，而且这样创建的新的hello对象也不会保存在对象池去。注意注意：String s=new String(hello);直接只有这条语句的时候，这里的hello作为一个参数传给String，而此时没有hello这个对象，那么：首先会创建一个hello对象，并且将这个hello对象的首地址保存在