一、 复用类

  （1）组合语法：将对象置于新的类中

class A {
        private String s;
        A(int i) {
            System.out.println("A constructor");
            s = "constructed";
        }

        public String toString() {
            return s;
        }
    }

    public class B {
        private A a；
        B(int i){
            a = A(i+1); // 组合和继承混合使用。
            System.out.println("B constructor");
        }
        public void apply() {
            System.out.println("B");
        }

        public String toString() {
            return "a=" + a;
        }
    }

    public class C extends B {
        C(){
            super(11); // 有参构造器必须用super来指明超类构造。
            System.out.println("C constructor");
        }
        public void apply() {
            System.out.println("C");
            super.apply();
        }
    }

        “a=" + a ;编译器需要一个String 对象，这边将调用A 中的toString() 方法，String a 对象的值为A对象构造的初始值。 

（2）继承语法：按照现有类的类型组建新类。（在不改变现有类的基础上，复用现有类的形式并在其中添加新代码）。创建一个类的时候，都是隐式的继承标准跟类Object。

        C如何想要调用B中的apply() 的方法不可以直接调用，避免成为递归，Java中用super超类来调用。表示当前类式从超类继承来的。 

        初始化基类：构建的过程是从基类”向外“扩散的。基类是必须要初始化，但是不需要该类的成员变量一定要完成初始化工作。

  • 构造器不能被继承， 一个类能得到构造器，只有两个办法：编写构造器，或者使用默认无参构造器。
  • 如果想要调用父类有参数的构造器，则必须在子类的构造器中显式地通过super关键字调用父类的构造器，并配以适当的参数列表（必须放在第一行）（构造器的起始处）。
  • 如果想要调用父类无参数的构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。

      总结：组合是为新类显式地提供方法，而继承隐式的为新类提供方法。但继承最重要的表现在新类和基类之间的关系（新类是现有类的一种类型）

二 、 多态

      多态的作用是消除类型之间的耦合关系。继承允许将对象视为它自己本身的类型或者其基类的类型，表明它允许将多种类型（同一个基类出发）视为同一类型来处理。多态方法的调用允许一种类型表现出与其他相似类型的区别（程序运行时）。

      向上转型：对象既可以作为它自己本身使用，同时也可以作为它的基类类型使用。

向上转型有利于我们使用多态性，将在以下代码体现 。

      绑定：遇到同名的方法如何区分？---：方法如果是final或者static 属于前期绑定，不允许更改。其他的都是后期绑定，也属于动态绑定。程序运行时根据当前的对象，从而调用相应的同名方法。编译器不需要额外的特殊信息就可以正确的调用。

     可扩展性：方法可以完全忽略周围代码所发生的全部变化,依旧正常运行，是将改变的事物和未改变的事物分离出来。

     多态的缺陷：

       "覆盖"了私有方法，由于私有方法不可覆盖，所以父类和子类同名的私有方法是不同的两个方法。

      域和静态方法，由于任何的域访问和静态的方法都是编译器解析，所以它们是不具备多态性的，想要调用的话需要用super超类来调用。

     构造器和多态

     构造器是隐式的static类型，不具备多态性，构造器如何通过多态实现运作，是尤为重要的。

class A {
    A() {
        System.out.println("A");
    }
}
class B {
    B() {
        System.out.println("B");
    }
}
class C extends A {
    C() {
        System.out.println("C");
    }
}
class D extends C {
    D() {
        System.out.println("D");
    }
}
public class E extends D {
    private A a = new A();  // a
    private B b = new B();  // b
    public E () {
        System.out.println("E");    // e
    }
    public static void main(String[] args){
        new E();
    }
//outPrint
A
C
D
A
B
E

}

基于所有的类被使用必须要完成初始化工作，所以调用构造函数的顺序是：

1）调用基类的构造类

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

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