【Java概念】多态（9）

package cn.hncu.program.extends_.polymorphic;

/**
 * 项目名：polymorphic 【类型的多态】
 * 时间 ：2017-9-12 下午5:17:45
 */

/* 
 * 【多态】：
 * 1.同一行为的多种不同表达方式，或者同一行为的不同实现叫做多态。
 * 2.子类通过继承方式扩充和发展了它的父类，继承约定了子类与父类之间存在的isA(是一个)关系，
 *   子类是父类中的一种特殊类型。
 * 【子类对象即是父类对象】：
 * 1.子类对象既属于当前类，也属于父类类型。
 * 2.当创建一个类的实例的时候也隐含的创建了一个其父类的一个实例。
 * 【父类对象引用子类实例】：
 * 1.子类对象即是父类对象，表现为父类与子类之间具有赋值相容性，即父类对象 能够引用子类实例。
 * 【运行规则】：
 * 1.方法覆盖后出现的运行时多态，其运行规则是：编译时看数据类型，运行时看实际的对象类型(new谁调谁)。
 *  
 * 【编译时多态和运行时多态】：
 * 1.根据什么时候才执行多态方法中的哪一个，多态分为两种情况：编译时多态和运行时多态。
 *   如果在编译时能够确定的多态方法中的哪一个 ，称为编译多态，否则称为运行时多态。
 * 2.编译时多态：
 *   方法重载都是编译时多态。
 * 3.运行时多态：
 *   方法覆盖表现出两种多态性，当对象引用本类实例的时候，为编译多态，否则为运行时多态，
 * 4.程序执行时，Java从实例所属的类开始寻找匹配的方法执行，如果当前类中没有匹配方法，
 *   则沿着继承关系逐层向上，直到Object类。
 * 5.因此父类对象只能执行那些在父类中声明、被子类覆盖了的子类方法。
 * 6.编译时多态看的是类型中有没有对应的变量或方法，此时还没有执行，现在只是编译成.class的阶段，
 *    此时没有内存。
 * 
 * 7.可以用强转解决编译时多态。
 * 
 * 【匹配原则】：
 * 先：确保参数完全匹配的原则下，依次匹配this、super。
 * 再：考虑参数用super(O)渐进匹配O，依次匹配this、super。
 * 当：存在子类覆盖父类方法时 ，根据new子类实例的原则，先调子类方法。
 * 【匹配顺序】：
 * this.show(O)-->
 * super.show(O)-->
 * this.show(super(O))-->
 * super.show(super(O))
 *     
 */


public class Polymorphic {
    public static void main(String[] args) {
        /*
         * 【所有的类都有一个Object父类】：
         * 1.instanceof 判断的是堆内存中的数据。
         * 2.由下边判断出p对象也是Object类型。
         */
        Person p = new Person("Jack", 22);
        boolean boo = p instanceof Object;
        System.out.println(boo);

        /*
         * Object obj = p;
         * String name = obj.getName();
         * 1.这段代码是编译错误的。
         * 2.编译时多态看的是类型中有没有对应的变量或方法(看Object类中有没有getName方法)，
         *   此时还没有执行，现在只是编译成.class的阶段，此时没有内存。
         * 3.只有在运行的时候才会到内存中去找getName方法。
         */

        /*
         * 【子类表现出父类的形态】：
         * 1.子类可以调用父类的成员方法，因为子类继承了父类的普通成员方法，
         *  子类调用toString方法的时候，先从子类找，如果没有则到父类找。
         * 
         */
        String str = p.toString();
        System.out.println("str = "+str);
    }
}

class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

关于多态的一个问题：

package cn.hncu.program.extends_.polymorphic;

public class Polymorphic_Test {
    public static void main(String args[]){
        A a1 = new A();   A a2  = new B();  
        B b = new B();    C c = new C();   D d = new D();   
       print(a1.show(b));  
       print(a1.show(c));  
       print(a1.show(d));
       print(a2.show(b)+"::::");   
       print(a2.show(c)); 
       print(a2.show(d)); 
       print(b.show(b));     
       print(b.show(c));    
       print(b.show(d)); 
       /*执行结果：
        A and A
        A and A
        A and D
        B and A::::
        B and A
        A and D
        B and B
        B and B
        A and D
        */
    }
    public static void print(String str){
        System.out.println(str);
    }
}
class A {  
    public String show(D obj){  
         return ("A and D");  
    }   
    public String show(A obj){  
          return ("A and A");  
    }   
}   
class B extends A{  
    public String show(B obj){  
           return ("B and B");  
    }  
    public String show(A obj){  
           return ("B and A");  
     }   
}  
class C extends B{}   
class D extends B{}

动态绑定：

/*
* 【动态绑定】：
* 1.方法调用和方法体在运行时刻的连接就称之为动态绑定（dynamic binding）。
* 2.动态绑定，它意味着绑定在运行期间进行，以对象的类型为基础。动态绑定也
* 叫做“后期绑定”或“运行期绑定”。若一种语言实现后后期绑定，同时必须提供一些机制，
* 可在运行期间判断对象的类型，并分别调用适当的方法。也就是说，编译器此时依然不知道
* 对象的类型，但方法调用机制能自己去调查，找到正确的方法主体。不同的语言对后期绑定的
* 实现方法是有所区别的。但我们至少可以这样认为：它们都要在对象中安插某些特殊类型的信息。
* 3.Java中绑定的所有方法都采用后期绑定技术，除非一个方法已被声明成final。这意味着我
* 们通常不必决定是否应进行后期绑定——它是自动发生的。
*/