JavaSE 多态

JavaSE 多态

  • 1. 多态
    • 1.1 多态概述
    • 1.2 多态中成员访问特点
    • 1.3 多态的好处和弊端
    • 1.4 多态中的转型

1. 多态

1.1 多态概述

同一个对象,在不同时刻表现出来的不同形态
举例:猫
我们可以说猫是猫:猫 cat = new 猫();
我们也可以说猫是动物:动物 animal = new 猫();
这里猫在不同的时刻表现出了不同的形态,这就是多态

多态的前提和体现:

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

1.2 多态中成员访问特点

  • 成员变量:编译看左边,执行看左边
  • 成员方法:编译看左边,执行看右边

为什么成员方法和成员变量的访问不一样呢?

  • 因为成员方法有重写,而成员变量没有
package Polymorphism01;

public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package Polymorphism01;

public class Cat extends Animal{
    public int age = 20;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

package Polymorphism01;
/*
    多态:
        同一个对象,在不同时刻表现出来的不同形态
    举例:猫
        我们可以说猫是猫:猫 cat = new 猫();
        我们也可以说猫是动物:动物 animal = new 猫();
        这里猫在不同的时刻表现出了不同的形态,这就是多态
    多态的前提和体现:
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class AnimalDemo {
    public static void main(String[] args){
        //有父类引用指向子类对象
        Animal a = new Cat();   //多态

        //成员变量:编译看左边,执行看左边
        System.out.println(a.age);  //结果输出40
//        System.out.println(a.weight);   //报错

        //成员方法:编译看左边,执行看右边
        a.eat();    //结果输出猫吃鱼
//        a.playGame();   //报错
    }
}

1.3 多态的好处和弊端

  • 好处:提高了程序的扩展性
    具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作

  • 弊端:不能使用子类的特有功能

package Polymorphism02;

public class Animal {

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

package Polymorphism02;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package Polymorphism02;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

package Polymorphism02;

public class Pig extends Animal{
    @Override
    public void eat() {
        System.out.println("猪吃白菜");
    }
}

package Polymorphism02;

public class AnimalOperator {
    /*
    public void useAnimal(Cat c){   //Cat c = new Cat();
        c.eat();
    }
    public void useAnimal(Dog d){   //Dog d = new Dog();
        d.eat();
    }
    */

    public void useAnimal(Animal a){
        //Animal a = new Cat();
        //Animal a = new Dog();

        a.eat();
    }
}

package Polymorphism02;

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(p);
    }
}

1.4 多态中的转型

  • 向上转型
    从子到父
    父类引用指向子类对象
  • 向下转型
    从父到子
    父类引用转为子类对象

向下转型解决了多态不能使用子类特有功能的弊端

package Polymorphism03;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}
package Polymorphism03;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}
package Polymorphism03;
/*
    向上转型
        从子到父
        父类引用指向子类对象
    向下转型
        从父到子
        父类引用转为子类对象
 */
public class AnimalDemo {
    public static void main(String[] args){
        //多态
        Animal a = new Cat();   //向上转型
        a.eat();
//        a.playGame();   //报错

        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

你可能感兴趣的:(JavaSE,java,javase)