Java编程思想第四版第七章学习（2）

1、保证正确清理
（1）垃圾回收器不知道何时会被调用，也不知道是否将被调用。因此如果要某个类清理一些东西，就必须显示地编写一个特殊方法来做这个事情。需要注意的是，在清理方法中，必须注意对基类清理方法和成员对象清理方法的调用顺序，以防某个子对象依赖于另一个子对象情形的发生。一般而言，首先执行类的所有特定的清理动作，其顺序同生产顺序相反（通常这就要求基类元素仍旧存活）；然后，调用基类的清理方法。

2、名称屏蔽
Java的基类拥有某个已被多次重载的方法名称，那么在导出类中重新定义该方法名称并不会屏蔽其在基类中的任何版本。即在该层或它的基类中对方法进行定义，重载机制都可以正常工作。在Java SE5后增加了@Override注解，当你想要覆写某个方法时，可以选择添加这个注解，在你不小心重载而非覆写该方法时，编译器就会报错。
如下所示：

class  Basic {
    public Basic (String s){
        System.out.println("This is the Basic Construction");
        System.out.println("s= " + s);
    }
     void test()//这是基类中即将要被覆写的方法
    {
        System.out.println("Override");
    }
}
//////////////////////////////////////////////////
class BasicTwo extends Basic {
    public BasicTwo () {//BasicTwo的默认构造器
        super("nihao");
        System.out.println("This is the first Construction");   
    };

    public BasicTwo(String s1, int i){//BasicTwo的非默认构造器
        super(s1);
        System.out.println("s1= " + s1 + ", i= " + i);
        System.out.println("This is the second Construction");

    }
    //此时Basic类中的方法test已经被覆写了。
    @Override void test ()
    {
        System.out.println("ddf");
    }
}

3、向上转型
由导出类转型成基类，在继承图上是向上移动的，因此称为向上转型。一般是从一个较为专用类型向较通用类型转换，所以总是安全的。此时，导出类是基类的一个超集。它可能有比基类含有更多的方法，但它必须至少有基类中的方法。在向上转型的过程中，类接口中唯一可能发生的事情是丢失方法。

4、final数据
（1）对于基本类型，final使数值恒定不变，而用于对象引用，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改向另一个对象。然而，对象其本身是可以修改的。

class Value {
    int i ;
    public Value(int i ){
        this.i = i;
    }
}

public class FinalData {
    private final Value v2 = new Value(22);
    private String id;
    public FinalData(String id){this.id = id;}
    //Arrays:
    private final int[] a = {1, 2, 3, 4, 5, 6};

public static void main(String[] args) {
    FinalData fd1  = new FinalData("fd1");
    // !fd1.v2 = new Value(0); //Error: Can not
    fd1.v2.i++; // Object is not constant. Can change
        System.out.println("v2.i= " + fd1.v2.i);

    // !fd1.a = new int[3];  //Error: Can not
    for(int i= 0; i< fd1.a.length; i++)
        {
            fd1.a[i]++;
            System.out.print(fd1.a[i]);
        }
}/*Output:
v2.i= 23
234567
*///

以上fd1.v2说明一旦引用被初始化指向一个对象，就无法再把它改向另一个对象。然而，对象其本身是可以修改的。数组同样也是。

（2）不能因为某数据是final的就认为在编译时可以知道它的值。例如

private final int i4 = rand.nextInt(20);
static final int INT_5 = rand.nextInt(20); 

i4可以通过创建不同的对象赋给不同的值，可一旦确定就不能改变。而INT_5的值是不可以通过创建第二个对象而加以改变，因为INT_5是static的，在装载时已被初始化，而不是每次创建新对象时而被初始化。
（3）空白final
空白final是指被声明为final但又未给定初值的域。无论什么情况下，编译器都确保空白final在使用前必须初始化。必须在域的定义处或每个构造器中用表达式对final进行赋值。
（4）final参数
在参数列表中以声明的方式将参数指明为final，意味着在方法中无法更改参数引用所指向的对象。

5、final方法
final指定的方法无法覆盖。在类中所有的private方法都隐式地指定为final的。由于无法取用private方法，所以也就无法覆盖它。可以对private方法添加final修饰词，但这没有任何意义。

6、final类
当将某个类的整体定义为final时，表示不打算继承该类，也不允许别人这么做。final类的域可以根据个人意愿选择为是不是final，但无论类是不是被定义为final，相同的规则都适用于定义为final的域。同时，final类中的所有的方法都隐式指定为final的，无法覆盖它们。

class SmallBrain {}

final class Dinosaur{
    int i =7;
    int j = 1;
    SmallBrain x = new SmallBrain();
    void f() {}
}
public class FinalClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Dinosaur n = new Dinosaur();
        n.f();
        n.i = 40;
        System.out.println(n.i);
        n.j++;
        System.out.println(n.j);
    }

}/*Output
40
2
*///

上述小程序表明final类中的域还是正常的，可以修改。