读Java编程思想随笔の复用类

　　复用代码是Java众多引人注目的功能之一。但要想成为极具革命性的语言，仅仅能够复制代码并对之加以改变是不够的，它还必须能够做更多的事情。

　　代码复用第一种方法非常直观：只需在新的类中产生现有类的对象。由于新的类是由现有类的对象组成，所以这种方法称为组合。该方法只是复用了现有程序代码的功能，而非它的形式。

　　第二种方法则更细致一些，它按照现有类的类型创建新类。无需改变现有类的形式，采用现有类的形式并在其中添加新代码。这种神奇的方式称为继承，而且编译器能够完成其中大部分工作。

　　先看一下组合语法，代码如下：

public class SprinklerSystem {
    private String value1,value2,value3,value4;
    private WaterSource waterSource = new WaterSource();
    private int i;
    private float f;
    public String toString (){
        return
                "value1="+value1+"\n"+
                "value2="+value2+"\n"+
                "value3="+value3+"\n"+
                "value4="+value4+"\n"+
                "i="+i+"\n"+
                "f="+f+"\n"+
                "waterSource="+waterSource;
    }
    public static void main (String [] args){
        SprinklerSystem ss = new SprinklerSystem();
        System.out.println(ss);
    }
}
class WaterSource {
    private String s;
    WaterSource () {
        System.out.println("WaterSource ()");
        s = "Constructed";

    }
    public String toString (){
        return s;
    }
}
//WaterSource ()
//value1=null
//value2=null
//value3=null
//value4=null
//i=0
//f=0.0
//waterSource=Constructed

　　编译器并不是简单地为每一个引用都创建默认对象，这一点是很有意义的，因为要真要那样做的话，就会在许多情况下增加不必要的负担。如果想要初始化这些应用，可以在代码中下列位置进行：

　　1、在定义对象的地方。这意味着它们总是能够在构造器调用之前被初始化。

　　2、在类的构造器中

　　3、就在正要使用这些对象之前，这种方式称为惰性初始化。在生成对象不值得及不必每次都生成对象的情况下，这种方式可以减少额外的负担。

　　4、使用实例初始化

　　以下是四种方式的示例：

public class Bath {
    private String s1 = "Happy",s2="Happy",s3,s4;
    private Soap catlille;
    private int i;
    private float toy;
    public Bath () {
        System.out.println("Inside Bath()");
        s3 = "Joy";
        toy = 3.14f;
        catlille = new Soap();
    }

    @Override
    public String toString() {
        if (s4==null)
            s4 = "Joy";
        return
                "s1="+s1+"\n"+"s2="+s2+"\n"+"s3="+s3+"\n"+"s4="+s4+"\n"+ "i="+i+"\n"+ "toy="+toy+"\n"+"catlille="+catlille;
    }

    public static void main(String[] args) {
        Bath bath = new Bath();
        System.out.println(bath);
    }

}
class Soap {
    private String s;
    Soap () {
        System.out.println("Soap ()");
        s = "Constructed";
    }
    public String toString (){
        return s;
    }
}
//Inside Bath()
//Soap ()
//s1=Happy
//s2=Happy
//s3=Joy
//s4=Joy
//i=0
//toy=3.14
//catlille=Constructed

　　再看继承语法，示例代码如下：

public class Detergent extends Cleanser{
    //change a method
    public void scrub () {
        append(" Detergent scrub ()");
        super.scrub();//call base-class version 防止递归
    }
    //Add methods to the interface
    public void foam () {
        append(" foam ()");
    }

    public static void main(String[] args) {
        Detergent x = new Detergent();
        x.dilute();x.apply();x.scrub();x.foam();
        System.out.println(x);
        System.out.println("Testing base class:");
        Cleanser.main(args);
    }
}
class Cleanser {
    public String s = "Cleanser ";
    public void append (String a) {
        s += a;
    }
    public void dilute () {
        append("dilute ()");
    }
    public void apply () {
        append(" apply ()");
    }
    public void scrub () {
        append(" scrub ()");
    }

    @Override
    public String toString() {
        return s;
    }
    public static void main(String[] args) {
        Cleanser x = new Cleanser ();
        x.dilute();x.apply();x.scrub();
        System.out.println(x);
    }
}
//Cleanser dilute () apply () Detergent scrub () scrub () foam ()
//Testing base class:
//Cleanser dilute () apply () scrub ()

　　从上述代码，我们可以看出以下几点：

　　1、在Detergent类中，肯定有一个默认构造器，此构造器的写法是：

　　 public Detergent(){  super();  } 

　　2、Detergent和Cleanser均含有main方法。可以为每个类都创建一个main方法，这种在每个类中都创建main方法的技术可使每个类的单元测试变得简单易行。

　　3、即使一个程序中含有多个类，也只有命令行调用的那个类的main方法才会被调用，在此例中，如果命令行时java Detergent，则Detergent的main方法会被调用，那么即使Cleanser类不是public类，那么命令行调用java Cleanser，Cleanser的main方法也会被调用。

