面向对象的程序设计语言的三大特征是：抽象、继承、多态

封装通过合并特征和行为来创建新的数据类型。实现隐藏则通过将私有化把接口和实现分离。多态的作用是消除类型之间的耦合关系。继承允许将对象视为它自己本身的类型或其父类型来加以处理。允许将多种类型（从同一父类继承的）视为同一类型来处理。多态方法调用允许一种类型表现出与其他相似类型之间的区别，只要它们都是从同一父类继承而来的。这种区别是根据方法行为的不同而表现出来的，虽然这些方法都可以通过同一父类来调用

1. 再论向上转型

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

class Instrument{
    public void play(Note n){
        System.out.println("Instrument.play()");
    }
}
public class Wind extends Instrument{
    public void play(Note n){
        System.out.println("Wind.play() " + n);
    }
}

public class Music {
    public static void tune(Instrument i){ // 接受一个Instrument 引用，同时也接受任何Instrument的子类
        i.play(Note.MIDDLE_C);
    }

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

public enum Note {
    MIDDLE_C,C_SHARP,B_FLAT;
}

2. 方法调用绑定

将一个方法调用和一个方法主体关联起来被称作绑定。在上面的代码中，因为编译器只有1个Instrument引用时，它无法知道究竟调用哪个方法，解决的方法就是后期绑定，后期绑定的含义就是在运行时根据对象的类型进行绑定。后期绑定也叫做动态绑定或运行时绑定。也就是说，编译器一直不知道对象的类型，但是方法调用机制能找到正确的方法体，并加以调用。

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

为什么要将某个方法声明为final呢？它可以防止其他人覆盖该方法。最重要的一点是：这样可以有效地关闭动态绑定。或者说，告诉编译器不需要对其进行动态绑定。这样，编译器就可以为final方法调用生成更有效的代码

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

继承图

向上转型可以像下面这条语句这么简单：Shape s = new Circle();

此时调用父类方法（父类方法已经在子类中被覆盖）：s.draw();，由于后期绑定（多态），还是正确调用了Circle.draw()方法

package com.testya.test;

class Instrument{
    void play(Note n){
        System.out.println("Instrument.play() " + n);
    }
    String what(){
        return "Instrument";
    }

    void adjust(){
        System.out.println("adjusting instrument");
    }
}

class Wind extends Instrument{
    void play(Note n){
        System.out.println("Wind.play() " + n);
    }
    String what(){
        return "Wind";
    }

    void adjust(){
        System.out.println("adjusting Wind");
    }
}

class Percussion extends Instrument{
    void play(Note n){
        System.out.println("Percussion.play() " + n);
    }
    String what(){
        return "Percussion";
    }

    void adjust(){
        System.out.println("adjusting Percussion");
    }
}

class Stringed extends Instrument{
    void play(Note n){
        System.out.println("Stringed.play() " + n);
    }
    String what(){
        return "Stringed";
    }

    void adjust(){
        System.out.println("adjusting Stringed");
    }
}

class Brass extends Wind{
    void play(Note n){
        System.out.println("Brass.play() " + n);
    }
    void adjust(){
        System.out.println("adjusting Brass");
    }
}

class Woodwind extends Wind{
    void play(Note n){
        System.out.println("Woodwind.play() " + n);
    }
    void adjust(){
        System.out.println("adjusting Woodwind");
    }
}
public class Music3 {
    public static void tune(Instrument i){
        i.play(Note.MIDDLE_C);
    }

    public static void tuneAll(Instrument[] e){
        for(Instrument i : e){
            tune(i);
        }
    }

    public static void main(String[] args) {
        Instrument[] Orchestra = {new Wind(),new Percussion(),new Stringed(),new Brass(),new Woodwind()};
        tuneAll(Orchestra);
    }
}

public enum Note {
    MIDDLE_C,C_SHARP,B_FLAT;
}

域和静态方法

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;
    }
}
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());
    }
}

当Sub对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的。在上面的例子中，为Super.field和Sub.field分配了不同的存储空间。这样，Sub实际上包含两个称为field的域：它自己的和它从Super处得到的。然而在引用Sub中的field时所产生默认域并非Super版本的field域。因此，为了得到Super.field，必须显式地指明super.field。在实际开发中，首先要将所有的域设置成private，因此不能直接访问它们，其副作用是只能调用方法来访问。另外，不要对父类中的域和子类中的域赋予相同的名字，因为这种做法容易令人混淆

如果某个方法是静态的，它的行为就不具有多态性：静态方法是与类，而并非与单个对象相关联的

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";
    }
}
public class StaticPolymorphism {
    public static void main(String[] args) {
        StaticSuper sup = new StaticSub();
        System.out.println(sup.staticGet());
        System.out.println(sup.dynamicGet());
    }
}

3. 构造器和多态

构造器实际上是static方法，只不过该static声明是隐式的，所以构造器并不具有多态性

构造器在多态的层次结构中的调用顺序

