Java程序基础——多态

目录

一、多态的概述

二、多态的定义和使用格式

三、多态——成员的特点

四、instanceof关键字 

五、多态-转型

六、多态的好处和弊端

        七、多态使用的前提

---

一、多态的概述

• 多态是继封装、继承之后，面向对象的第三大特性。
• Java作为面向对象的语言，同样可以描述一个事务的多种形态。如Student类继承了Person类，一个Student类的对象既是Student，又是Person。
• Java中，多态的代码体现在一个子类对象既可以给这是子类引用变量赋值，也可以给这个子类的父类变量赋值。
• 多态的最终体现，就是父类引用变量可以指向子类对象。
• 所以，多态的前提，是必须在子父类关系或类实现接口关系，否则无法完成多态
• 在使用多态后的父类引用变量，调用方法时，会调用子类重写后的方法

二、多态的定义和使用格式

• 定义格式：父类的引用变量指向子类对象

父类类型 变量名 = new 子类类型（）;
变量名.方法名()

• 普通类

父类 变量名 = new 子类();
变量名.方法名()
class A {}
class B extends A {}
A a = new B();

• 抽象类

抽象类 变量名 = new 子类（）;
变量名.方法名();
abstract class A {
  abstract void method();
}
class B extends A {
  public void method(){ 
  }
}

A a = new B();
a.method();

• 接口

接口 变量名 = new 子类（）;
变量名.方法名();
interface A {
  void method();
}
class B implement A {
  public void method(){ 
  }
}

A a = new B();
a.method();

• 注意：同一父类的方法可以被不同子类重写。在调用方法时，调用的为各个子类重写后的方法

Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.show();   // animal1调用的时Dog重写后的show方法
animal2.show();   // animal2调用的时Cat重写后的show方法

 当父类引用变量指向不同子类对象时，由于每个子类重写父类方法的内容不同，所以才会调用不同的方法。

三、多态——成员的特点

1. 成员变量

class A {
  int num = 4;
}

class B extends A {
   int num = 5;
}
 
class Demo extends B {
   public static void main(String[] args) {
     A a = new B();
     System.out.println("A:"+ a.num);   // 输出结果：4
     B b = new B(); 
     System.out.println("B:"+ b.num);   // 输出结果：5
    }
}

       当子父类出现同名的成员变量，多态调用该变量时 ：

        编译时期：参考的是引用类型变量所属的类中是否有被调用的成员变量；如果没有，                                        编译失败.

        运行时期：也是参考引用类型变量所属的类中的成员变量.

简单记：多态的成员变量，编译、运行都看“=”左

     2. 多态成员方法

class A {
  int num = 4;
  void show(){
         System.out.println("A类的show方法");  
   }
}

class B extends A {
   int num = 5;
   void show(){
         System.out.println("B类的show方法");  
   }
}
 
class Demo {
   public static void main(String[] args) {
     A a = new B();
     a.show();
     B b = new B(); 
     b.show();
    }
}

         编译时期：参考的是引用类型变量所属的类，如果该类中没有调用的方法，编译失败.

         运行时期：参考引用类型变量指向对象所属的类，并运行对象所属类中的成员方法。

简单记：多态的成员方法，编译看左边、运行都看右边

四、instanceof关键字 

        intanceof用来判断某个对象是否属于某种数据类型。

        使用格式：

boolean b = 对象 instanceof 数据类型；

五、多态-转型

• ​向上转型

  当子类对象赋值给一个父类引用变量时（父类引用指向子类对象），就是向上转型

• 使用格式：

父类类型 变量名 = new 子类类型

• 向下转型

  一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程叫向下转型。如果直接创建的父类对象，是无法向下转型的。

  使用格式：

  父类类型 父类变量 = new 子类类型();
  子类类型 变量名 = （子类类型）父类变量；

  class Fu{
   public void show(){}
  }
  
  class Zi extends Fu{
   public void show2(){}
  }
  
  class Zi2 extends Fu{
   public void show2(){}
  }
  
  Fu fu = new Zi();
  if(fu instanceof Zi){
     ((Zi)fu).show2();
  }
  ((Zi2)fu).show2();    // 类型转换异常
  

六、多态的好处和弊端

• 向上转型

  好处：​​隐藏了子类类型，提高了代码的扩展性。

  ​弊端：只能使用父类共性的内容，无法使用子类特性的内容，功能上有限制

• 向下转型

  ​好处：能使用子类的特性内容

  ​弊端：需要面对具体的子类对象；在向下转型的过程中容易发生类型转换异常（ClassCastException）,所以在转换前需要做类型的判断。

总结：

• 什么时候使用向上转型？

  当不需要面对子类类型时，或者使用父类的功能就能完成相应的操作，这时候就可以使用向上转型。

• 什么时候使用向下转型？

  ​当需要使用子类特有功能时，​就需要使用向下转型。

七、多态使用的前提

• 有继承或者实现关系
• 需要方法重写
• 父类引用指向子类对象

面向对象的三大特性：封装、继承、多态

三大特性的作用：

• 封装：把对象的属性与方法时向细节隐藏，仅对外提供一些公共的访问方式。
• 继承：子类会自动拥有父类所有可继承的属性和方法。
• 多态：配合继承与方法重写，提高了代码的复用性和扩展性。