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 Duotai {
       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(a1.show(b));

a1.show(b)：

1.先看引用变量a1的类型，为A，b是B的一个实例；

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

3.查看A是否有超类（父类），发现不存在；

4.查看A中是否有方法show(A obj）,存在；

注：参数b是B的实例，B为A的子类，将参数b转换为a再找方法，在A中查找是否有B可以继承的方法show(A obj)

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

System.out.println(a1.show(c));

a1.show(c):

1,2,3同上

4.A中不存在方法show(B obj)；继续步骤3,没有；继续步骤4，类A中有show(A obj)；

5.同上
            System.out.println(a1.show(d));

           System.out.println(a2.show(b));

a2.show(b):

1，2，3同上

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

注：将参数b转换为a

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

           System.out.println(b.show(b));
            System.out.println(b.show(c));

b.show(c):

1,2同上

3.B的父类A中是否有方法show(c obj),不存在；

4.B中是否有方法show(B obj),存在；

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

System.out.println(b.show(d));
}
}

实例二：

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三大特征之------多态

最新文章

热门文章