面向对象特征三：多态性

姜小白程序

已于 2024-04-02 16:00:19 修改

阅读量555

点赞数 9

文章标签： java 开发语言

于 2024-04-02 15:27:02 首次发布

本文链接：https://blog.csdn.net/m0_59281987/article/details/137271871

版权

一千个读者眼中有一千个哈姆雷特。

多态的形式和体现

对象的多态性

多态性，是面向对象中最重要的概念，在Java中的体现：对象的多态性：父类的引用指向子类的对象

格式：（父类类型：指子类继承的父类类型，或者实现的接口类型）

父类类型变量名 = 子类对象；

举例：

Person p = new Student();

Object o = new Person();//Object类型的变量o，指向Person类型的对象

o = new Student(); //Object类型的变量o，指向Student类型的对象

对象的多态：在Java中，子类的对象可以替代父类的对象使用。所以，一个引用类型变量可能指向(引用)多种不同类型的对

多态的理解

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法） “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）

多态的使用前提：① 类的继承关系 ② 方法的重写

举例

package com.atguigu.polymorphism.grammar;

public class Pet {
private String nickname; //昵称

public String getNickname() {
return nickname;
}

public void setNickname(String nickname) {
this.nickname = nickname;
}

public void eat(){
System.out.println(nickname + "吃东西");
}
}

package com.atguigu.polymorphism.grammar;

public class Cat extends Pet {
//子类重写父类的方法
@Override
public void eat() {
System.out.println("猫咪" + getNickname() + "吃鱼仔");
}

//子类扩展的方法
public void catchMouse() {
System.out.println("抓老鼠");
}
}

package com.atguigu.polymorphism.grammar;

public class Dog extends Pet {
//子类重写父类的方法
@Override
public void eat() {
System.out.println("狗子" + getNickname() + "啃骨头");
}

//子类扩展的方法
public void watchHouse() {
System.out.println("看家");
}
}

1、方法内局部变量的赋值体现多态

package com.atguigu.polymorphism.grammar;

public class TestPet {
public static void main(String[] args) {
//多态引用
Pet pet = new Dog();
pet.setNickname("小白");

//多态的表现形式
/*
编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
*/
pet.eat();//运行时执行子类Dog重写的方法
// pet.watchHouse();//不能调用Dog子类扩展的方法

pet = new Cat();
pet.setNickname("雪球");
pet.eat();//运行时执行子类Cat重写的方法
}
}

2、方法的形参声明体现多态

package com.atguigu.polymorphism.grammar;

public class Person{
private Pet pet;
public void adopt(Pet pet) {//形参是父类类型，实参是子类对象
this.pet = pet;
}
public void feed(){
pet.eat();//pet实际引用的对象类型不同，执行的eat方法也不同
}
}

package com.atguigu.polymorphism.grammar;

public class TestPerson {
public static void main(String[] args) {
Person person = new Person();

Dog dog = new Dog();
dog.setNickname("小白");
person.adopt(dog);//实参是dog子类对象，形参是父类Pet类型
person.feed();

Cat cat = new Cat();
cat.setNickname("雪球");
person.adopt(cat);//实参是cat子类对象，形参是父类Pet类型
person.feed();
}
}

3、方法返回值类型体现多态

package com.atguigu.polymorphism.grammar;

public class PetShop {
//返回值类型是父类类型，实际返回的是子类对象
public Pet sale(String type){
switch (type){
case "Dog":
return new Dog();
case "Cat":
return new Cat();
}
return null;
}
}

package com.atguigu.polymorphism.grammar;

public class TestPetShop {
public static void main(String[] args) {
PetShop shop = new PetShop();

Pet dog = shop.sale("Dog");
dog.setNickname("小白");
dog.eat();

Pet cat = shop.sale("Cat");
cat.setNickname("雪球");
cat.eat();
}
}

为什么需要多态性(polymorphism)？

开发中，有时我们在设计一个数组、或一个成员变量、或一个方法的形参、返回值类型时，无法确定它具体的类型，只能确定它是某个系列的类型。

案例：

（1）声明一个Dog类，包含public void eat()方法，输出“狗啃骨头”

（2）声明一个Cat类，包含public void eat()方法，输出“猫吃鱼仔”

（3）声明一个Person类，功能如下：

包含宠物属性
包含领养宠物方法 public void adopt(宠物类型Pet)
包含喂宠物吃东西的方法 public void feed()，实现为调用宠物对象.eat()方法

public class Dog {
public void eat(){
System.out.println("狗啃骨头");
}
}

public class Cat {
public void eat(){
System.out.println("猫吃鱼仔");
}
}

public class Person {
private Dog dog;

//adopt：领养
public void adopt(Dog dog){
this.dog = dog;
}

//feed：喂食
public void feed(){
if(dog != null){
dog.eat();
}
}
/*
问题：
1、从养狗切换到养猫怎么办？
修改代码把Dog修改为养猫？
2、或者有的人养狗，有的人养猫怎么办？
3、要是还有更多其他宠物类型怎么办？
如果Java不支持多态，那么上面的问题将会非常麻烦，代码维护起来很难，扩展性很差。
*/
}

多态的好处和弊端

好处：变量引用的子类对象不同，执行的方法就不同，实现动态绑定。代码编写更灵活、功能更强大，可维护性和扩展性更好了。

弊端：一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。

Student m = new Student();
m.school = "pku";   //合法,Student类有school成员变量
Person e = new Student(); 
e.school = "pku";   //非法,Person类没有school成员变量

// 属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

开发中：

使用父类做方法的形参，是多态使用最多的场合。即使增加了新的子类，方法也无需改变，提高了扩展性，符合开闭原则。

【开闭原则OCP】