Java三大特征--多态

1.定义

允许不同类的对象对同一消息做出响应，即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

2.存在条件

2.1存在继承关系

2.2子类重写了父类方法

2.3父类类型的变量指向子类对象的引用（向上转型）

3.实现方式

3.1接口实现

3.2继承父类进行方法重写

3.3同一个类中进行方法重载

4.类型的强制转换

4.1转换格式：子类新变量=（子类）变量（父类类型的引用变量指向子类对象）

4.2父类类型的变量可以转换成子类类型的变量，但是可能出现“类型转换异常”

4.3使用x instance A判断异常,要求x所属的类B与类A为父子关系：结果为true,不抛出异常

5.实例分析

实例一：

 class A {

     public String show(A obj) {

         return ("A and A");

     }

     public String show(D obj) {      //方法的重载

         return ("A and D");

     }

 }

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

     public static void main(String[] args) {

         A a1 = new A();

         B b = new B();

         C c = new C();

         D d = new D();

         //多态：父类类型的变量指向子类对象的引用

         A a2 = new B();

         //多态的表现形式：相同类型的变量，调用相同的方法，产生不一样的结果。

         System.out.println("1--" + a1.show(b));

         System.out.println("2--" + a1.show(c));

         System.out.println("3--" + a1.show(d));

         System.out.println("4--" + a2.show(b));

         System.out.println("5--" + a2.show(c));

         System.out.println("6--" + a2.show(d));

         System.out.println("7--" + b.show(b));

         System.out.println("8--" + b.show(c));

         System.out.println("9--" + b.show(d));

     }

 }

运行结果：

 1--A and A

 2--A and A

 3--A and D

 4--B and A

 5--B and A

 6--A and D

 7--B and B

 8--B and B

 9--A and D

详细说明：

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，

但是这个被调用的方法必须是在超类中定义过的，也就是被子类覆盖的方法。方法的调用关系如下：

this.method(O) // 该类自身的方法
super.method(O) // 基类的方法
this.method((super)O) // 该类自身的方法，参数向上转型
super.method((super)O) // 基类的方法，参数向上转型

示例讲解：

a1.show(b)：

1.a1是类型为A的引用变量，该变量指向A对象，b是B的一个实例；

2.在类A中查看是否存在show(B obj)方法，不存在；

3.查看类A是否存在超类(父类)，不存在；

4.查看类A是否存在show(A obj)方法，存在；

注：(super) O即(super) B，即为A，则对应的方法为show(A obj)）；

5.a1是对本身对象的引用，不考虑方法的重写，答案为 A and A。

注：第1步是分析，第2-4步分别对应上面的this.show(O)，super.show(O)，this.show((super) O)

a1.show(c):

1.a1是类型为A的引用变量，该变量指向A对象，c是C的一个实例；

2.查看类A是否存在show(C obj)方法，不存在；

3.查看类A是否存在超类(父类)，不存在；

4.查看类A是否存在show(B obj)方法，不存在；

5.查看类A是否存在超类(父类)，不存在；

6.查看类A是否存在show(A obj)方法，存在；

7.a1是对本身对象的引用，不考虑方法的重写，答案为 A and A。

a2.show(b):

1.a2是类型为A的引用变量，该变量指向A对象，b是B的一个实例；

2.查看类A是否存在show(B obj)方法，不存在；

3.查看类A是否存在超类(父类)，不存在；

4.查看类A是否有show(A obj)方法，存在；

5.a2是对子类B对象的引用，考虑方法的重写，在子类B中对类A的show(A obj)进行了重写，所以答案为B and A。

b.show(c):

1.b是类型为B的引用变量，该变量指向B对象，c是C的一个实例；

2.查看类B是否存在show(C obj)方法，不存在；

3.查看类A是否存在show(C obj)方法，不存在；

4.查看类B是否存在show(B obj)方法，存在；

5.b是对本身对象的引用，不考虑方法的重写，答案为B and B。

实例二：

 public class Person {

     public void walk(){

         System.out.println("走路");

     }

 }

 public class Man extends Person{

     public void walk(){

         System.out.println("男人快步走");

     }

     public void work(){

         System.out.println("男人是个工作狂");

     }

 }

 public class Woman extends Person{

     public void walk(){

         System.out.println("女人漫步走");

     }

     public void shopping(){

         System.out.println("女人是个购物狂");

     }

 }

 public class Test {

     public static void main(String args[]){

         Person p1=new Person();

         //多态：父类类型的变量指向子类对象的引用

         Person p2=new Man();

         Person p3=new Woman();

         //多态的表现形式：相同类型的变量，调用相同的方法，产生不一样的结果。

         p1.walk();

         虚拟方法调用：当父类的方法被子类重写时，会调用子类重写的方法，而不是父类的方法。

         p2.walk();

         p3.walk();

         在多态的情况下，只能调用父类的方法和被子类重写的方法;如果向调用子类的方法，需要进行类型的前置转换

         // p2.work();    错误

         Man m=(Man) p2;

         m.work();

         Woman w=(Woman) p3;

         w.shopping();

         父类类型的变量可以转换成子类类型的变量，但是可能出现“类型转换异常”。

         /*Woman w=(Woman) p2;

         w.shopping();*/

         /*instanceof操作符

         x instance A,要求x所属的类B与类A为父子关系

         instanceof可以检测是否会抛出类型转换异常，返回true表示可以转换类型*/

         System.out.println(p2 instanceof Man);

     }

 }

！！！

巴特西

Java三大特征--多态

最新文章

热门文章