编程思想基础学习（多态）

• 多态：域与静态方法

public class FiledAccess {
    public static void main(String[] args) {
        Super sub = new Sub();
        System.out.println("sub.filed"+sub.filed + "   sub.getFiled"+sub.getFiled()
                +"");

        Sub sub1 = new Sub();
        System.out.println("sub1.filed"+sub1.filed + "  sub1.getFiled"+sub.getFiled()
                +"  sub1.getSuperFiled" + sub1.getSuperFiled());
    }
}
class Super{
    public int filed = 0;
    public int getFiled(){
        return  filed;
    }
}
class Sub extends  Super{
    public int filed = 1;
    public int getFiled(){
        return filed;
    }
    public  int getSuperFiled(){
        return super.filed;
    }
}

sub.filed0   sub.getFiled1
sub1.filed1  sub1.getFiled1  sub1.getSuperFiled0

上面一段代码说明，任何访问域的操作都是又编译器解析，因此不是多态，本例基类的filed和子类的filed分配了不同的存储空间。实际上sup（子类）中包含了两个filed的域 然而在引用时默认的是子类的filed
只有普通的方法调用可以是多态的

静态方法是不具有多态的：静态方法是于类而非与单个对象相关联的。

• 构造器与多态

class Meal{
    Meal (){System.out.println("Meal");}
}

class Bread{
    Bread(){System.out.println("Bread");}
}
class Cheese{
    Cheese(){System.out.println("cheese");}
}

class Lettuce{
    Lettuce(){System.out.println("lettuce");}
}
class Lunch extends  Meal{
    Lunch(){System.out.println("lunch");}
}
class PortableLunch extends  Lunch{
    PortableLunch(){System.out.println("portablelunch");};
}
public class Sandwich extends PortableLunch {
    private  Bread bread = new Bread();
    private Cheese cheese = new Cheese();
    private Lettuce lettuce = new Lettuce();

    public Sandwich(){System.out.println("sandwich");}

    public static void main(String[] args) {
        new Sandwich();
    }
}

执行结果

Meal
lunch
portablelunch
Bread
cheese
lettuce
sandwich

复杂对象调用构造器顺序：（不十分完整）
1、调用基类构造器
2、按声明顺序调用成员的初始化方法
3、调用导出类构造器的主体
下边一个例子说明了去不完整性：

class Glyph{
    void dorw(){System.out.println("Glyph.dorw()");}
    Glyph(){
        System.out.println("Glyph()n before draw()");
        dorw();
        System.out.println("Glyph() after drow()");
    }
}

class RoundGlyph extends  Glyph{
    private int radius = 1;
    RoundGlyph( int r){
        radius = r;
        System.out.println("RoundGlyph() " + radius);
    }
    void doryw(){
        System.out.println("RoundGlyph.dorw() " + radius);
    }
}
public class PolyConstructor {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}

执行结果

Glyph()n before draw()
RoundGlyph.dorw() 0
Glyph() after drow()
RoundGlyph() 5

0、在其他任何任务发生之前，将分配给对对象的存储空间初始化成二进制的零
1、调用基类构造器
2、按声明顺序调用成员的初始化方法
3、调用导出类构造器的主体

• 继承与清理
  导出类覆盖基类的清理方法时务必调用基类版本的方法，否则基类的清理动作就不会发生，其中销毁的顺序应该和初始化的顺序相反

class Useful{
    public void f(){};
    public  void g(){};
}
class MoreUseful extends Useful{
    public void f(){};
    public void g(){};
    public void u(){}
}
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();//ava.lang.ClassCastException: Javathingking.Useful cannot be cast to Javathingking.MoreUseful
    }
}