读Java编程思想随笔の多态

　　在面向对象程序设计语言中，多态是继数据抽象和继承之后的第三种基本特征。

　　多态通过分离做什么和怎么做，从另一角度将接口和实现分离开来。多态不但能够改善代码的组织结构和可读性，还能够创建可扩展的程序---即无论在项目最初创建时还是在需要添加新功能时都可以“生长”的程序。

　　“封装”通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将细节“私有化”把接口和实现分离开来。这种类型的组织机制对于那些拥有过过程式程序开发背景的人来说，更容易理解。而多态的作用则是消除类型之间的耦合关系。我们知道，继承允许将对象视为它自己本身的类型或基类型来加以处理。这种能力极为重要，因为它允许将多种类型视为同一类型来处理，而另一份代码也就可以毫无差别的运行在这些不同类型之上。多态方法调用允许一种类型表现出与其他相似类型之间的区别，只要它们都是从同一基类导出来的。这种区别是根据方法行为的不同而表示出来，虽然这些方法都可以通过同一个基类来调用。

　　向上转型

　　对象既可以作为它自己本身的类型使用，也可以作为它的基类型使用，而这种把对某个对象的引用视为对其基类型的引用的做法称为向上转型。

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 音符枚举
 */
public enum Note {
    MIDDLE_C,C_SHARP,B_FLAT;
}　

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 向上转型
 */
public class Wind extends Instrument{
    public void play (Note n) {
        System.out.println("Wind play() "+n);
    }
}
class Instrument {
    public void play (Note n) {
        System.out.println("Instrument.play ()");
    }
}

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 向上转型
 */
public class Music {
    public static void  tune (Instrument i) {
        i.play(Note.MIDDLE_C);
    }

    public static void main(String[] args) {
        Wind flute = new Wind ();
        tune (flute);
    }
}
//Wind play() MIDDLE_C

　　方法调用绑定

　　将一个方法调用同一个方法主体关联起来被称作绑定。若在程序执行前绑定（如果有的话，由编译器和连接程序实现），叫做前期绑定。读者可能以前从没有听说过这个术语，因为它是面向过程的语言中不需要选择就默认的绑定方式。

　　而对于后期绑定，它的含义就是在运行时根据对象的类型进行绑定。后期绑定又叫动态绑定或运行时绑定。如果一种语言想实现后期绑定，就必须具有某种机制，以便在运行时能判断对象的类型，从而调用恰当地方法。也就说，编译器一直不知道对象的类型，但是方法调用机制能找到对应的方法体，并加以调用。后期绑定机制随编程语言的不同而有所不同，但是只要想一下就会得知，不管怎么样都必须在对象中安置某种“类型信息”。

　　Java中除了static方法和final方法外（private方法属于final方法），其他所有的方法都是后期绑定。这意味着通常情况下，我们不必判定是否应该后期绑定，它会自动发生。

　　为什么要将某个方法声明为final呢？它可以防止其他人覆盖该方法，但更重要一点或许是：这样做可以有效的关闭动态绑定。或者说，告诉编译器不需要对此方法进行动态绑定。这样，编译器就可以为final方法调用生成更有效的代码。然而，大多数情况下，这样做，对程序的整体性能不会有多少改观。所以，最好根据设计来决定是否使用final，而不是出于试图提高性能的目的使用final。

　　一旦知道Java中所有方法都是通过动态绑定实现多态这个事实之后，我们就可以编写只与基类打交道的程序代码了，并且这些代码对所有导出类都可以正确的运行。或者换一种说法，发送消息给某个对象，让该对象去判定应该做什么事。

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 后期绑定 （多态）
 */
public class Shape {
    public void draw () {};
    public void erase () {};
}

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 后期绑定 （多态）
 */
public class Circle extends Shape {
    @Override
    public void draw() {
        //super.draw();
        System.out.println("Circle.draw ()");
    }

    @Override
    public void erase() {
        //super.erase();
        System.out.println("Circle.erase ()");
    }
}

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 后期绑定 （多态）
 */
public class Square extends Shape {
    @Override
    public void draw() {
        //super.draw();
        System.out.println("Square.draw()");
    }

    @Override
    public void erase() {
        //super.erase();
        System.out.println("Square.erase()");
    }
}

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 后期绑定 （多态）
 */
public class Triangle extends Shape{
    @Override
    public void draw() {
        //super.draw();
        System.out.println("Triangle.draw()");
    }

    @Override
    public void erase() {
        //super.erase();
        System.out.println("Triangle.erase()");
    }
}

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 后期绑定 （多态）
 */
public class RandomShapeGenerator {
    private Random rand = new Random(47);
    public Shape next(){
        switch (rand.nextInt(3)){
            default:
            case 0:return new Circle();
            case 1:return new Square();
            case 2:return new Triangle();
        }

    }

