Java编程思想（七）

Java编程思想（七）

复用类

编译器不是简单的为每个引用都创建默认对象

如果想初始化引用，可以在代码中下列位置进行：

• 在定义对象的地方，这意味着他们能在构造器呗调用之前被初始化

• 在类的构造器中

• 就在正要使用这些对象之前

• 使用实例初始化

代码示例：

class Soap{
    private String s;
    Soap(){
        System.out.println("Soap()");
        s = "Constructed";
    }
    public String toString(){
        return s;
    }
}
public class Bath {
    private String s1 = "Happy",s2 = "Happy",s3,s4;
    private Soap castille;
    private int i;
    private float toy;

    public Bath(){
        System.out.println("Inside Bath()");
        s3 = "Joy";
        toy = 3.14f;
        castille = new Soap();
    }
    {i = 47;}

    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="+castille;


    }

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

}

---

继承语法

如果没有明确指出从其他类中继承，则就是在隐式从Java标准根中继承Object

---

初始化基类(无参)

构建的过程是从基类向外扩散的。所以基类在导出类构造器可以访问它之前，就已经完成初始化

class Art{
    Art(){
        System.out.println("Art constructor");
    }
}
class Drawing extends Art{
    Drawing(){
        System.out.println("Drawing constructor");
    }
}
public class Cartoon extends Drawing{
    public Cartoon(){
        System.out.println("Cartoon constructor");
    }

    public static void main(String[] args) {
        Cartoon x = new Cartoon();
    }
}

---

初始化基类（有参）

会使用到super进行传参

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

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

public class Chess extends BoardGame{
    Chess(){
        super(11);
        System.out.println("Chess constructor");
    }

    public static void main(String[] args) {
        Chess x = new Chess();
    }
}

---

继承与组合有什么区别

组合和继承的共同点：
继承和组合的使用都可以减少重复代码，同时若类B是类A的内嵌对象，则B类具有A类的全部数据。
不同点：组合是通过在其他类中定义对象来使用类中的方法和属性，不能访问父类的任何接口。而继承则是从父类中得到方法和属性，即可以得到父类的全部接口，并加以调用。
通过组合生成的类和被组合的类之间的逻辑关系：组合生成的类具有被组合类的全部内容，但是并不包括被组合类的全部接口，就是通过被组合的类的对象只能访问组合类的成员函数，但不能直接访问到被组合类的成员函数。
继承类与基类的逻辑关系：即通过派生类的对象不但可以访问派生类的成员函数，也能访问基类的成员函数，派生类是可以完全继承基类的任何内容的包括全部接口。

最清晰判断使用组合与继承的方法：

如果需要向上转型，则继承是必要的，如果不需要，也许就考虑一下是否需要继承。

---

Final关键字

可能使用到final的三种情况：数据，方法和类

final数据

适用场景：

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

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

---

继承与初始化

了解创建对象的过程中，初始化的顺序对于了解代码是非常有用的

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");
    static int printInit(String s){
        System.out.println(s);
        return 47;
    }
}

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

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