Java程序基础——多态

柿子镭

已于 2022-04-06 11:38:30 修改

阅读量1.2k

点赞数 1

分类专栏： Java 文章标签： Java 多态

于 2022-03-29 16:05:44 首次发布

本文链接：https://blog.csdn.net/weixin_45890771/article/details/123820588

版权

Java 专栏收录该内容

46 篇文章 2 订阅

订阅专栏

一、多态的概述

多态是继封装、继承之后，面向对象的第三大特性。
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方法

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

三、多态——成员的特点

成员变量

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）,所以在转换前需要做类型的判断。

总结：