    public static void main(String[] args) {
        Random r1 = new Random(47);
        Random rand1 = new Random(47);
//        Random r2 = new Random();
//        Random rand2 = new Random();
//        Random r3 = new Random(56);
//        Random rand3 = new Random(65);
        //47表示种子数，如果种子数相同，则代表引用r和引用rand指向同一片存储空间
        //如果new Random()种子数不填或者填写的种子数不同，则代表引用r和引用rand指向不同的存储空间
        System.out.println(r1.nextInt(66));
        System.out.println(rand1.nextInt(66));
    }
}

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 后期绑定 （多态）
 */
public class Shape {
    public void draw () {};
    public void erase () {};
}

　　私有方法被“覆盖”的情况

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 覆盖私有方法
 */
public class PrivateOverride {
    private void f(){
        System.out.println("private f()");
    }

    public static void main(String[] args) {
        PrivateOverride pri = new Derived();
        pri.f();
    }
}
class Derived extends PrivateOverride {
    public void f(){
        System.out.println("public f()");
    }
}

//private f()

　　只有非private方法才可以被覆盖，但是还需要密切注意覆盖private方法的现象，这时虽然编译器不会报错，但是也不会按照我们所期望的来执行。确切的说，在导出类中，对于基类中的private方法，最好采用不同的名称。

　　域与静态方法的多态

      域由编译器解析，而方法则是代码执行中绑定

/**
 * @author yxm
 * @date 2015/11/1.
 * @company 中国奇奇科技有限公司
 * @description 域不具备多态性
 */
public class FieldAccess {
    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println("sup.field="+sup.field+", sup.getField()="+sup.getField());
        Sub sub = new Sub();
        System.out.println("sub.field="+sub.field+", sub.getField()="+sub.getField()+", sub.getSuperField()="+sub.getSuperField());
    }
}
class Super{
    public int field = 0;
    public int getField(){
        return field;
    }
}
class Sub extends Super{
    public int field = 1;
    public int getField(){
        return field;
    }
    public int getSuperField(){
        return super.field;
    }
}
//sup.field=0, sup.getField()=1
//sub.field=1, sub.getField()=1, sub.getSuperField()=0
//域不具有多态，只有方法具有多态性

/**
* @author yxm
        * @date 2015/11/1.
        * @company 中国奇奇科技有限公司
        * @description 静态方法不具备多态性
        */
public class StaticPolymorphism {
    public static void main(String[] args) {
        StaticSuper sup = new StaticSub();
        System.out.println(sup.dynamicGet());
        System.out.println(sup.staticGet());
    }
}
class StaticSuper{
    public static String staticGet(){
        return "Base staticGet()";
    }
    public String dynamicGet(){
        return "Base dynamicGet()";
    }
}
class StaticSub extends StaticSuper{
    public static String staticGet(){
        return "Derived staticGet()";
    }
    public String dynamicGet(){
        return "Derived dynamicGet()";
    }
}
//Derived dynamicGet()
//Base staticGet()
//静态方法不具有多态性，静态方法不与对象关联，而与类关联

　　构造器与多态

　　构造器不同于其他种类的方法。涉及到多态时，仍是如此。尽管构造器并不具有多态性（它们实际上是static方法，只不过该static声明是隐式的），但还是非常有必要理解构造器怎样通过多态在复杂的层次结构中运作。

　　构造器的调用顺序

　　基类的构造器总是在导出类的构造过程中被调用，而且按照继承层次逐渐向上链接，以使每个基类的构造器都能够得到调用。这样做是有意义的，因为构造器具有一项特殊任务，检查对象是否被正确的构造。导出类只能访问它自己的成员，不能访问基类中的成员。只有基类的构造器才具有恰当地知识和权限来对自己的元素进行初始化。因此，必须令所有的构造器都得到调用，否则就不可能正确的构造完整对象。这正是编译器为什么要强制每个导出类部分都必须调用构造器的原因。在导出类的构造器主体中，如果没有明确指定调用某个基类构造器，它就会默默的调用默认构造器。如果不存在默认构造器，编译器就会报错。

public class Sandwich extends PortableLunch{
    Sandwich(){
        System.out.println("Sandwich()");
    }
    private Bread b = new Bread();
    private Cheese c = new Cheese();
    private Lettuce l = new Lettuce();

    public static void main(String[] args) {
        new Sandwich();
    }
}
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()");
    }
}
//Meal()
//Lunch()
//PortableLunch()
//Bread()
//Cheese()
//Lettuce()
//Sandwich

　　在此例中，对象调用构造器要遵照下面的顺序：

　　1、调用基类构造器。这个步骤会不断地反复递归下去，首先是构造这种层次结构的根，然后是下一层导出类，等等，直到最底层导出类；

　　2、按声明顺序调用成员的初始化方法

　　3、调用导出类构造器的主体

