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();
}
}
/*
为什么打我？我做错什么了！
我知道错了，别打了！
我跑，你打不着！
*/

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