一. 多态的概述
多态是某一个事物，在不同时刻表现出来的不同状态。
举例:
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物
动物 d = new 猫();
水在不同时刻的状态
多态的前提和体现:
- 有继承关系
- 有方法重写
- 有父类引用指向子类对象
二.多态中成员的访问特点
成员变量访问特点
编译看左边，运行看左边
成员方法访问特点
编译看左边，运行看右边
代码:
duotai1
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物类 多态中成员访问特点
*
* 为什么成员变量和成员方法的访问不一样呢?
* 因为成员方法有重写，而变量没有。
*
*/
public class duotai1 {
public int age = 40;
public void eat() {
System.out.println("吃东西");
}
}
duotai2
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物类子类-猫 多态中成员访问特点
*
*/
public class duotai2 extends duotai1 {
public int age = 20;
public int weight = 10;
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame() {
System.out.println("猫捉迷藏");
}
}
duotai3
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物类测试类 多态中成员访问特点
*
*/
public class duotai3 {
public static void main(String[] args) {
//由父类引用指向子类对象
duotai1 a = new duotai2();
System.out.println(a.age);
//System.out.println(a.weight);//不能访问
a.eat();
//a.playGame();//不能访问
}
}
三. 多态的好处和弊端
多态的好处：
提高了程序的扩展性
多态的弊端：
不能访问子类特有功能
那么如何访问子类的特有功能呢？
通过多态中的转型
多态转型代码:
duotai_animal
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物类 多态的好处和弊端
*/
public class duotai_animal {
public int age = 40;
public void eat() {
System.out.println("吃东西");
}
}
duotai_cat
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物子类-猫类 多态的好处和弊端
*/
public class duotai_cat extends duotai_animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
duotai_dog
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物子类-狗类 多态的好处和弊端
*/
public class duotai_dog extends duotai_animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void lookDoor() {
System.out.println("狗看门");
}
}
duotai_pig
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物子类-猪类 多态的好处和弊端
*/
public class duotai_pig extends duotai_animal {
@Override
public void eat() {
System.out.println("猪吃白菜");
}
}
duotai_operator
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物类的操作类 多态的好处和弊端
*/
public class duotai_operator {
public void userAnimal(duotai_cat cat) {
cat.eat();
}
public void userAnimal(duotai_dog dog) {
dog.eat();
dog.lookDoor();
}
public void userAnimal(duotai_pig pig) {
pig.eat();
}
}
duotai_test1
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物类的测试类 多态的好处和弊端
*/
public class duotai_test1 {
public static void main(String[] args) {
//由父类引用指向子类对象
duotai_operator ao = new duotai_operator();
duotai_cat c = new duotai_cat();
duotai_dog d = new duotai_dog();
duotai_pig p = new duotai_pig();
ao.userAnimal(c);
ao.userAnimal(d);
ao.userAnimal(p);
}
}
测试记录:
猫吃鱼
狗吃骨头
狗看门
猪吃白菜
四. 多态中的转型问题
向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象
代码:
duotai_animal
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物类 多态中的转型问题
*/
public class duotai_animal {
public int age = 40;
public void eat() {
System.out.println("吃东西");
}
}
Java_study
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物子类-猫类 多态中的转型问题
*/
public class duotai_cat extends duotai_animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame() {
System.out.println("猫捉迷藏");
}
}
duotai_test2
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-25
* @remark 动物子类-猫类 多态中的转型问题
*/
public class duotai_test2 {
public static void main(String[] args) {
duotai_animal a = new duotai_animal();
a.eat();
//a.playGame();
/*
不能访问
多态的弊端：无法访问子类特有方法
现在我就想使用子类特有方法，怎么办呢？
创建子类对象就可以了
*/
duotai_cat c1 = new duotai_cat();
c1.eat();
c1.playGame();
/*
现在代码虽然可以访问子类的特有功能，但是不合理
因为我们发现内存中有两个猫类的对象
这个时候，我们得想办法把多态中的猫对象还原
这个时候就需要使用多态中的转型了
父类引用转为子类对象
*/
duotai_animal a2 = new duotai_cat();
duotai_cat c2 = (duotai_cat)a2;
c2.eat();
c2.playGame();
}
}
测试记录:
吃东西
猫吃鱼
猫捉迷藏
猫吃鱼
猫捉迷藏
网友评论