多形性

虽然是第二次看，感觉这部分还是要仔细看。多形性是面向对象编程语言的第三中特性。

首先是上溯造型（这个是什么意思就不说了），为什么需要上溯造型呢？很多书上都会用“画图”或者“乐器”的程序来和大家解释：

class Note{
    private int value;
    private Note(int val) { value = val; }
    public static final Note 
    middleC = new Note(0),
    cSharp = new Note(1),
    cFlat = new Note(2);
} // Etc.
class Instrument {
    public void play(Note n) {
        System.out.println("Instrument .play()");
    }
}
class Wind  extends Instrument {
    public void play(Note n) {
        System.out.println("Wind .play()");
    }
}
class Stringed extends Instrument {
    public void play(Note  n) {
        System.out.println("Stringed .play()");
    }
}
class Brass  extends Instrument  {
    public void play(Note  n) {
        System.out.println("Brass .play()");
    }
}
public class test {
    public static void tune(Wind  i) {
        i.play(Note .middleC);
    }
    public static void tune(Stringed  i) {
        i.play(Note .middleC);
    }
    public static void tune(Brass  i) {
        i.play(Note .middleC);
    }
    public static void main(String[] args) {
        Wind  flute = new Wind ();
        Stringed  violin = new Stringed ();
        Brass  frenchHorn = new Brass ();
        tune(flute);
        tune(violin);
        tune(frenchHorn);
    }
}
输出结果：
Wind.play()
Stringed.play()
Brass.play()

神奇吧，但是程序是怎么知道的？显然在编译的时候确定是不可能的。所以这只能“运行期绑定”了。那“运行期绑定”是怎么实现的？一般认为是在对象中安插关于类型的特殊信息（细节我还不清楚）。有了这个显然会给我们带来极大的方便，因为只要你是乐器，我调用演奏的方法你就能正确地发出声音。

继承不断地进化，就出现了“抽象类”，只要用“abstract”来修饰一个类就可以了（如果有抽象方法的话必须为抽象类）：

import java.util.*;
abstract class Instrument {
    int i;
    public abstract void play();
    public String what() {
        return "Instrument";
    }
    public abstract void adjust();
}
class Wind extends Instrument {
    public void play() {
        System.out.println("Wind.play()");
    }
    public String what() { return "Wind"; }
    public void adjust() {}
}
class Percussion extends Instrument {
    public void play() {
        System.out.println("Percussion.play()");
    }
    public String what() { return "Percussion"; }
    public void adjust() {}
}
class Stringed extends Instrument {
    public void play() {
        System.out.println("Stringed.play()");
    }
    public String what() { return "Stringed"; }
    public void adjust() {}
}
class Brass extends Wind {
    public void play() {
        System.out.println("Brass.play()");
    }
    public void adjust() {
        System.out.println("Brass.adjust()");
    }
}
class Woodwind extends Wind {
    public void play() {
        System.out.println("Woodwind.play()");
    }
    public String what() { return "Woodwind"; }
}
public class test {
    static void tune(Instrument i) {
        i.play();
    }
    static void tuneAll(Instrument[] e) {
        for(int i = 0; i < e.length; i++)
            tune(e[i]);
    }
    public static void main(String[] args) {
        Instrument[] orchestra = new Instrument[5];
        int i = 0;
        orchestra[i++] = new Wind();
        orchestra[i++] = new Percussion();
        orchestra[i++] = new Stringed();
        orchestra[i++] = new Brass();
        orchestra[i++] = new Woodwind();
        tuneAll(orchestra);
    }
}

自从有了抽象类，就不能随随便便地申请对象了，还得乖乖地实现抽象方法。既然已经到这个地步了，那和不走的更远？

import java.util.*;
interface CanFight {
    void fight();
}
interface CanSwim {
    void swim();
}
interface CanFly {
    void fly();
}
class ActionCharacter {
    public void fight() {}
}
class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
    public void swim() {}
    public void fly() {}
}
public class test {
    static void t(CanFight x) { x.fight(); }
    static void u(CanSwim x) { x.swim(); }
    static void v(CanFly x) { x.fly(); }
    static void w(ActionCharacter x) { x.fight(); }
    public static void main(String[] args) {
        Hero i = new Hero();
        t(i); // Treat it as a CanFight
        u(i); // Treat it as a CanSwim
        v(i); // Treat it as a CanFly
        w(i); // Treat it as an ActionCharacter
    }
}

