1. 多态
1.1 多态概念
同一对象在不同时刻的不同形态
多态需要有3个前提/体现
- 有继承/实现关系
- 有方法重写
- 有父类指向子类对象
public class Animal {
public void eat(){
System.out.println("动物吃东西...");
}
}
public class Cat extends Animal{ // 子类继承
@Override // 方法重写
public void eat() {
System.out.println("猫吃鱼...");
}
}
public class AnimalDemo {
public static void main(String[] args) {
//父类引用指向子类对象
Animal cat = new cat();
}
}
1.2 多态中成员访问的特点
public class Animal {
public int age =40; //age为40
public void eat(){
System.out.println("动物吃东西...");
}
}
public class Cat extends Animal {
public int age=20; //age为20
public int weight=10;
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
public void playGame(){
System.out.println("猫玩游戏...");
}
}
public class AnimalDemo {
public static void main(String[] args) {
//父类引用指向子类对象
Animal cat = new Cat();
System.out.println(cat.age); // Animal里的age是40,Cat继承Animal里面的age是20;输出是40,是Animal里的值
cat.eat(); //调用的是Cat类的eat方法
//System.out.println(cat.playgame()}; // 不能调用Cat类里的新增方法playGame
}
}
输出结果:
40
猫吃鱼...
Process finished with exit code 0
为什么age是40?
//父类引用指向子类对象
Animal cat = new Cat();
因为:
在多态中,子类Cat继承父类Animal
成员变量age在Cat和Animal中都有
在子类Cat中重写了eat方法,新增了playGame方法
多态访问中,
成员变量:编译看左边的Animal类,执行也看左边的Animal类
成员变量:编译看左边的Animal类,执行看右边的Cat类。
为什么成员变量和成员方法访问不一样?
因为成员变量没有重写,而成员方法有重写。
1.3 多态的好处与短处
public class Animal {
public void eat(){
System.out.println("动物吃东西...");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
}
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头...");
}
}
public class AnimalOperator {
public void useAnimal(Cat cat){
cat.eat();
}
public void useAnimal(Dog dog){
dog.eat();
}
}
public class AnimalDemo {
public static void main(String[] args) {
AnimalOperator ao = new AnimalOperator();
Cat c = new Cat();
ao.useAnimal(c);
Dog d = new Dog();
ao.useAnimal(d);
}
}
上述代码中,Cat、Dog继承Animal类,重写了eat方法。
有一个操作类AnimalOperator,添加对应Cat、Dog的操作方法
如果,再添加一个类Pig继承Animal类,那么操作类AnimalOperator就要添加对应Pig的操作方法。
如果一直添加类x,继承Animal类,操作类AnimalOperator每次就要添加x对应操作方法。
这就很麻烦。使用多态既可以解决这个问题。
public class Animal {
public void eat(){
System.out.println("动物吃东西...");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
}
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头...");
}
}
public class Pig extends Animal{
@Override
public void eat() {
System.out.println("猪吃剩饭...");
}
}
public class AnimalOperator {
// public void useAnimal(Cat cat){
// cat.eat();
// }
// public void useAnimal(Dog dog){
// dog.eat();
// }
public void useAnimal(Animal a){ // 父类作为引用类型,传入具体子类
a.eat();
}
}
public class AnimalDemo {
public static void main(String[] args) {
AnimalOperator ao = new AnimalOperator();
Cat c = new Cat();
//ao.useAnimal(c);
Dog d = new Dog();
//ao.useAnimal(d);
Pig p = new Pig();
ao.useAnimal(c);
ao.useAnimal(d);
ao.useAnimal(p);
}
}
输出:
猫吃鱼...
狗吃骨头...
猪吃剩饭...
使用多态后,操作类AnimalOperator 可以传任何继承Animal类的子类,不需要添加对应的操作类。
总结:
-
多态的好处:
提高了程序的拓展性,在方法定义中,使用父类型作为参数,具体子类参与操作
-
多态的短处:
不能使用子类新增的方法。(只能是重写父类的方法)