　　4、为了继承，一般规则是将所有数据成员都定义为private，将所有方法都指定为public。

　　初始化基类

public class Cartoon extends Drawing{
    Cartoon () {

        super();
        System.out.println("Cartoon ()");
    }
    public static void main(String[] args) {
        Cartoon c = new Cartoon ();
    }
}
class Drawing extends Art{
    Drawing () {
        super();
        System.out.println("Drawing ()");
    }
}
class Art {
    Art () {
        System.out.println("Art ()");
    }
}

//Art ()
//Drawing ()
//Cartoon ()

　　构建过程是从“基类”向外扩散的。所以基类在导出类构造器可以访问它之前，就已经完成了初始化。即使你不为Cartoon创建构造器，编译器也会为你合成一个默认的构造器，该构造器将调用基类的构造器。

　　确保正确清理

　　在清理方法dispose中，还必须注意对基类清理方法和成员对象清理方法的调用顺序，以防某个子对象依赖于另一个子对象情形的发生。一般而言，所采用的形式应该与C++编译器在其析构函数上所施加的形式相同：首先，执行类的所有特定清理动作，其顺序同生产顺序相反；然后，就如我们示范的那样，调用基类的清理方法。

　　许多情况下，清理并不是问题，仅需让垃圾回收器完成该动作就行。但当必须亲自处理清理时，就得多加努力和小心。因为，一旦涉及垃圾回收，能够信赖的事就不会很多了。垃圾回收器可能永远也无法被调用，即使被调用，它也可能以任何它想要的顺序来回收对象。最好的办法是除了内存以外，不能依赖垃圾回收器去做任何事情。如果需要进行清理，最好是编写你自己的清理方法，但不要使用finalize()。

　　名称屏蔽

public class Hide {
    public static void main(String[] args) {
        Bart b = new Bart();
        b.doh(1);
        b.doh('x');
        b.doh(1.0f);
        b.doh(new Milhouse ());
    }
}
class Homer {
    char doh (char c) {
        System.out.println("doh(char)");
        return c;
    }
    float doh (float c) {
        System.out.println("doh(float)");
        return 1.0f;
    }
}
class Bart extends Homer {
    void doh (Milhouse m) {
        System.out.println("doh(Milhouse)");
    }
}
class Milhouse {

}
/*
    doh(float)
    doh(char)
    doh(float)
    doh(Milhouse)
*/

　　使用与基类完全相同的特征签名及返回类型来覆盖具有相同名称的方法，是一件极其平常的事。但它也令人迷惑。

　　Java SE5新增了@override注解，它并不是关键字，但是可以把它当作关键字使用。当你想要复写某个方法时，可以选择添加这个注解，在你不留心重载而并非覆盖该方法时，编译器就会报出一条错误信息。

　　向上转型

　　“为新的类提供方法”并不是继承技术中最重要的方面，其最重要的方面是用来表现新类和基类之间的关系。这种关系可用“新类是现有类的一种类型”这句话加以概括。

public class Wind extends Instrument{
    public static void main(String[] args) {
        Wind flute = new Wind();
        Instrument.tune(flute);
    }
}
class Instrument {
    public void play () {
        System.out.println("upper cast");
    }
    static void tune (Instrument i) {
        i.play();
    }
}
//upper cast

　　由于向上转型是从一个较专用类型向较通用类型转换，所以总是很安全的。也就是说，导出类是基类的一个超集。它可能比基类含有更多的方法，但它至少必须具备基类中的所有方法。

　　组合和继承的选择

　　到底是该用组合还是用继承，一个最清晰的判断办法就是问一问自己是否需要从新类向基类进行向上转型。如果必须向上转型，则继承是必要的；但如果不需要，则应该好好考虑继承是不是必须的。

　　final关键字

　　1、一个永不改变的编译时常量

　　2、一个在运行时被初始化的值，而你不希望它被改变

　　一个既是static有时final的域只占据一段不能改变的存储空间。

　　当对对象引用而不是基本类型运用final时，其含义就会有一点令人迷惑。对于基本类型，final使数值恒定不变；而对于对象引用，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象。然而，对象其自身却是可以被修改的，Java并未提供使任何对象恒定不变的途径。这一限制，同样适合于数组。

public class  FinalData {
    private static Random rand = new Random();
    private String id;
    public FinalData (String id) {
        this.id= id;
    }
    private final int valueOne = 9;
    private static final int VALUE_TWO = 99;
    public static final int VALUE_THREE = 99;

    private final int i4 = rand.nextInt(20);
    static final int INT_5 = rand.nextInt(20);
    private Value v1 = new Value(11);
    private final Value v2 = new Value(22);
    private static final Value V_3 = new Value(33);
    private final int [] a= {1,2,3,4,5,6};
    @Override
    public String toString() {
        return id+":"+"i4="+i4+",INT_5="+INT_5;
    }
    public static void main(String[] args) {
        FinalData fd1 = new FinalData ("fd1");
        fd1.v2.i++;
        fd1.v1 = new Value(9);
        for (int i = 0; i < fd1.a.length; i++) {
            fd1.a[i]++;
        }
        System.out.println(fd1);
        System.out.println("Creating new FinalData");
        FinalData fd2 = new FinalData ("fd2");
        System.out.println(fd1);
        System.out.println(fd2);
    }

}
class Value {
    int i;
    public Value (int i) {
        this.i = i;
    }
}
//fd1:i4=6,INT_5=8
//Creating new FinalData
//fd1:i4=6,INT_5=8
//fd2:i4=16,INT_5=8