　　构造器的调用顺序是很重要的。当进行继承时，我们一切知道基类的一切，并且可以访问基类中声明为public和protected的成员。这意味这在导出类中，必须假定基类的所有成员都是有效的。一种标准方法是，构造动作一经发生，那么对象所有部分的全体成员都会得到构建。然而，在构造器内部，我们必须确保所要使用的成员都已构建完毕。为确保这一目的，唯一的办法就是首先调用基类构造器。那么在进入导出类构造器时，在基类中可供我们访问的成员都已得到了初始化。此外，知道构造器中所有成员都有效也是因为当成员对象在类中进行定义时，只要有可能，就应该对它们进行初始化。若遵循这一规则，那么就能保证所有基类成员以及当前对象的成员对象都已被初始化。

　　继承和清理

　　通过组合方法和继承来创建新类时，永远不必担心对象的清理问题，子对象通常都会留给垃圾回收器进行处理。如果确实遇到清理的问题，那么必须用心为新类创建dispose（）方法。并且由于继承的缘故，如果我们有其他作为垃圾回收器一部分的特殊清理动作，就必须在导出类中覆盖dispose（）方法。当覆盖被继承类的dispose（）方法时，务必记住调用基类版本dispose（）方法；否则，基类的清理动作就不会发生。

ublic class Frog extends Amphibian{
    private Characteristic c = new Characteristic("Croaks");
    private Description d = new Description("Eats Bugs");
    Frog(){
        System.out.println("Frog()");
    }
    protected void dispose(){
        System.out.println("Frog dispose");
        c.dispose();
        d.dispose();
        super.dispose();
    }

    public static void main(String[] args) {
        Frog frog = new Frog();
        System.out.println("bye bye");
        frog.dispose();
    }
}
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 d = new Description("Basic Living Creature");
    LivingCreature(){
        System.out.println("LivingCreature()");
    }
    protected void dispose(){
        System.out.println("LivingCreature dispose");
        d.dispose();
        p.dispose();
    }
}
class Animal extends LivingCreature{
    private Characteristic c = new Characteristic("has heart");
    private Description d = new Description("Animal not Vegetable");
    Animal(){
        System.out.println("Animal()");
    }
    protected void dispose(){
        System.out.println("Animal dispose");
        c.dispose();
        d.dispose();
        super.dispose();
    }

}
class Amphibian extends Animal{
    private Characteristic c = new Characteristic("can live in water");
    private Description d = new Description("Both water and land");
    Amphibian(){
        System.out.println("Amphibian()");
    }
    protected void dispose(){
        System.out.println("Amphibian dispose()");
        c.dispose();
        d.dispose();
        super.dispose();
    }
}
//Creating Characteristic is alive
//Creating Description Basic Living Creature
//LivingCreature()
//Creating Characteristic has heart
//Creating Description Animal not Vegetable
//Animal()
//Creating Characteristic can live in water
//Creating Description Both water and land
//Amphibian()
//Creating Characteristic Croaks
//Creating Description Eats Bugs
//Frog()
//bye bye
//Frog dispose
//disposing Characteristic Croaks
//disposing Description Eats Bugs
//Amphibian dispose()
//disposing Characteristic can live in water
//disposing Description Both water and land
//Animal dispose
//disposing Characteristic has heart
//disposing Description Animal not Vegetable
//LivingCreature dispose
//disposing Characteristic is alive
//disposing Description Basic Living Creature

　　层次结构中的每个类都包含Characteristic和Description这两种类型的成员对象，并且它们也必须被销毁。所以万一某个子对象要依赖于其他对象，销毁的顺序应该和初始化顺序相反。对于字段，则意味着和声明的顺序相反（因为字段的初始化是按照声明的顺序进行的）。对于基类，应该首先对导出类进行清理，然后才是基类。这是因为导出类的清理可能会调用基类中的某些方法，所以需要使基类中的构建仍起作用而不应过早的销毁它们。

　　构造器内部的多态的方法行为

　　构造器内部调用的普通方法不会是基类的方法，即使在使用多态的情况下：

public class PolyConstructors {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}
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 i){
        this.radius = i;
        System.out.println("RoundGlyph.RoundGlyph(),radius="+radius);
    }
    void draw(){
        System.out.println("RoundGlyph.draw(),radius="+radius);
    }
}
//Glyph() before draw()
//Glyph.draw()
//Glyph() after draw()
//RoundGlyph.RoundGlyph(),radius=5

　　协作返回类型

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);
    }
}
class Grain{
    @Override
    public String toString() {
        return "Grain";
    }
}
class Wheat extends Grain{
    @Override
    public String toString() {
        return "Wheat";
    }
}
class Mill{
    Grain process(){
        return new Grain();
    }
}
class WheatMill extends Mill{
    @Override
    Wheat process(){
        return new Wheat();
    }
}
//Grain
//Wheat