Java编程思想笔记
1. 前期、后期绑定 P9 P150
将一个方法调用同一个方法主体关联起来称为绑定。若在程序执行前（由编译器和连接程序实现）进行绑定叫前期绑定，例如面向过程语言C。
在运行时根据对象的类型进行绑定叫后期绑定。编译器一直不知道对象的类型，但是方法调用机制能找到正确的方法体并加以调用。
Java中除了static和final（private方法属于final方法）方法外，其他方法都是后期绑定。多态性通过动态绑定实现。
2. 单根继承好处 P11
3. 对于自己创建的类，equals()的默认行为是比较引用。所以除非在自己的类中覆盖equals()方法，否则不可能表现出我们希望的行为。 P45
4. Java没有sizeof。因为所有数据类型在所有机器中的大小是相同的。在C/C++中需要使用sizeof的最大原因是为了移植。 P56
5. 在构造器中调用构造器 P86
在构造器中可以用this调用另一个构造器，但不能调用2个。此外，必须将构造调用置于最起始处，否则编译器会报错。
除构造器外，编译器禁止在其他任何方法中调用构造器。
6. static
在static方法内部不能调用非静态方法，反之可以。
7. finalize() P88 或 《Effective Java》 P26
避免使用该方法，因为该方法不能保证被及时的执行。
该方法有两个用途，一是充当最后的安全网，例如迟一点释放关键资源总比永远不释放要好；
二是在本地对等体(native)并不拥有关键资源的前提下，当它的Java对等体被回收的时候，可以用该方法来释放该资源，例如用C/C++调用malloc()分配对象后，可以通过 finalize()用本地方法调用free()来释放内存。
8. 垃圾回收器 P90
9. 类的每个成员保证都会有一个初始值。方法内的局部变量则不会默认初始化。
变量的赋值顺序与方法定义的顺序无关，例如：
public class Test{ int i = f() int f() {return 1;} }
10. 初始化顺序 P96
- 假设有个名为Dog的类，即使没有显式地使用static关键字，构造器实际上也是静态方法。当首次创建类型为Dog的对象时（构造器可以看成静态方法），或者Dog类的静态方法或静态域首次被访问时，Java解释器必须查找类路径，以定位Dog.class文件。
- 然后载入Dog.class（这将创建一个Class对象），有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
- 当用new Dog()创建对象的时候，首先将在堆上为Dog对象分配足够的存储空间。
- 这块空间会被清零。
- 执行所有出现于（非静态）字段定义处的初始化动作。
- 执行构造器。（最后才执行）
11. Java会自动在导出类的构造器中插入对基类构造器（默认构造器或无参构造器）的调用。如果想调用带参数的基类构造器，需要super显式调用。
12. 代理是继承与组合之间的中庸之道。因为我们将一个成员对象置于所要构造的类中（就像组合），但与此同时我们在新类中暴露了该成员对象的所有方法（就像继承）。
13. final
将方法中的参数指明为final，表明你无法在方法中更改参数引用所指向的对象。
void with(final Dog d){ d = new Cat(); // error }
将方法设为final，是想要确保在继承中使方法行为保持不变，并且不会被覆盖。
将某个类设为final，表明你不打算继承该类，即不希望它有子类。
14. interface
接口也可以包含域，但是这些域隐式地是static和final的。
15. 内部类允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。内部类了解外围类，并能与之通信。
内部类能访问其外围对象的所有成员，而不需要任何条件，还拥有其外围类的所有元素的访问权（包括private）。
故内部类的作用有：
- 内部类可以很好的实现隐藏。 一般的非内部类，是不允许有 private 与protected权限的，但内部类可以。
package test; interface Incrementable { void increment(); } class Example { private class InsideClass implements Incrementable { public void increment() { System.out.println("这是一个测试"); } } public Incrementable getIn() { return new InsideClass(); } } public class TestExample { public static void main(String args[]) { Example a = new Example(); Incrementable a1 = a.getIn(); a1.increment(); } }
从这段代码里面我只知道Example的getIn()方法能返回一个Incrementable 实例但我并不知道这个实例是这么实现的。而且由于InsideClass 是private的，所以我们如果不看代码的话根本看不到这个具体类的名字，所以说它可以很好的实现隐藏。
- 内部类拥有外围类的所有元素的访问权限
public class TestExample { private String name = "test"; private class InTest { public InTest() { System.out.println(name); } } public void test() { new InTest(); } public static void main(String args[]) { TestExample bb = new TestExample(); bb.test(); } }
- 可以实现多重继承
package test; class Example1 { public String name() { return "test"; } } class Example2 { public int age() { return 25; } } public class TestExample { private class test1 extends Example1 { public String name() { return super.name(); } } private class test2 extends Example2 { public int age() { return super.age(); } } public String name() { return new test1().name(); } public int age() { return new test2().age(); } public static void main(String args[]) { TestExample mi = new TestExample(); System.out.println("姓名:" + mi.name()); System.out.println("年龄:" + mi.age()); } }
- 可以避免修改接口而实现同一个类中两种同名方法的调用。
如果你的类要继承一个类，还要实现一个接口，可是你发觉你继承的类和接口里面有两个同名的方法怎么办，你怎么区分它们？这就需要我们的内部类了。
package test; interface Incrementable { void increment(); } class MyIncrement { public void increment() { System.out.println("Other increment()"); } static void f(MyIncrement f) { f.increment(); } } public class TestExample extends MyIncrement { private int i = 0; private void incr() { i++; System.out.println(i); } private class Closure implements Incrementable { public void increment() { incr(); } } Incrementable getCallbackReference() { return new Closure(); } }
16. 容器 P222
- List: ArrayList, LinkedList（添加了可以使其用作栈，队列或双端队列的方法）
- Set （加入Set的元素必须定义equals()方法以确保对象的唯一性）
-
HashSet （出于查询速度的原因，使用了散列。存入hashSet的元素必须定义hashCode()）
-
TreeSet （将元素存储在红黑树结构中，方便排序。元素必须实现Comparable接口）
-
LinkedHashSet （也是用了散列，但用链表来维护元素的插入顺序。故使用迭代器遍历Set的时候，结果会按元素插入的顺序显示。元素也必须定义hashCode()）
-
- Map: HashMap, TreeMap, LinkedHashMap, ConcurrentHashMap
与Set类似，任何键都必须有一个equals()方法；如果键被用于散列Map，那必须还有hashCode()方法；如果键被用于TreeMap，那它必须实现Comparable。
另外，无论何时，对同一个对象调用hashCode()都应该生成同样的值。且必须基于对象的内容生成散列码。
散列码不必是独一无二的，应该更关注于生成速度。只要通过hashcode() 与equals() 能够完全确认对象的身份。
- Iterator：能够将遍历序列的操作与序列底层的结构分离，统一了对容器的访问方式。
新程序中不要使用已过时的Vector, Hashtable, Stack。
17. 异常
Throwable异常对象可以分为两种类型:Error用来表示编译时和系统错误；Exception是可以被抛出的异常。
运行时异常（RuntimeException）会自动被虚拟机抛出，不用程序员特殊处理。例如NullPointerException
无论异常是否被抛出，finally子句总能被执行。当涉及break，continue时，finally子句也会得到执行。
18. String对象是不可变的。
StringBuffer是线程安全的，开销也会大点。StringBuilder是非线程安全的。
19. 类型信息
一种是传统的RTTI，它假定我们在编译时就已经知道了所有类型；另一种是反射机制，它允许我们在运行时发现和使用类的信息。
对传统的RTTI，编译器在编译时打开和检查.class文件；而对于反射来说，.class文件在编译时是不可获取的，即在运行时打开和检查.class文件。
20. Class对象
每个类都有一个Class对象。每当编写并编译了一个新类，就会产生一个Class对象（确切的说是被保存在一个同名的.class文件中）。为了生成这个类的对象，JVM将使用类加载器。
取得Class对象的一个引用的方式:
- Class c1 = Class.forName("Dog")
- Class c2 = new Dog().getClass()
- 类字面常量：Class c3 = Dog.class
以上三个方法取出来的是同一个对象，即c1 == c2 ==c3 ，但是c1是在运行时加载的，c2、c3是在编译时加载的。
instanceof与isInstance() 保持了类型的概念，即“你是这个类吗，或者是这个类的派生类吗”；但equals()与==，比较的是实际的Class对象，没有考虑继承。
21. 泛型
Class c1 = new ArrayList<String>().getClass(); Class c2 = new ArrayList<Integer>().getClass(); System.out.println(c1 == c2) // True
在泛型代码内部，无法获得任何有关泛型参数类型的信息，即泛型擦除。上面的例子都会被擦除成原生的ArrayList。
泛型不能用于显式地引用运行时类型的操作中，例如转型、instanceof操作和new表达式，因为所有关于参数的类型信息都丢失了。要时刻提醒自己，“它只是个Object” 。
public class TestExample<T>{ private final static int SIZE = 100; public static void f(Object arg){ if(arg instanceof T){} //error T var = new T(); //error T[] array = new T[SIZE]; //error T[] array = (T)new Object[SIZE]; //warning } }
22. 并发
- 线程启动的两种方式：
- 实现Runnable接口并编写run()方法，将该Runnable对象提交给一个Thread构造器，再调用Thread对象的start(）方法。
- 直接从Thread继承。
class MyThread implements Runnable{ private int ticket=10; public void run(){ for(int i=0;i<20;i++){ if(this.ticket>0){ System.out.println(Thread.currentThread().getName()+" 卖票：ticket"+this.ticket--); } } } }; public class RunnableTest { public static void main(String[] args) { MyThread mt=new MyThread(); // 启动3个线程t1,t2,t3(它们共用一个Runnable对象)，这3个线程一共卖10张票！ Thread t1=new Thread(mt); Thread t2=new Thread(mt); Thread t3=new Thread(mt); t1.start(); t2.start(); t3.start(); } }
class MyThread extends Thread{ private int ticket=10; public void run(){ for(int i=0;i<20;i++){ if(this.ticket>0){ System.out.println(this.getName()+" 卖票：ticket"+this.ticket--); } } } }; public class ThreadTest { public static void main(String[] args) { // 启动3个线程t1,t2,t3；每个线程各卖10张票！ MyThread t1=new MyThread(); MyThread t2=new MyThread(); MyThread t3=new MyThread(); t1.start(); t2.start(); t3.start(); } }
实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。还能避免由于Java的单根继承特性带来的局限。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。
