Java编程思想学习笔记_4

一、继承与清理

　　如果某个类需要去清理自身的资源，那么必须用心为其创建回收垃圾的方法，而如果此类有导出的子类，那么必须在导出类中覆盖回收的方法，当覆盖被继承类的回收垃圾的方法的时候，需要注意销毁的顺序应该和初始化的顺序相反。对于字段来说，意味着与声明的顺序相反。应该先对导出类进行清理，然后才是基类。这是因为导出类的清理可能会调用基类的某些方法，所以需要使基类的构件仍起作用而不应过早的销毁他们。

　　如果需要去销毁被多个成员对象共享的变量的时候，这种情况会变得很复杂。这种情况下，可以使用引用计数法来跟综访问着共享对象的代码数量,代码如下：

import static net.mindview.util.Print.*;
class Shared {
    private int refcount=0; //标识引用该变量的个数
    private static long counter=0;
    private final long id=counter++; //标识Shared变量
    public Shared() {
        print("Creating "+this);
    }
    public void addRef() {
        refcount++;
    }
    protected void dispose() {
        if(--refcount==0) {
            print("Disposing "+this);
        }
    }
    public String toString() {
        return "Shared"+id;
    }
 }
class Composing {
    private Shared shared;
    private static long counter=0;
    private final long id=counter++;
    public Composing(Shared shared) {
        print("Creating "+this);
        this.shared=shared;
        this.shared.addRef();
    }
    protected void dispose() {
        print("disposing "+this);
        shared.dispose();
    }
    public String toString() {
        return "Composing"+id;
    }
}
public class ReferenceCounting {

    public static void main(String[] args) {
        Shared shared=new Shared();
        Composing[] composing={new Composing(shared),new Composing(shared),
                new Composing(shared),new Composing(shared)};
        for(Composing c:composing) {
            c.dispose();
        }
    }

}

二、构造器内部的多态方法的行为

　　如果调用构造器内部的一个动态绑定的方法的时候，就需要用到那个方法被覆盖后的定义，动态绑定的方法调用导出类的方法，此时导出类成员变量还未被初始化，可能会产生错误。

public class Test {
    public static void main(String[] args) {
        new NewSon().print();
    }
}
abstract class Father {
    String fs="Dad!";
    public Father() {
        print();
    }
    public abstract void print();
}
class NewSon extends Father {
    int i=4;
    String ss="son!";
    public void print() {
        System.out.println("Son.."+i);
//        System.out.println(ss.toUpperCase());  error
    }
}

　　小细节：如果一个类实现了一个接口，同时继承了另外一个类，如果被继承的类有和接口中同样方法签名的方法，那么子类可以不用提供对于方法的实现。父类继承过来的方法相当于在子类中实现了接口。

interface Eat {
    public void eat();
}
class Dog {
    public void eat() {

    }
}
public class BadDog extends Dog implements Eat {}