　　空白final

　　必须在域的定义处或者每个构造器中用表达式对final进行赋值，这正是final域在使用前总是被初始化的原因所在。

　　如以下代码：

public class BlankFinal {
    private final int i = 0;
    private final int j;//blank final
    private final Poppet p;//blank final reference
    //blank final must be initialized in the constructor
    public BlankFinal () {
        j = 1;//initialize blank final
        p = new Poppet (1);//initialize blank final reference
    }
    public BlankFinal (int x) {
        j = x;
        p = new Poppet (x);
    }

    public static void main(String[] args) {
        new BlankFinal ();
        new BlankFinal (47);
    }
}
class Poppet {
    private int i;
    Poppet (int ii) {
        i = ii;
    }
}

　　final参数

　　你可以读参数，但却无法修改参数。这一特性主要用来向匿名内部类传递数据。

public class FinalArguments {
    void with (final Gizmo g) {
        //g = new Gizmo();//-bug
        System.out.println(g);
        //g.spin();
    }
    void without (Gizmo g) {g = new Gizmo(); g.spin();}
    int g (final int i) {return i+1;}

    public static void main(String[] args) {
        FinalArguments bf = new FinalArguments ();
        bf.with(null);
        bf.without(null);
    }
}
class Gizmo{
      public void spin () {
          System.out.println("spin()");
      }
}

　　final方法

　　使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类来修改它的含义。这是出于设计考虑：想要确保在继承中使方法行为保持不变，并且不会被覆盖。第二个原因是效率。

　　类中所有private方法都是隐式地指定为final的。由于无法取用private方法，所以也就无法覆盖它。

　　“覆盖”只有在某方法是基类的接口的一部分时才会出现。即，必须将一个对象向上转型为它的基本类型并调用相同方法。如果某方法为private，它就不是基类接口的一部分。它仅是一些隐藏于类中的程序代码，只不过是具有相同的名称而已。但如果在导出类中以相同的名称生成public、protected或包访问权限的方法话，该方法就不会产生在基类中出现的“仅有相同名称”的情况。此时你并没有覆盖该方法，仅是生成了一个新的方法。

　　final类

　　当将某个类的整体定义为final时，就表明了你不打算继承该类，而且也不允许别人这样做。换句话说，出于某种考虑，你对该类的设计永不需要做任何变动，或者出于安全考虑，你不希望它有子类。

　　请注意，final类的域可以根据个人的意愿选择为是或不是final。不论类是否被定义为final，相同的规则都适用于定义为final的域。然而，由于final禁止继承，所以final类中所有的方法都隐式指定为final，因为无法覆盖它们。

　　初始化和类的加载

　　在许多传统语言中，程序被作为启动过程的一部分立刻被加载的。然后是初始化，紧接着程序开始运行。这些语言的初始化过程必须小心控制，以确保定义为static的东西，其初始化顺序不会造成麻烦。
而在Java中就不会出现这个问题，因为它采用了一种不同的加载方式。加载是众多变得更加容易的动作之一，因为Java中所有事物都是对象。请记住，每个类的编译代码都存在于它自己的独立文件中。该文件只在需要使用程序代码时才会被加载。一般来说，“类的代码在初次使用时才加载。”这通常是指加载发生于创建类的第一个对象之时，但是当访问static域或static方法时，也会发生加载。

　　初次使用之处也是static初始化发生之处。所有static对象和static代码段都会在加载时依程序中顺序而依次初始化。当然定义为static的东西只会被初始化一次。

public class Beetle extends Insect{
    private int k = printInit("Beetle.k initialized");
    public Beetle () {
        super();
        System.out.println("k="+k);
        System.out.println("j="+j);
    }
    private static int x2 = printInit("static Beetle.x2 initialized");

    public static void main(String[] args) {
        System.out.println("Beetle constructor");
        Beetle b = new Beetle();
    }
}
class Insect {
    private int i = 9;
    protected int j;
    Insect () {
        System.out.println("i = "+i+", j="+j);
        j = 39;
    }
    private static int x1 = printInit("static Insect.x1 initialized");
    static int printInit (String s) {
        System.out.println(s);
        return 47;
    }
}
//static Insect.x1 initialized
//static Beetle.x2 initialized
//Beetle constructor
//i=9,j=0
//Beetle.k initialized
//k=47
//j=39
//static变量最先初始化，而初始化导出类前，先要初始化基类；然后执行main方法，创建对象，而创建导出类对象之前先创建基类；然后初始化构造方法之前，先初始化全局变量