Thinking in Java 笔记碎片

复用类

P135 垃圾收集器可能永远也无法被调用，即使被调用，它也可能以任何他想要的顺序来回收对象。因此最好除了内存回收以外，不要依赖垃圾回收器做任何事情。如果需要清理（如关闭文件等），最好自己编写清理方法，且不要使用finalize()方法。

多态

• 多态的作用主要在于消除类型间的耦合关系
• 将一个方法调用和一个方法主体关联起来的过程谓之“绑定”
  • 前期绑定：在程序执行以前就进行绑定，则是前期绑定，这一般由编译器和链接程序实现
  • 后期绑定：在运行时根据对象的类型进行绑定，则是后期绑定，也称为动态绑定或运行时绑定
    Java中除final方法（private方法也是某种意义上的final方法）和static方法外，其余方法均是后期绑定

注意：

• “覆盖”私有方法：如果在子类中写一个与基类中的私有方法同名、同参且返回值相同（一模一样）的方法，那么编译器会认为这是子类的一个全新的方法，所以在将子类向上转型为基类，并调用该方法时，调用的将是基类中的方法

class Cycle extends Shape {
    void f() {
        OutUtil.print("I am the child class -- Cycle!");
    }
}
public class Shape {
    private void f() {
        OutUtil.print("I am the base class -- Shape!");
    }
    public static void main(String[] args) {
        Shape s = new Cycle();
        s.f();
    }
}

// Output:
I am the base class -- Shape!

• 域不具备多态性：当将一个子类型向上转型为基类型时，任何对域的访问操作都将由编译器解析，因此不是多态的。实际上，对于子类型，会为当前类和基类可访问（拥有访问权限）域分配不同的存储空间，当需要访问基类中的域时，需要使用关键词super.域名进行访问
• 静态方法不具备多态性：因为静态方法是与某一个类绑定的，而并非与类对象绑定的，而多态是针对对象而言的，所以静态方法也不具备多态性

class Super{
    String ss = "String in Super";
    static void staticf(){
        OutUtil.print("staticf() in Super");
    }
    void commonf(){
        OutUtil.print("commonf() in Super");
    }
}
class Sub extends Super{
    String ss = "String in Sub";
    static void staticf(){
        OutUtil.print("f() in Sub");
    }
    void commonf(){
        OutUtil.print("commonf() in Sub");
    }
}
public class MultiType {
    //  Thinking in Java P156 域和静态方法的多态性
    public static void main(String[] args) {
        Super sup = new Sub();
        OutUtil.print(sup.ss);
        sup.staticf();
        sup.commonf();
    }
}

//Output:
String in Super
staticf() in Super
commonf() in Sub

• 当需要对某些对象进行清理时，其清理顺序应该和初始化顺序相反。即对象的清理顺序应该和初始化顺序相反；字段则是与声明的顺序相反（因为字段的初始化顺序就是其声明顺序）；而对于类的继承而言，则应该先清理子类，然后再对基类进行清理。因为子类可能需要使用到基类的某些方法，如果先清理基类，则会导致那些方法无效。
• 通过引用计数释放含有共享变量的类：如果存在一个成员变量被一个或多个对象共享的情况，那么就需要好好处理这些对象的清理问题。在这种情况下，可以使用引用计数来跟踪仍旧在访问共享变量的对象数量，只有当引用计数变为0时，才清理这个共享变量（这里的清理并不一定是内存的清理，也可以是文件的关闭、网络的断开等，因为内存清理可以由JVM自动完成，可以不用考虑）

public class ReferenceCounting {
    public static void main(String[] args) {
        Compose[] composes = new Compose[5];
        Share s = new Share();
        for (int i = 0; i < 5; ++i){
            composes[i] = new Compose(s);
        }
        for (int i = 0; i < 5; ++i){
            composes[i].dispose();
        }
    }
}
class Share {
    private int refCount = 0;       // 引用计数器
    private static long counter = 0; // 利用counter和id记录当前创建的Share实例数
    private final long id = counter++;
    public Share() {
        OutUtil.print(this.toString());
    }
    public void addRef() {
        refCount++;
    }
    public void dispose() {
        // 方法内部需要将引用计数减1
        if (--refCount == 0) {
            OutUtil.print("dispose " + this);
        }
    }
    @Override
    public String toString() {
        return "Share " + id;
    }
}
class Compose {
    private Share share;
    private static long counter = 0;
    private final long   id = counter++;
    public Compose(Share share) {
        this.share = share;
        share.addRef();     // 创建一个新对象时，需要将共享变量的引用计数加1
        OutUtil.print(this.toString());
    }
    public void dispose(){
        OutUtil.print("dispose " + this);
        share.dispose();
    }
    @Override
    public String toString() {
        return "Compose " + id;
    }
}

//Output:
Share 0
Compose 0
Compose 1
Compose 2
Compose 3
Compose 4
dispose Compose 0
dispose Compose 1
dispose Compose 2
dispose Compose 3
dispose Compose 4
dispose Share 0

• 构造器：应该使用尽可能简单的方法使对象进入正常状态，如果可以的话，应该尽可能避免调用其他方法。在构造器内唯一能够安全调用的方法是基类中的final方法。
• 协变返回类型：Java SE5允许协变返回类型，所谓协变返回类型是指子类覆盖基类的方法时，可以返回该基类返回类型的子类型，即更具体化

Java运行时多态性：

• 继承实现多态：即将子类对象的引用赋值给基类对象引用，从而实现多态；
• 接口实现多态：一个接口，多种实现，将接口实现类的对象引用赋值给接口对象的引用，以实现多态；