多态继承封装抽象多态

一.相关定义1-1 多态多态是同一个行为具有多个不同表现形式或形态的能力。同一个形参类型为基类的接口，使用不同的子类的实例可以执行不同操作。
1-2 绑定

绑定：将一个方法调用和一个方法体关联起来被称作绑定；
前期绑定：若在程序执行前进行绑定（如果有的话，由编译器和连接程序实现）；
后期绑定：在运行时根据对象的类型绑定，也叫做动态绑定或运行时绑定。

后期绑定的实现通常是在对象中安置某种“类型信息”，以便方法调用机制能知道对象是哪种类型，从而找到对应的方法体加以调用。
Java中除了static方法和final方法（private方法也属于final方法）之外，其他所有方法都是后期绑定。
1-3 总是调用最派生的方法Java在使用基类引用调用方法时，总是调用最派生的方法。选取最派生方法的范围是：基类中的方法和基类引用指向的对象所在类中覆写的同名方法。即，如果基类引用所指向对象所在的类中未覆写基类中的方法，那么通过基类引用调用的将会是基类中的方法，否则调用的就是基类引用所指向对象所在类中覆写的方法。
package com.hutao.test.page155;import static com.hutao.util.Print.print;class BaseClass {public void method1(){print("Base class's method1 call method2");method2();}public void method2(){print("Base class's method2 was called");}}class DerivedClass extends BaseClass{@Overridepublic void method2() {print("Derived class's method2 was called");}}public class Test{public static void main(String[] args) {BaseClass baseClass = new DerivedClass();//使用基类引用调用方法baseClass.method1();}}运行结果为：
Base class's method1 call method2Derived class's method2 was calledProcess finished with exit code 0如上代码中的派生关系为：

文章插图
使用基类引用调用的方法是method1()，从BaseClass baseClass = new DerivedClass()可知选取最派生方法的范围应该是BaseClass类和DerivedClass类，但DerivedClass中未覆写BaseClass中的method1()，所以最派生的method1()方法就是BaseClass中的method1() 。BaseClass中的method1()又调用了method2()，这里实际上也可理解为是通过基类引用baseClass去调用的method2()，此时，因为DerivedClass中覆写了method2()，所以选取最派生的方法就是DerivedClass类中的method2() 。
二.final方法、静态方法和域的多态结论：final方法（包括private方法）、静态方法和域没有多态特性。
2-1 final方法final方法不可以被覆写，所以同一个行为就不能有多种表现形式，所以没有多态。注意：private方法是默认的final方法。
【多态继承封装抽象多态】package com.hutao.page.page156;import static com.hutao.util.Print.*;public class PrivateOverride {private void f(){print("private f()");}public static void main(String[] args) {PrivateOverride privateOverride = new Derived();privateOverride.f();}}class Derived extends PrivateOverride{public void f(){print("public f()");}}运行结果为：
private f()Process finished with exit code 0这里还是可以根据1-3中的方式分析，从PrivateOverride privateOverride = new Derived()中可知，选取最派生f()方法的范围为PrivateOverrie类和Derived类，但是Derived类中未覆写f()方法（虽然有同名方法，但因为private方法不可能被覆写，所以Derived类中的f()只能算是另一个新方法），所以选取的范围就只剩下来基类中的f()方法，因此实际调用的方法就是基类中的f()方法。
2-2 静态方法静态方法对应的行为不具有多态性，静态方法是与类而并非单个对象关联的。
package com.hutao.page.page157;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类相关联StaticSuper staticSuper = new StaticSub();System.out.println(staticSuper.staticGet());System.out.println(staticSuper.dynamicGet());}}运行结果为：
Base staticGet()Derived dynamicGet()Process finished with exit code 02-3 域如果直接访问某个域，这个访问在编译期就进行了解析（并非是运行时绑定），所以域不具有多态性。
package com.hutao.page.page156;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 getSupperField(){return super.field;}}public class FieldAccess {public static void main(String[] args) {Super sup = new Sub();//upcastSystem.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.getSupperField());}}运行结果为：
sup.field = 0, sup.getField() = 1sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0Process finished with exit code 0三.构造器和多态3-1 构造器的多态构造器不具有多态性，因为构造器实际上是隐式声明的static方法，由2-2可知，静态方法不具有多态性。

基类的构造器总是在导出类的构造过程中被调用；
无论是基类还是导出类，在构造器被调用时，所有成员变量都已经完成了初始化。

package com.hutao.page.page158;import static com.hutao.util.Print.*;class Meal{Meal(){print("Meal()");}}class Bread{Bread(){print("Bread()");}}class Cheese{Cheese(){print("Cheese()");}}class Lettuce{Lettuce(){print("Lettuce()");}}class Lunch extends Meal{Lunch(){print("Lunch()");}}class PortableLunch extends Lunch{//此成员变量用来验证是先初始化成员再调用构造器的。private Bread bread = new Bread();PortableLunch(){print("PortableLunch()");}}public class Sandwich extends PortableLunch{private Bread bread = new Bread();private Cheese cheese = new Cheese();private Lettuce lettuce = new Lettuce();public Sandwich(){print("Sandwich()");}public static void main(String[] args) {new Sandwich();}}运行结果为：
Meal()Lunch()Bread()//表明成员被初始化在构造器被调用之前PortableLunch()Bread()Cheese()Lettuce()Sandwich()Process finished with exit code 0调用构造器的顺序为：
1）调用基类构造器。这个步骤会不断反复递归下去，首先是构造这个层次结构的根（根基类），然后是下一层的导出类，直到最低层的导出类（构造器执行前需保证类中的所有成员按声明顺序完成了初始化）；
2）按声明顺序调用最低层导出类的初始化方法；
3）调用最低层导出类构造器的主体。
3-2 基类构造器中调用具有多态特性的方法如果要在基类构造器中调用一个可被动态绑定的方法，实际上调用时绑定的方法体可能会是导出类中覆盖此方法的方法体。这个调用结果可能会引发错误，因为在调用基类构造器时，导出类对象还未被完全构造。（在构造导出类对象时候，会先调用基类的构造器。）
package com.hutao.page.page163;import static com.hutao.util.Print.*;class Glyph{void draw(){print("Glyph.draw()");}Glyph(){print("Glyph() before draw()");draw();print("Glyph() after draw()");}}class RoundGlyph extends Glyph{private int radius = 1;RoundGlyph(){this.radius = radius;print("RoundGlyph.RoundGlyph(), radius = "+radius);}@Overridevoid draw() {print("RoundGlyph.draw(), radius = "+radius);}}public class PolyConstructors {public static void main(String[] args) {new RoundGlyph();}}运行结果为：
Glyph() before draw()RoundGlyph.draw(), radius = 0Glyph() after draw()RoundGlyph.RoundGlyph(), radius = 1Process finished with exit code 0Glyph.draw()方法设计为将要被覆盖，这种覆盖是在RoundGlyph中发生的。但是Glyph构造器会调用这个方法，结果导致了对RoundGlyph.draw()的调用。但是此时RoundGlyph中的radius还未被初始化（还是二进制0）。
初始化的具体过程：（->）https://www.cnblogs.com/certainTao/p/14657469.html

编写构造器的准则：用尽可能简单的方法使对象进入正常状态；如果可以的话，避免调用其他方法。
在构造器中唯一能够安全调用的方法是本类中的final方法（private方法默认是final方法），这类方法不能被覆盖（其实调用静态方法也是可以的，但这里要表明的重点不是这个）。

多态继承封装抽象 多态

多态继承封装抽象多态