构造器与多态

1.构造器的调用顺序

例：

class Real{
    public Real(String index) {
        // TODO Auto-generated constructor stub
        System.out.println("Real()"+index);
    }
}
class Meal{
    Real r= new Real("Meal");
    Meal() {
        // TODO Auto-generated constructor stub
        System.out.println("Meal()");
    }
}
class Bread{
    Bread() {
        // TODO Auto-generated constructor stub
        System.out.println("Bread()");
    }
}
class Cheese{
    Cheese() {
        System.out.println("Cheese()");
    }
}
class Lettuce{
    Lettuce() {
        // TODO Auto-generated constructor stub
        System.err.println("Lettuce()");
    }
}

class PortableLunch{
    Real r= new Real("PortableLunch");
    PortableLunch(){
        System.out.println("PortableLunch()");
    }
}
public class Sandwich extends PortableLunch{
    Bread b= new Bread();
    Cheese c= new Cheese();
    Lettuce l= new Lettuce();
    Sandwich(){
        System.out.println("Sandwich()");
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Sandwich();
    }

}

2、继承与清理

例：

class Characteristic {
    private String s;

    Characteristic(String s) {
        this.s = s;
        System.out.println("Creating Characteristic " + s);
    }

    protected void dispose() {
        System.out.println("disposing Characteristic " + s);
    }
}

class Description {
    private String s;

    Description(String s) {
        this.s = s;
        System.out.println("Creating Description " + s);
    }

    protected void dispose() {
        System.out.println("disposing Description " + s);
    }
}

class LivingCreature {
    private Characteristic p = new Characteristic("is alive");
    private Description t = new Description("Basic Living Creature");

    LivingCreature() {
        System.out.println("LivingCreature()");
    }

    protected void dispose() {
        System.out.println("LivingCreature dispose");
        t.dispose();
        p.dispose();
    }
}

class Animal extends LivingCreature {
    private Characteristic p = new Characteristic("has heart");
    private Description t = new Description("Animal not Vegetable");

    Animal() {
        System.out.println("Animal()");
    }

    protected void dispose() {
        System.out.println("Animal dispose");
        t.dispose();
        p.dispose();
        super.dispose();
    }
}

class Amphibian extends Animal {
    private Characteristic p = new Characteristic("can live in water");
    private Description t = new Description("Both water and land");

    Amphibian() {
        System.out.println("Amphibian()");
    }

    protected void dispose() {
        System.out.println("Amphibian dispose");
        t.dispose();
        p.dispose();
        super.dispose();
    }
}

public class Frog extends Amphibian {
    private Characteristic p = new Characteristic("Croaks");
    private Description t = new Description("Eats Bugs");

    public Frog() {
        System.out.println("Frog()");
    }

    protected void dispose() {
        System.out.println("Frog dispose");
        t.dispose();
        p.dispose();
        super.dispose();
    }

    public static void main(String[] args) {
        Frog frog = new Frog();
        System.out.println("Bye!");
        frog.dispose();
    }
} /*
 * Output

3.构造器内部的多态方法的行为
例：

class Glyph {
    void draw() {
        System.out.println("Glyph.draw()");
    }

    Glyph() {
        System.out.println("Glyph() before draw()");
        draw();
        System.out.println("Glyph() after draw()");
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;

    RoundGlyph(int r) {
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
    }

    void draw() {
        System.out.println("RoundGlyph.draw(), radius = " + radius);
    }
}

public class PolyConstructors {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}
/**输出结果
Glyph() before draw()
RoundGlyph.draw(), radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(), radius = 5
*/

1.当创建RoundGlyph 对象时，会先为创建该对象分配足够的内存，存储空间清理，
基本类型被初始化为0，变量radius 被初始化为0，
2.再调用基类的构造器，基类构造器
中的draw()方法被子类覆盖，所以draw()调用的是子类RoundGlyph 中的方法，但是子类还没有完成初始化，所以容易出问题

4.协变返回类型
子类覆盖版本返回的类型可以是父类返回类型的子类
例：

class Grain{
    public String toString(){ return "Grain"; }
}
class Wheat extends Grain{
    public String toString(){ return "Wheat"; }
}
class Mill{
    Grain process(){ return new Grain(); }
}
class WheatMill extends Mill{
    Wheat process() { return new Wheat(); }
}
public class CovariantReturn{
    public static void main(String[] args) {
        Mill m = new Mill();
        Grain g = m.process();
        System.out.println(g);
        m = new WheatMill();
        g = m.process();
        System.out.println(g);
    }
}
/*Output
Grain
Wheat
*/

5.用继承进行设计

纯继承：（is-a）,是一种纯替代，父类和子类有着完全形同的接口
扩展：子类中有额外的方法，子类中的扩展方法基类不能访问，当向上转型时会丢失新方法

向下转型不安全，当转到错误类型容易报错

例：

class Useful {
    public void f() {
        System.out.println("Useful f()");
    }

    public void g() {
        System.out.println("Useful g()");
    }
}

class MoreUseful extends Useful {
    public void f() {
        System.out.println("MoreUseful f()");
    }

    public void g() {
        System.out.println("MoreUseful g()");
    }

    public void u() {
        System.out.println("MoreUseful u()");
    }

    public void v() {
    }

    public void w() {
    }
}

public class RTTI {
    public static void main(String[] args) {
        Useful[] x = { new Useful(), new MoreUseful() };
        x[0].f();
        x[1].g();
        // x[1].u();
        ((MoreUseful) x[1]).u();
        ((MoreUseful) x[0]).u();// Exception thrown.
    }
}