知识点复习

1. 接口的方法可以默认为 public static final,接口中不可以定义变量。
2. Java创建对象的几种方式（重要）：
   (1) 用new语句创建对象，这是最常见的创建对象的方法。
   (2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
   (3) 调用对象的clone()方法。
   (4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
   (1)和(2)都会明确的显式的调用构造函数 ；(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函数。
3. ArrayList的默认长度为10，如果添加20个长度，则需要给原来长度扩展一次（扩展为原来长度的1.5陪），但是明确指出需要多少长度的时候，则可以直接分配所需要的空间。

4.  1 class HelloA {
   
    2 
   
    3     public HelloA() {
   
    4         System.out.println("HelloA");
   
    5     }
   
    6     
   
    7     { System.out.println("I'm A class"); }
   
    8     
   
    9     static { System.out.println("static A"); }
   
   10 
   
   11 }
   
   12 
   
   13 public class HelloB extends HelloA {
   
   14     public HelloB() {
   
   15         System.out.println("HelloB");
   
   16     }
   
   17     
   
   18     { System.out.println("I'm B class"); }
   
   19     
   
   20     static { System.out.println("static B"); }
   
   21     
   
   22     public static void main(String[] args) { 
   
   23 　　　　 new HelloB(); 
   
   24 　　 }
   
   25 
   
   26 }

   本题考查了静态代码块、构造函数、构造语句块（{大括号里面的}）的执行顺序。执行结构：

    1 static A
   
    2 static B
   
    3 -------main start-------
   
    4 I'm A class
   
    5 HelloA
   
    6 I'm B class
   
    7 HelloB
   
    8 I'm A class
   
    9 HelloA
   
   10 I'm B class
   
   11 HelloB
   
   12 -------main end-------

   静态代码块，只要类首次加载入内存时调用一次，只此一次，从上到下开始执行。                                                                                                             非静态代码块在每次创建对象时，会在构造函数之前被使用。                                                                                                                                      构造函数，每次创建对象时最后调用。                                                                                                                                                                  创建子类对象时，先创建父类对象，在创建子类对象。

5. 多个catch语句块的执行顺序。                                                                                                                                                                        catch语句的执行时，先从最前面的异常进行异常类型匹配，如果父异常的类型在子异常的类型之前，就只执行父类型的异常，子类型的异常将不执行。否则子类型的异常在父类型的异常（exception）之前，两者都将执行，一般会使用后面的方式进行。
6. 局部变量在使用前必须声明并赋值，成员变量只需要声明即可。

7. 1         String str4 = "string";
   
   2         String str2 = new String("string");
   
   

   第一行生成的string，在字符串池中查看，如果没有的话，创建新的，再将地址返回str4；如果有的话，直接将string的地址返回给str4.
   第二行生成的string，先会在字符串池中查看，如果有的话，则不用的字符串池中创建对象，直接在堆中创建对象，再将地址返回给str2；如果没有的话，先在字符串池中创建对象，再在堆中创建对象，最后将地址返回给str2.                                                                                                                                                string一旦被创建就不能被改变。如果改变的话，也就是生成新的对象。  

8. System.out.pringln("5" + 2); 结果为52

9. RandomAccessFile是IO包的类，但是自成一派，从Object直接继承过来。可以对文件中的内容可以随机的进行读取。                                                    RandomAccessFile in = new RandAccessFile("file.dat","r");in.skipBytes(9);int c = in.readByte();

10. 抽象类遵循的原则：                                                                                                                                                                                            (1)abstract只能修饰方法和类，不能修饰段。                                                                                                                                                           (2)抽象类不能被实例化（不能被new出新的对象），只能被继承。                                                                                                                                (3)变量可以初始化或者不初始化，但是初始化之后不可以在抽象类里面重新的赋值和操作该变量，应该在其子类中做相应的操作。                                                    (4)抽象类中的抽象方法不能进行实现 。                                                                                                                                                                   (5)含有抽象方法的类必须定义成抽象类。

11. 抽象类与接口区别：                                                                                                                                                                                           (1) 接口是公开的，里面不能有私有的变量和方法，而抽象类里面可以有。                                                                                                                     (2) 抽象类是继承关系，而且只能继承一次；而接口是实现关系，可以进行多重实现。                                                                                                         (3)接口中的数据成员必须是static final ，不过一般不定义出局成员，所有的成员方法默认为public abstract.                                                                             (4)实现接口一般需要实现接口中的所有方法，而抽象类中可以有选择的实现抽象方法。接口中不能实现方法。                                                                         (5)接口中定义的变量一般都是public static final，不能进行修改

12. serilizable与transient                                                                                                                                                                                     一个对象要被序列化，必须实现serilizable接口。而对于实际开发中，有的属性需要被序列化，有的不需要被序列化，这种时候就需要在其前面使用transient关键字。transient只能修饰变量。而对于静态的属性，则不会进行序列化，要想获得属性值，就要在jvm中获取响应的static值。对象的序列化可以通过实现两种接口来实现，若实现的是Serializable接口，则所有的序列化将会自动进行，若实现的是Externalizable接口，则没有任何东西可以自动序列化，需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容，而不是null。

13. 构造函数                                                                                                                                                                                                       子类调用父类的构造函数。子类没有显示的调用父类的构造函数，子类new生成一个对象时都要调用父类没有带参数的构造方法，再看子类是否带参数。如果带参数就先调用父类没带参数的构造方法，再调用子类带参数的构造方法，最后再调用父类带参数的构造方法。若没有，则调用父类不带参数的构造方法和子类不带参数的构造方法。