[7]复用类 0X01

复用代码的两种方式：
1.组合
2.继承

每一个非基本类型的对象都有一个toString()方法。

组合

1.引用的初始化：
类中域的基本数据类型能够自动被初始化为”零”，但是对象引用会被初始化为null,如果这时你试图为他们调用任何方法，都会得到一个空指针异常。然而，在不抛出异常的情况下，仍旧可以打印一个null引用。

• 初始化引用的位置：
  1.在定义对象的地方，意味着它们总是能够在构造器被调用之前初始化。
  2.在类的构造器中。
  3.使用实例初始化。
  4.“惰性初始化”、就在正要使用这些对象之前。（在生成对象不值得及
  不必每次都生成对象的情况下，这种方式可以减少额外的负担）

• 上代码，演示四种方式：

package me.funnyzhao.recycleclass;
class Soap{
    private String s;
    Soap(){
        //构造器中初始化
        System.out.println("Soap()");
        s="Constructed";
    }
    @Override
    public String toString(){
        return s;
    }
}
public class Bath {
    //在定义对象的地方初始化
    private String s1="Happy",
            s2="Happy",
            s3,s4;
    private Soap catille;
    private int i;
    private float toy;
    public Bath(){
        System.out.println("Inside Bath()");
        s3="joy";
        toy=3.14f;
        catille=new Soap();
    }
    {
        //在所有初始化前调用
        i=47;
        System.out.println(i);
    }
    @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"+
            "castille= "+catille;
    };

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

OutPuts:

47
Inside Bath()
Soap()
s1=Happy
s2=Happy
s3=joy
s4=joy
i=47
toy=3.14
castille= Constructed

继承

1.初始化基类
java会自动在子类的构造器中插入对基类构造器的调用，下面的代码展示了上述机制在三层继承关系上是如何工作的：

class Art{
    Art(){Sytem.out.println("Art Cr")}
}
class Drawing extends Art{
    Drawing(){
        System.out.println("Deawing Cr");
    }
}
public class Cartoon extends Drawing{
    public Cartoon(){System.out.println("Cartoon Cr");}
    public static void main(String[] args){
        Cartoon x=new Cartoon();
    }
}
/*
output:
Art Cr
Drawing Cr
Cartoon Cr
*/

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

1.1下面的我们来证明基类构造器总是会被调用，并且在子类构造器之前被调用：

class Soap{
    Soap(){
        System.out.println("Soap()");
    }
}
public class Bath extends Soap{
    static{
        System.out.println("static域");
    }
    {
        System.out.println("空白");
    }
    Bath(){
        System.out.println("Bath");
    }
    Bath(int i){
        System.out.println("Bath"+i);
    }
    public static void main(String[] args) {
        new Bath(1);
        new Bath(2);
    }
}
/*output:
static域
Soap()
空白
Bath1
Soap()
空白
Bath2
*/

从打印的结果可以看出，结论是成立的。
2.带参数的构造器
如果一个类的基类没有默认的构造器，或者想调用一个带参数的基类构造器，就必须用关键字super显示地编写调用基类构造器的语句，并且配以适当的参数列表：

class Game{
    Game(int i){
        System.out.println("Game()");
    }
}
class BoardGame extends Game{

    BoardGame(int i) {
        super(i);
        System.out.println("BoardGame()");
    }
}
public class Bath extends BoardGame {
    Bath(){
        super(11);
        System.out.println("Bath()");
    }
    public static void main(String[] args) {
        Bath c=new Bath();
    }
}
/*output:
Game()
BoardGame()
Bath()
*/

如果不在BoardGame()中显示的调用基类构造器，编译器会出错误提示；而且，调用基类构造器是你在子类中应该做的第一件事情。