Java学习之多态

2021-06-08

同一对象，在不同时刻表现出来的不同形态

1.多态介绍

同一对象，在不同时刻表现出来的不同形态

2.代码演示

/*
	举例：
		我们可以说猫是猫：猫 cat = new 猫();
		我们也可以说猫是动物：动物 cat = new 猫();
		这里猫在不同的时刻表现出来了不同的形态，这就是多态
	多态的前提和体现
		有继承/实现关系
		有方法重写
		有父类引用指向子类对象
*/
package Java_Polymorphism;

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 c = new Cat();
    }
}

3.多态中成员变量及方法的访问特点

3.1代码演示

package Java_Polymorphism2;

public class Animal {
    public int age = 20;
    public void eat(){
        System.out.println("小动物");
    }
}

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

    public void show(){
        System.out.println("这是Cat类中的show()方法");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        Animal c = new Cat();
        //System.out.println(c.weight);//报错
        System.out.println(c.age);
        c.eat();
        //c.show();//报错
    }
}
//输出结果
/*
	20
	猫吃鱼
*/

3.2总结

多态中成员的访问特点

成员变量：编译看左边(父类)，执行看左边
成员方法：编译看左边(父类)，执行看右边(子类/继承类)

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

因为成员方法有重写，而成员变量没有

4.多态的利与弊

4.1代码演示

package Java_Polymorphism3;
//动物类

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

//动物操作类
public class AnimalOperating {
    public void useAnimal(Animal a){
        a.eat();
    }
}

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

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

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

//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperating ao = new AnimalOperating();
        Cat c = new Cat();
        ao.useAnimal(c);
        Dog d = new Dog();
        ao.useAnimal(d);
        Pig p = new Pig();
        ao.useAnimal(p);
    }
}
//输出结果
/*
	猫吃鱼
    狗啃骨头
    猪吃白菜
*/

4.2总结

多态的好处和弊端

多态的好处：提高了程序的扩展性

具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时侯，使用具体的子类型参与操作
多态的弊端：不能使用子类的特有功能

5.多态的转型

5.1转型介绍

有时候我们要通过父类创建的对象去访问子类中独有的一个方法那么就需要用到转型了，而转型又分为两种

向上转型

从子到父

父类引用指向子类对象
向下转型

从父到子

父类引用转为子类对象

5.2代码演示

package Java_Polymorphism4;

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

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

    public void playGame(){
        System.out.println("狗狗玩游戏");
    }
}

public class Demo_1 {
    public static void main(String[] args) {
        //向上转型
        Animal d = new Dog();
        d.eat();
        //d.playGame(); //直接访问报错
        //向下转型
        Dog d_2 = (Dog)d;
        d_2.eat();
        d_2.playGame();
    }
}
//输出结果
/*
	狗狗吃骨头
	狗狗吃骨头
	狗狗玩游戏

*/

6.多态小案例之猫和狗

6.1代码演示

package Java_Polymorphism5;

public class Animal {
    private String name;
    private int age;

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

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗狗爱吃骨头");
    }
}

public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    public void playGame(String name) {
        System.out.println(name + "喜欢玩");
    }

    @Override
    public void eat() {
        System.out.println("猫猫爱吃鱼");
    }
}

//案例：利用多态完成猫和狗的操作
/*
    1.定义动物类
        成员变量：姓名、年龄
        构造方法：无参、带参
        成员方法：get方法、set方法、eat()
    2.定义狗类
        构造方法：无参、带参
        成员方法：重写父类的eat()方法
    3.定义猫类
        构造方法：无参、带参
        成员方法：重写父类的eat()方法
 */

public class Demo_1 {
    public static void main(String[] args) {
        //无参构造
        Animal c = new Cat();
        c.setName("Tom");
        c.setAge(5);
        System.out.println(c.getName() + "今年" + c.getAge() + "岁了");
        c.eat();
        //带参构造
        Animal c_2 = new Cat("Tom_2",6);
        System.out.println(c_2.getName() + "今年" + c_2.getAge() + "岁了");
        c_2.eat();
        //向下转型
        Cat c_3 = (Cat)c_2;
        c_3.playGame(c_2.getName());
    }
}
//输出结果
/*
	Tom今年5岁了
	猫猫爱吃鱼
	Tom_2今年6岁了
	猫猫爱吃鱼
	Tom_2喜欢玩
*/