接口，貌似是抽象类的进化，但是貌似没那么简单。可以“implements”多个接口，“interface”里面的东西全部被认为是“static&final”的（这这点很容易理解）。而且对接口更好的理解是“协议”。实现了多个接口的类可以上溯为多个类型（这个很好理解哈）。这个地方有个“static&final”引起的小插曲，应该算是Java怎么实现“enum”的吧：

public final class test {
    private String name;
    private test(String nm) { name = nm; }
    public String toString() { return name; }
    public final static test
        JAN = new test("January"),
        FEB = new test("February"),
        MAR = new test("March"),
        APR = new test("April"),
        MAY = new test("May"),
        JUN = new test("June"),
        JUL = new test("July"),
        AUG = new test("August"),
        SEP = new test("September"),
        OCT = new test("October"),
        NOV = new test("November"),
        DEC = new test("December");
    public final static test[] month = {
        JAN, JAN, FEB, MAR, APR, MAY, JUN,
        JUL, AUG, SEP, OCT, NOV, DEC
    };
    public static void main(String[] args) {
        test m = test.JAN;
        System.out.println(m);
        m = test.month[12];
        System.out.println(m);
        System.out.println(m == test.DEC);
        System.out.println(m.equals(test.DEC));
    }
}

有值有类型安全检查，还算不错吧？不过第一次见到这个方法好像不是在这本书上。

关于继承方面的就到此为止，下面开始“内部类”：

public class test {
    class Contents {
        private int i = 11;
        public int value() { return i; }
    }
    class Destination {
        private String label;
        Destination(String whereTo) {
            label = whereTo;
        }
        String readLabel() { return label; }
    }
    public void ship(String dest) {
        Contents c = new Contents();
        Destination d = new Destination(dest);
    }
    public static void main(String[] args) {
        test p = new test();
        p.ship("Tanzania");
    }
}

看着实现起来很简单吧！其实感觉这个东西本来就不难，关键是怎么用吧。还有就是匿名类。如果定义了一个匿名类，并想使用在匿名类内部使用外部类定义的一个对象，编译器要求外部类对象必须为final类型的（想想为什么？http://blog.csdn.net/cnitcastsdut/article/details/6020221）。这种写法是为了方便吧：

interface Destination {
    String readLabel();
}
public class test {
    public Destination dest(final String dest) {
        return new Destination() {
            private String label = dest;
            public String readLabel() { return label; }
        };
    }
    public static void main(String[] args) {
        test p = new test();
        Destination d = p.dest("Tanzania");
    }
}

威为什么内部类可以访问封装类？是因为在内部类的对象里面保存了一个外部类的指针。内部类拥有对封装类所有元素的访问权限。那如果内部类是“static”呢？创建一个static的内部类对象是不需要一个外部类对象，所以不能从static内部类的一个对象访问一个外部类对象的。

abstract class Contents {
    abstract public int value();
}
interface Destination {
    String readLabel();
}
public class test {
    private static class PContents extends Contents {
        private int i = 11;
        public int value() { return i; }
    }
    protected static class PDestination implements Destination {
        private String label;
        private PDestination(String whereTo) {
            label = whereTo;
        }
        public String readLabel() { return label; }
    }
    public static Destination dest(String s) {
        return new PDestination(s);
    }
    public static Contents cont() {
        return new PContents();
    }
    public static void main(String[] args) {
        Contents c = cont();
        Destination d = dest("Tanzania");
    }
}

怎么去声明一个内部类的对象？其实看起来并不奇怪哈，其实继承内部类的时候也是这么写的。更神奇的是内部类可以覆盖（hh）。

public class test {
    class Contents {
        private int i = 11;
        public int value() { return i; }
    }
    class Destination {
        private String label;
        Destination(String whereTo) {
            label = whereTo;
        }
        String readLabel() { return label; }
    }
    public static void main(String[] args) {
        test p = new test();
        //     Must use instance of outer class
        // to create an instances of the inner class:
        test.Contents c = p.new Contents();
        test.Destination d = p.new Destination("Tanzania");
    }
}