解析java多态经典习题

解析java多态经典习题

1 题目一

1.1 题目内容

编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从
而发出不同的声音。
可以弹奏的乐器包括二胡、钢琴和琵琶。
实现思路及关键代码：
①定义乐器类Instrument，包括方法makeSound()
②定义乐器类的子类：二胡Erhu、钢琴Piano和
小提琴Violin
③定义乐手类Musician，可以弹奏各种乐器
play(Instrument i)
④定义测试类,给乐手不同的乐器让他弹奏

1.2 示例代码

Instrument类

package Work03;
public class Instrument {
    public void makeSound(){
        System.out.println("乐器在奏乐");
    }
}

Erhu类

package Work03;

public class Erhu extends Instrument{
    @Override
    public void makeSound() {
        System.out.println("二胡,弹奏的曲目是二泉映月");
    }
}

Piano类

package Work03;

public class Piano extends Instrument{
    @Override
    public void makeSound() {
        System.out.println("钢琴,弹奏的曲目是致爱丽丝");
    }
}

Violin类

package Work03;

public class Violin extends Instrument{
    @Override
    public void makeSound() {
        System.out.println("小提琴,弹奏的曲目是沉思");
    }
}

Muscian类

package Work03;

public class Musician {
    private String  name;

    public Musician() {
    }

    public Musician(String name) {
        this.name = name;
    }
    public void play(Instrument i){
           System.out.print(name+"弹奏的乐器是");
           i.makeSound();
    }
}

Test类

package Work03;
public class Test {
    public static void main(String[] args) {
        Musician m=new Musician("张三");
        m.play(new Piano());
        m.play(new Erhu());
        m.play(new Violin());
    }
}

1.3 示例代码运行截图

2 题目二

2.1 题目内容

编写程序实现主人喂养宠物和跟宠物玩耍的场景
定义宠物类Pet，宠物都需要吃东西,跟主人玩。
定义狗类Dog、猫类Cat、Dolphin海豚类继承Pet宠物类。
狗狗吃骨头、猫咪吃老鼠、海豚吃乌贼。

主人和宠物的玩耍是每个宠物都独有一份

主人跟狗狗完抓飞盘，主人跟猫咪玩抓老鼠、主人跟海豚玩转圈圈。

2.2 示例代码

Pet类

package Work03;
//上课练习
public class Pet {
    private String name;

    public Pet() {
    }

    public Pet(String name) {
        this.name = name;
    }

    //吃的方法
    public void eat(){

    }

    public String getName() {
        return name;
    }

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

Dog类

package Work03;

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

    public Dog(String name) {
        super(name);
    }

    public void catchDisc() {
        System.out.println("玩抓飞盘");
    }

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

Cat类

package Work03;

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

    public Cat(String name) {
        super(name);
    }

    public void catchMouse() {
        System.out.println("玩抓老鼠");
    }

    @Override
    public void eat() {
        System.out.println("猫咪吃老鼠");
    }
}

Dolphin类

package Work03;

public class Dolphin extends Pet{
    public Dolphin() {
    }

    public Dolphin(String name) {
        super(name);
    }

    public void runningCircle() {
        System.out.println("玩转圈圈");
    }

    @Override
    public void eat() {
        System.out.println("海豚吃乌贼");
    }
}

Master类

package Work03;

public class Master {
    private  String name;

    public Master() {
    }

    public Master(String name) {
        this.name = name;
    }

    public void feed(Pet pet){
       //得出喂食的宠物是什么名字,是狗还是猫还是海豚
        if(pet instanceof Dog){
            System.out.println(name+"喂食的宠物是一只叫"+ ((Dog)pet).getName()+"的狗狗");
        }else if(pet instanceof Cat){
            System.out.println(name+"喂食的宠物是一只叫"+ ((Cat)pet).getName()+"的猫咪");
        }else if(pet instanceof Dolphin){
            System.out.println(name+"喂食的宠物是一只叫"+ ((Dolphin)pet).getName()+"的海豚");
        }
        //吃的方法都是被重写的,无需进行类型的判断
        pet.eat();
    }
    public void play(Pet pet){
        //每个宠物的玩耍方法都是其独有的方法,因此需要向下转型,向下转型前需要对类型进行判断
        if(pet instanceof Dog){
            System.out.print(name+"是和一只叫"+ ((Dog)pet).getName()+"的狗狗");
            ((Dog)pet).catchDisc();
        }else if(pet instanceof Cat){
            System.out.print(name+"是和一只叫"+ ((Cat)pet).getName()+"的猫咪");
            ((Cat)pet).catchMouse();
        }else if(pet instanceof Dolphin){
            System.out.print(name+"是和一只叫"+ ((Dolphin)pet).getName()+"的海豚");
            ((Dolphin)pet).runningCircle();
        }
    }
}

Test类

package Work03;
public class Test {
    public static void main(String[] args) {
       Master master=new Master("张三");
       Dog dog=new Dog("德福");
       Cat cat=new Cat("叮当");
       Dolphin dolphin=new Dolphin("祥云");
       master.feed(dog);
       master.feed(cat);
       master.feed(dolphin);
       master.play(dog);
       master.play(cat);
       master.play(dolphin);
    }
}

2.3 示例代码运行截图

3 思路总结

3.1 使用多态后调用重写的方法时,无需进行对象类型的判断

理由:因为它会自动去找对应类型里面的重写了的方法去运行

3.2 使用多态后,想要调用子类特有的方法,必须实现向下转型,且向下转型前必须判断对象是哪个类型的

向下转型的理由: 使用多态后只能调用父类型特征里面从父类继承过来的属性、非重写方法、以及子类重写的方法,要使用子类特有的方法就必须是子类对象才可以调用,因此需要向下转型

向下转型前必须判断对象的类型:因为只有强转的类型和实例化对象的类型保持一致,两者才可以强转,不然会出现ClassCastException类型转化异常,例如Animal a=new Dog();你只能对Animal强转成Dog类型,你强转成Cat就会报错(运行报错,编译可以通过)