Java中多态性

Java中多态性的实现

什么是多态

面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
多态的作用：消除类型之间的耦合关系。
现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

多态存在的三个必要条件

• 要有继承；
• 要有重写；
• 父类引用指向子类对象。

 class A {
　}
　
class B extends A {
　　}
　　。。。
A b = new B();

---

1,继承时，子类会隐藏父类相同的方法，要调用父类方法就必须使用super关键字。
2,向上转型时，子类会丢失和父类不同的方法（只保留重写的方法），可以使用父类的不同名的所有方法。

父类引用，只会调用子类中重写父类的方法，你在子类定义其他的方法，会调用不到
父类引用肯定能调父类的方法，被重写的就不调了

父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，父类引用是无法调用的；

示例一

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


public class PolyDemo09{
    public static void main(String[] args){
    A a1 = new A();
    A a2 = new B();//B类型向上转型丢失与A类不同方法
    B b = new B(); 
    C c = new C();
    D d = new D();

    System.out.println("⑴ " + a1.show(b));//B类的父类是A，所以A and A
    System.out.println("⑵" + a1.show(c)); //C类父类的父类是A，D和他是同级。所以A and A
    System.out.println("⑶" + a1.show(d));//D类方法有，所以不会向上转型，所以A and D
    System.out.println("⑷" + a2.show(b)); 
    /*注意这时候a2的两个方法其实是
    public String show(D obj) {
    return ("A and D");
    }
    public String show(A obj) {
    return ("B and A");
    }  B的父类是A，所以B and A 
    */                                                           
    System.out.println("⑸    " + a2.show(c));//C的父类的父类是A，所以B and A；
    System.out.println("⑹    " + a2.show(d));  //D有对应方法，所以A and D
    System.out.println("⑺    " + b.show(b)); /*这个就是继承了，继承除了隐藏父类中和子类同名的方法外，在子类中可以直接使用父类的方法。所以B and B
所以就变成了
    public String show(D obj) {
        return ("A and D");
    }
    public String show(B obj) {
        return ("B and B");
    }
    public String show(A obj) {
        return ("B and A");
    */
    System.out.println("⑻    " + b.show(c)); //C 的父类是B，所以B and B
    System.out.println("⑼    " + b.show(d));//D有相应方法，所以A and D

    }
}

示例2

//父类   
 class Father{   
    //父类有一个打孩子方法   
    public void hitChild(){   
    }   
}   
//子类1   
 class Son1 extends Father{   
    //重写父类打孩子方法   
    public void hitChild(){   
      System.out.println("为什么打我？我做错什么了！");   
    }   
}   
//子类2   
 class Son2 extends Father{   
    //重写父类打孩子方法   
    public void hitChild(){   
      System.out.println("我知道错了，别打了！");   
    }   
}   
//子类3   
 class Son3 extends Father{   
    //重写父类打孩子方法   
    public void hitChild(){   
      System.out.println("我跑，你打不着！");   
    }   
}   
//测试类   
public class Test{   
    public static void main(String args[]){   
      Father father;   
      father = new Son1();   
      father.hitChild();   
      father = new Son2();   
      father.hitChild();   
      father = new Son3();   
      father.hitChild();   
    }   
}  
/*
为什么打我？我做错什么了！
我知道错了，别打了！
我跑，你打不着！
*/

这个例子，说明，向上转型，父类引用调用的是子类重写的方法。