多态

1.多态

1.1 多态概述

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

举例：猫

我们可以说猫是猫：猫 cat=new 猫();

我们也可以说猫是动物：动物 animal=new 猫();

这里猫在不同的时刻表现出来了不同的形态，这就是多态

多态的前提和体现：

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

package com.szy008;

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

package com.szy008;

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

package com.szy008;

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a=new Cat();//多态
        a.eat();
    }
}

1.2多态中成员变量访问特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边

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

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

package com.szy009;

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

package com.szy009;

public class Cat extends Animal{
    public int age=20;
    public int weight=10;

    @Override
    public void eat() {
        super.eat();
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

package com.szy009;

public class AnimalDemos {
    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 com.szy010;
/*
动物类
 */
public class Animal2 {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package com.szy010;
/*
猫类
 */
public class Cat2 extends Animal2{
    @Override
    public void eat() {
        super.eat();
        System.out.println("猫吃鱼");
    }
}

package com.szy010;
/*
狗类
 */
public class Dog2 extends Animal2{
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }
}

package com.szy010;
/* 猪类

 */
public class Pig2 extends Animal2{
    @Override
    public void eat() {
        System.out.println("猪啃白菜");
    }
}

package com.szy010;
/*
动物操作类
 */
public class AnimalOperator {
    /*
    public void useAnimal(Cat2 c){
        c.eat();
    }
    public void useAnimal(Dog2 d){
        d.eat();
    }
    public void useAnimal(Pig2 p){
        p.eat();
    }

     */
    public void useAnimal(Animal2 a){
        a.eat();
      //  a.lookDoor();//报错，多态不能访问具体的子类所特有的功能

    }

}

package com.szy010;
/*测试类

 */
public class AnimalDemo2 {
    public static void main(String[] args) {
        //创建动物操作类的对象，调用方法
        AnimalOperator ao=new AnimalOperator();
        Cat2 c=new Cat2();
        ao.useAnimal(c);
        Dog2 d=new Dog2();
        ao.useAnimal(d);
        Pig2 p=new Pig2();
        ao.useAnimal(p);
    }
}

1.4多态中的转型

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

package com.szy011;

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

package com.szy011;

public class Cat3 extends Animal3{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("捉迷藏");
    }
}

package com.szy011;

public class AnimalDemo3 {
    public static void main(String[] args) {
        //多态
        Animal3 a=new Cat3();//向上转型
        a.eat();
      //  a.playGame();报错

        /*
        //创建Cat3类的对象
        Cat3 c=new Cat3();
        c.eat();
        c.playGame();

         */

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

    }
}

运行结果为：

1.5多态转型内存问题

package com.szy012;

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

package com.szy012;

public class Cat4 extends Animal4{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void play(){
        System.out.println("小猫钓鱼");
    }
}

package com.szy012;

public class Dog4 extends Animal4{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void study(){
        System.out.println("小狗学习");
    }
}

package com.szy012;

public class AnimalDemo4 {
    public static void main(String[] args) {
        //向上转型
        Animal4 a=new Cat4();//内存中,a是一只猫
        a.eat();

        //向下转型
        Cat4 c=(Cat4)a;//猫强制转成猫没有问题
        c.eat();
        c.play();

        //向上转型
        a=new Dog4();//内存中a是一只狗
        a.eat();

        //向下转型
        //ClassCastException类型转换异常
        Cat4 cc=(Cat4)a;//内存中a是一只狗，强制给它转成猫报错
        cc.eat();
        cc.play();
    }
}

案例：猫和狗（多态版）

需求：请采用多态的思想实现猫和狗的案例，并在测试类中进行测试。

package com.szy013;

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

    public Animal5() {//无参构造方法
    }

    public Animal5(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 void eat(){
        System.out.println("动物吃饭");
    }
}

package com.szy013;

public class Cat5 extends Animal5{
    public Cat5() {
    }

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

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

package com.szy013;

public class Dog5 extends Animal5{
    public Dog5() {
    }

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

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

package com.szy013;

public class AnimalDemo5 {
    public static void main(String[] args) {
        //创建猫类对象并测试
        Animal5 a=new Cat5();
        a.setName("加菲");
        a.setAge(4);
        System.out.println(a.getName()+a.getAge());
        a.eat();

        a=new Cat5("小花",2);
        System.out.println(a.getName()+a.getAge());
        a.eat();

        Animal5 b=new Dog5();
        b.setName("小哈");
        b.setAge(5);
        System.out.println(b.getName()+b.getAge());
        b.eat();

        b=new Dog5("二哈",8);
        System.out.println(b.getName()+b.getAge());
        b.eat();
    }
}

posted @ 2022-03-30 17:43 行雨阅读(61) 评论(0) 收藏举报

刷新页面返回顶部

宋子怡

多态