面向对象-多态

1. 多态的概念

  1. 同一个数据类型的不同对象对同一种行为会有多种不同的实现。

2. 多态的前提

  1. ① 子类重写了父类的方法
  3. ② 父类引用指向子类对象（创建的是一个子类的对象，并把该对象赋值给一个变量，这个变量的类型是其父类类型）
  5. 例如：
  1. Animal a = new Dog();
  2. Animal b = new Cat();

3. 父类引用指向子类对象后成员访问的特点

  1. 除了成员方法编译看左边，运行看右边。其他所有成员都是编译看左边，运行看左边。
  3. 解读：编译期间会去看左边(父类),看父类有没有这个成员方法。如果没有则直接报错,如果有则编译通过,不报错。运行期间,实际执行代码,看的是右边(子类),看子类中有没有重写该方法,如果有则执行子类中的该方法,如果没有<br />

则运行父类中的该方法。

4. 多态的应用场景

  1. 多态最大的应用场景其实就用在方法的参数上。在适当的时候把方法的参数类型定义成父类类型。调用方法的时候就可以传入任意的子类对象。提高了代码的复用性和可扩展性。

5. 多态的优缺点

优点：提高了代码的复用性和可扩展性

缺点：不能直接使用子类的成员。

6.向上转型，向下转型

6.1 向上转型

  1.         向上转型就是子类转父类。因为是绝对安全的所以会自动进行转换。

例如：

  1.     Animal a = new Dog();

6.2 向下转型

  1.       向上转型就是父类转子类。因为不是绝对安全的所以必须使用强转的方式来进行转换。

例如：

  1.     Animal a = new Dog();
  2.     Dog d = (Dog)a;

注意：必须是这个子类的对象才可以转换成该子类,否则会出异常

6.3 instanceof进行类型判断

  1.     在向下转型的时候为了保证安全我们可以使用instanceof进行类型判断。判断一个对象是否某个类的对象。如果是的话我们再把它转换成该类型，这样会更加安全。

6.3.1 使用格式

  1.                 对象 instanceof 类名/接口名

示例：

  1.     //判断对象是否是某个类的对象，如果是结果为true，如果不是结果为false
  2.     Animal a = new Dog();
  3.     if(a instanceof Dog){
  4.         //说明a是Dog这个类的对象，我们可以把他强转成Dog类型
  5.         Dog d = (Dog)a;
  6.     }

7. 思考题

思考下面代码的输出结果

  1. class A {  
  2.      public String show(D obj){  
  3.             return ("A and D");  
  4.      }   
  5.      public String show(A obj){  
  6.             return ("A and A");  
  7.      }   
  8. }   
  9. class B extends A{  
  11.      public String show(B obj){  
  12.             return ("B and B");  
  13.      }  
  14.      public String show(A obj){  
  15.             return ("B and A");  
  16.      }   
  17. }  
  18. class C extends B{}   
  19. class D extends B{}
  21. class  DynamicTest
  22. {    
  23.     public static void main(String[] args){
  24.         A a1 = new A();  
  25.         A a2 = new B();  
  26.         B b = new B();  
  27.         C c = new C();   
  28.         D d = new D();   
  29.         System.out.println(a1.show(b));  
  30.         System.out.println(a1.show(c));  
  31.         System.out.println(a1.show(d));  
  33.         System.out.println(a2.show(b));   
  34.         System.out.println(a2.show(c));           
  35.         System.out.println(a2.show(d));  
  37.         System.out.println(b.show(b));   
  38.         System.out.println(b.show(c));  
  39.         System.out.println(b.show(d));      
  41.     }
  42. }