子类构造过程中调用父类的构造器，而且是按照继承层次逐渐向上链接，以使每个父类的构造器都能得到调用。这样做的原因是：因为构造器的重要任务之一是：检查对象是否被正确地构造，子类只能访问它自己的成员，不能访问父类的成员（父类成员通常是private的）。所以只有父类才能正确的初始化。因此所有的构造器都必须得到调用。在子类的构造器中，如果没有明确指定调用某个父类构造器，子类构造器会自动调用默认构造器，如果不存默认构造器，编译器就会报错（若某个类没有构造器，便器会自动合成出一个默认构造器）

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 b = new Bread();
    private Cheese c = new Cheese();
    private Lettuce l = new Lettuce();
    public Sandwich(){
        System.out.println("Sandwich()");
    }

    public static void main(String[] args) {
        new Sandwich();
    }
}
/** 执行结果：
Meal()
Lunch()
PortableLunch()
Bread()
Cheese()
Lettuce()
Sandwich()
*/

上面的例子中，每个类都有构造器，并且Sandwich体现了三层继承关系以及三个成员对象。当在main()方法里创建Sandwich()对象后，就可以看到输出结果：
1）先调用父类的构造器，这个步骤会不断的反复递归下去，首先是Meal类，然后是下一层子类Lunch，最后是PortableLunch
2）按声明顺序调用Sandwich成员的初始化方法
3）调用Sandwich构造器

构造器内部的多态方法

在一般的方法内部，动态绑定的调用是在运行时才决定的，因为对象无法知道方法所在的那个类，还是属于那个类的子类

如果要调用的构造器内部的一个动态绑定方法，就是用到那个方法的被覆盖后的定义，这个调用的效果可能相当难以预料，因此被覆盖的方法在对象被完全构造之前就会被调用。

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 PloyConstructors {

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

在上面的例子中，Glyph.draw()方法设计为被覆盖，这种覆盖是在RoundGlyph发生的。但是Glyph构造器会调用这个方法，结果导致了对
RoundGlyph.draw()的调用。但是从输出结果看，此时radius不是默认初始值1，而是0

所以，初始化的实际过程是：
1）在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制的零
2）如前所述那样调用父类的构造器。此时，调用被覆盖后的draw()方法（在RoundGlyph构造器之前调用），由于步骤1的缘故，此时发现radius的值为0
3）按照声明的顺序调用成员的初始化方法
4）调用子类的构造器主体

因此，编译构造器时有一条有效的准则：用尽可能简单的方法使对象进入正常状态；如果可以的话，避免调用其他方法。在构造器中唯一能够安全调用的那些方法是父类中的final方法（也适用于private方法，它们自动属于final方法，这些方法不能被覆盖）

4.协变返回类型

JavaSE5 中添加了协变返回类型，它表示在子类中的被覆盖的方法可以返回父类方法的返回类型的某种子类类型

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);
    }
}

5.用继承进行设计

class Actor{
    public void act(){}
}

class HappyActor extends Actor{
    public void act(){
        System.out.println("HappyActor");
    }
}

class SadActor extends Actor{
    public void act(){
        System.out.println("SadActor");
    }
}

class Stage{
    private Actor actor = new HappyActor();
    public void change(){
        actor = new SadActor();
    }
    
    public void performPlay(){
        actor.act();
    }
}
public class Transmogrify {
    public static void main(String[] args) {
        Stage stage = new Stage();
        stage.performPlay();
        stage.change();
        stage.performPlay();
    }
}

在上面的例子中：Stage对象包含一个对Actor的引用，而Actor被初始化为
HappyActor对象。这意味着performPlay()会产生某种行为，并且SadActor对象的引用可以在actor中被替代，performPlay()产生的行为也随之改变。这样一来，我们在运行期间获得了动态灵活性（这也称作状态模式）

通常：用继承表达行为间的差异，用字段表达状态上的变化。在上述例子汇总，两者都用到了：通过继承得到了两个不同的类，用于表达act()方法的差异，而Stage通过运用组合使自己的状态发生变化。在这种情况下，状态的改变也就产生了行为的改变。

纯继承域扩展

用纯继承的方式创建继承层次结构，也就是说，只有在父类中已经建立的方法才可以在导出类中被覆盖。这种被称作是纯碎的is-a(是一种)关系，因为一个类的接口已经确定了它应该是什么。继承可以确保所有子类具有父类的接口，且绝对不会少。在使用中子类可以完全替代父类，而且使用子类时，完全不需要知道关于子类的任何额外信息，因为父类可以接受发送给子类的任何消息，由于二者有完全相同的接口，我们只需从子类向上转型，用于不需要正在处理的对象的确切类型。所有这一切，都是通过多态来处理的

但是在实际开发中，扩展接口才是解决特定问题的完美方案。这可以在称为“is-like-a”(像一个)关系，因为子类就像是一个父类-拥有父类相同的基本接口，但是子类还可以具有额外方法实现的其他特性

但这种方式也具有其缺点，就是子类的部分接口是不能被父类访问的，这时，一旦向上转型，就不能调用子类中父类中并没有定义的那些方法

向下转型与运行时类型识别

在Java中，所有的转型都会得到检查！所以即使我们只是进行一次普通的加括号形式的类型转换，在进入运行期时仍然会对其进行检查，以保证它的确是我们希望的哪种类型，否则，如果不是，就会返回一个ClassCastException（类转型异常），这种在运行期间对类型进行检查的行为称作“运行时类型识别”（RTTI）

class Useful{
    public void f(){}
    public void g(){}
}

class MoreUseful extends Useful{
    public void f(){}
    public void g(){}
    public void 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[0].g();
        ((MoreUseful)x[1]).u(); // RTTI 向下转型
        // ((MoreUseful)x[0]).u();  // ClassCastException ，Useful对象不能转型为MoreUseful
    }
}