15-JavaSE基础巩固练习：多态、接口、抽象类的综合练习

最新推荐文章于 2023-06-21 11:27:44 发布
最新推荐文章于 2023-06-21 11:27:44 发布
阅读量521 收藏 3
点赞数 1
分类专栏： JavaSE基础巩固练习 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yelitoudu/article/details/127974735
版权

多态的综合练习

1、需求

  • 狗类

    • 属性：年龄，颜色
    • 行为：
      • eat(String something)：表示吃东西
      • lookHome()：看家

  • 猫类

    • 属性：年龄，颜色
    • 行为：
      • eat(String something)：吃东西
      • catchMouse()：逮老鼠

  • 饲养员

    • 属性：姓名，年龄
    • 行为：
      • keepPet(Dog dog, String something)：喂养宠物狗，something表示喂养的东西
      • keepPet(Cat cat, String something)：喂养宠物猫，something表示喂养的东西
      • 需要无参与有参构造器，set和get方法

  • 测试类

    • 完成以下打印效果：

      • 年龄为30岁的老王养了一只黑颜色的2岁的狗。

        2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃。

      • 年龄为25岁的老李养了一只灰颜色的3岁的猫。

        3岁的灰颜色的猫眯着眼睛侧着头吃鱼。

  • 思考

    • 1、Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
    • 2、Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？

2、分析

  • 我们可以发现这个需求中：
    • 猫、狗都属于动物，属性也一样，也有相同的行为；
    • 因此我们需要让猫和狗类继承动物类，抽离相同的属性、行为定义在动物类中；
    • 猫和狗类只需要定义它们自己特有的方法即可。
    • 饲养员类要单独定义。
  • 提问？
    • 为啥人不继承动物类呢？人也是动物啊？
    • 这个问题没毛病，但是不符合我们的这个需求！
    • 我们的需求是人饲养宠物猫、宠物狗，而不是人饲养人。

3、实现

package com.app.demo24_polymorphic.been;

/**
 * 动物类
 */
public class Animal {
    /*
        定义动物相同的属性：
            年龄，颜色
     */
    private int age;
    private String color;

    /*
        提供无参数的构造器
        提供有全部参数的构造器
     */
    public Animal() {}
    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    /*
        提供全套的get和set方法
        方便暴露属性的取值和赋值
     */
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }


    /*
        定义动物相同的行为：
            吃东西
     */
    public void eat(String something) {
        System.out.println("动物在吃" + something);
    }
}

package com.app.demo24_polymorphic.been;

/**
 * 狗类：继承父类动物类
 */
public class Dog extends Animal{
    /*
        由于狗类继承了父类动物类，
        因此只需要在狗类中定义狗特有的行为就好了
        定义狗特有的行为：看门
     */
    public void lookHome() {
        System.out.println("狗正趴在门口~");
    }

    /*
        提供无参数的构造器
        提供有参数的构造器
     */
    public Dog() {}
    public Dog(int age, String color) {
        super(age, color);
    }

    /*
            由于父类动物类中的吃东西的行为是面向所有动物的，
            又因为需求中有对狗吃东西的描述：2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃。
            因此需要重写父类的eat方法。
         */
    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住" + something + "猛吃。");
    }
}

package com.app.demo24_polymorphic.been;

/**
 * 猫类：继承动物类
 */
public class Cat extends Animal{
    /*
        由于猫类继承了父类动物类，
        因此只需要在猫类中定义猫特有的行为就好了
        定义猫特有的行为：逮老鼠
     */
    public void catchMouse() {
        System.out.println("猫正在奋力的逮老鼠~~");
    }

    /*
        提供无参数的构造器
        提供有参数的构造器
     */
    public Cat() {}
    public Cat(int age, String color) {
        super(age, color);
    }

    /*
        由于父类动物类中的吃东西的行为是面向所有动物的，
        又因为需求中有对猫吃东西的描述：3岁的灰颜色的猫眯着眼睛侧着头吃鱼
        因此需要重写父类的eat方法。
     */
    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的猫眯着眼睛侧着头吃" + something + "。");
    }
}

package com.app.demo24_polymorphic.been;

/**
 * 饲养员类
 */
public class Person {
    /*
        定义饲养员的属性：
            姓名、年龄
     */
    private String name;
    private int age;

    /*
        提供无参数的构造器
        提供有全部参数的构造器
     */
    public Person() {
    }

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

    /*
        提供全套的get和set方法
        方便暴露其属性的取值和赋值
     */
    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 keepPet(Dog dog, String something) {
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
        // 狗吃饲养员喂养的食物
        dog.eat(something);
    }*/

    /*
        未使用多态前：
        定义饲养员喂养宠物猫的行为
        参数一：猫对象；参数二：喂养的食物
     */
    public void keepPet(Cat cat, String something) {
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的猫");
        // 猫吃饲养员喂养的食物
        cat.eat(something);
    }


    /*
        使用多态来定义饲养员喂养宠物狗、猫的行为
        参数一：动物对象；参数二：喂养的食物
     */
    public void keepPet(Animal a, String something) {
        // 无法直接调用子类中的特有行为
        // a.lookHome();
        // a.catchMouse();

        // 判断该动物对象类型是否为狗对象类型
        /*if (a instanceof Dog) {
            // 是，则将动物对象类型强转为狗对象类型
            Dog d = (Dog) a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + d.getColor() + "颜色的" + d.getAge() + "岁的狗");
            // 狗吃饲养员喂养的食物
            d.eat(something);
            // 可以调用子类中的特有行为
            // d.lookHome();
        } else if (a instanceof Cat) { // 否，则判断该动物对象类型是否为猫对象类型
            // 是，则将动物对象类型强转为猫对象类型
            Cat c = (Cat) a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + c.getColor() + "颜色的" + c.getAge() + "岁的猫");
            // 猫吃饲养员喂养的食物
            c.eat(something);
            // 可以调用子类中的特有行为
            // c.catchMouse();
        } else { // 否，则说明没有这种动物
            System.out.println("没有这种动物喔！");
        }*/


        /*
            优化写法
         */
        // 判断该动物对象类型是否为狗对象类型
        if (a instanceof Dog d) { // 是，则将动物对象类型强转为狗对象类型
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + d.getColor() + "颜色的" + d.getAge() + "岁的狗");
            // 狗吃饲养员喂养的食物
            d.eat(something);
        } else if (a instanceof Cat c) { // 否，则判断该动物对象类型是否为猫对象类型：是，则将动物对象类型强转为猫对象类型
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + c.getColor() + "颜色的" + c.getAge() + "岁的猫");
            // 猫吃饲养员喂养的食物
            c.eat(something);
        } else { // 否，则说明没有这种动物
            System.out.println("没有这种动物喔！");
        }
    }
}

package com.app.demo24_polymorphic.test;

import com.app.demo24_polymorphic.been.Animal;
import com.app.demo24_polymorphic.been.Cat;
import com.app.demo24_polymorphic.been.Dog;
import com.app.demo24_polymorphic.been.Person;

/**
 * 测试类
 * 完成以下打印效果：
 * 年龄为30岁的老王养了一只黑颜色的2岁的狗。
 * 2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃。
 * 年龄为25岁的老李养了一只灰颜色的3岁的猫。
 * 3岁的灰颜色的猫眯着眼睛侧着头吃鱼。
 */
public class Test {
    public static void main(String[] args) {
        /*// 创建饲养员1
        Person p1 = new Person("老王", 30);
        // 未使用多态前：创建宠物狗
        Dog dog = new Dog(2, "黑");
        // 饲养员1调用喂养宠物狗的行为方法，完成喂养
        p1.keepPet(dog, "骨头");

        // 创建饲养员2
        Person p2 = new Person("老李", 25);
        // 未使用多态前：创建宠物猫
        Cat cat = new Cat(3, "灰");
        // 饲养员2调用喂养宠物猫的行为方法，完成喂养
        p2.keepPet(cat, "鱼");*/

        Person p1 = new Person("老王", 30);
        // 使用多态：创建宠物狗
        Animal dog = new Dog(2, "黑");
        p1.keepPet(dog, "骨头");

        Person p2 = new Person("老李", 25);
        // 使用多态：创建宠物猫
        Animal cat = new Cat(3, "灰");
        p2.keepPet(cat, "鱼");
    }
}

年龄为30岁的老王养了一只黑颜色的2岁的狗
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃。
年龄为25岁的老李养了一只灰颜色的3岁的猫
3岁的灰颜色的猫眯着眼睛侧着头吃鱼。

Process finished with exit code 0

接口和抽象类的综合案例

1、需求

  • 编写带有接口和抽象类的标准Javabean类：
    • 我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。
    • 为了出国交流，跟乒乓球相关的人员都需要学习英语。
    • 请用所有知识分析，在这个案例中，哪些是具体类，哪些是抽象类，哪些是接口？
  • 乒乓球运动员：姓名、年龄、学打乒乓球，说英语。
  • 篮球运动员：姓名、年龄、学打篮球。
  • 乒乓球教练：姓名、年龄、教打乒乓球，说英语。
  • 篮球教练：姓名、年龄、教打篮球。

2、分析

  • 可以从以上需求看出：

    • 他们都有共同的属性，因此可以定义一个人的类，来定义这些共同的属性，让他们继承
    • 乒乓球运动员和乒乓球教练都有说英语的共同行为，因此需要定义一个说英语的接口，让他们实现
    • 运动员都有一个共同的行为，那就是学习打球，但是由于球类不同，因此这个学习方法是抽象的，必须让运动员自己实现。
    • 教练都有一个共同的行为，那就是教学生打球，但是由于球类不同，因此这个教学方法是抽象的，必须让教练自己实现。
    • 最后要注意一个细节：
      • 由于人类是运动员和教练的顶级父类，因此必须是抽象的。
      • 因为此时不能让外界直接创建顶层父类人的对象，此时是没有意义的。

  • 分析结构图：

    在这里插入图片描述

3、实现

  • 人类（顶层父类）

    package com.app.demo25_interface_abstract.been;

/**
 * 人类：顶层父类
 * 注意：
 * 1、人类是顶层父类，主要作用就是定义所有子类的共同属性、行为，这样子类就不需要重复定义。
 * 2、因此构造对象的时候，也是构造子类的对象，如果直接构造顶层父类：人类的对象，此时是没有意义的。
 * 3、所以，顶层父类是定义为抽象类的：目的就是为了不让外界直接创建顶层父类的对象。
 */
public abstract class Person {
    /*
        定义子类的共同属性：
            姓名、年龄
     */
    private String name;
    private int age;

    /*
        提供无参数的构造器
        提供带全部参数的构造器
     */
    public Person() {}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /*
        提供全套的get和set方法，
        方便合理暴露其属性的取值和赋值
     */
    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; }
}

  • 运动员类（人类的子类，所有运动员的父类）

    package com.app.demo25_interface_abstract.been;

/**
 * 运动员类
 * 必须定义为抽象类：
 * 1、因为运动员的学习行为方法是定义为抽象方法
 * 2、因为每个运动员要学习的内容不一样，因此需要定义为抽象方法，让子类必须重写运动员类(父类)的学习方法
 */
public abstract class Sportsman extends Person{
    /*
        提供无参数的构造器
        提供带全部参数的构造器
     */
    public Sportsman() {}
    public Sportsman(String name, int age) {
        // super(): 将构造运动员对象的属性传递给父类(顶层父类：人类)
        super(name, age);
    }

    /*
        定义运动员的共同行为：学习
        必须定义为抽象方法，让每个运动员自己实现。
        因为每个运动员要学习的内容都不一样。
     */
    public abstract void study(String name);
}

  • 教练类（人类的子类，所有教练的父类）

    package com.app.demo25_interface_abstract.been;

/**
 * 教练类
 * 必须定义为抽象类：
 * 1、因为教练的教学行为方法是定义为抽象方法
 * 2、因为每个教练要教学的内容不一样，因此需要定义为抽象方法，让子类必须重写教练类(父类)的教学方法
 */
public abstract class Coach extends Person{
    /*
        提供无参数的构造器
        提供带全部参数的构造器
     */
    public Coach() {}
    public Coach(String name, int age) {
        // super(): 将构造教练对象的属性传递给父类(顶层父类：人类)
        super(name, age);
    }

    /*
        定义教练的共同行为：教学
        必须定义为抽象方法，让每个教练自己实现。
        因为每个教练要教学的内容都不一样。
     */
    public abstract void teach(String name);
}

  • 英语接口（乒乓球相关的需要实现说英语方法）

    package com.app.demo25_interface_abstract.been;

/**
 * 定义英语接口：乒乓球运动员、教练都要说英语
 */
public interface English {
    /*
        定义说英语的抽象方法：
        1、接口中的方法，默认是公开、抽象的
        2、因此实现接口时，必须重写该方法
        3、所以修饰符：public、abstract也可以省略不写！
     */
    void speakEnglish(String name);
}

  • 乒乓球运动员类（运动员的子类，英语接口的实现类）

    package com.app.demo25_interface_abstract.been;

/**
 * 乒乓球运动员类
 * 1、需要继承运动员类：Sportsman
 * 2、需要实现英语接口：English
 * 3、因此必须重写运动类、英语接口的方法
 */
public class PingPongSportsman extends Sportsman implements English{
    /*
        提供无参数的构造器
        提供带全部参数的构造器
     */
    public PingPongSportsman() {}
    public PingPongSportsman(String name, int age) {
        // super(): 将构造乒乓球运动员对象的属性传递给运动员类(父类)
        super(name, age);
    }

    // 1、重写父类的学习方法
    @Override
    public void study(String name) {
        System.out.println("乒乓球运动员" + name + "正在学习如何打乒乓球~~");
    }

    // 2、重写英语接口的说英语方法
    @Override
    public void speakEnglish(String name) {
        System.out.println("乒乓球运动员" + name + "正在说着一口流利的英语 ~^_^~");
    }
}

  • 乒乓球教练（教练的子类，英语接口的实现类）

    package com.app.demo25_interface_abstract.been;

/**
 * 乒乓球教练类
 * 1、需要继承教练类：Coach
 * 2、需要实现英语接口：English
 * 3、因此必须重写教练类、英语接口的方法
 */
public class PingPongCoach extends Coach implements English{
    /*
        提供无参数的构造器
        提供带全部参数的构造器
     */
    public PingPongCoach() {}
    public PingPongCoach(String name, int age) {
        // super(): 将构造器乒乓球教练对象的属性传递给教练类(父类)
        super(name, age);
    }

    // 1、重写父类的教学方法
    @Override
    public void teach(String name) {
        System.out.println("乒乓球教练" + name + "正在向学员们传授最正宗的乒乓球打法~~");
    }

    // 2、重写英语接口的说英语方法
    @Override
    public void speakEnglish(String name) {
        System.out.println("乒乓球教练" + name + "正在飙着一口流利的英语 @^_^@");
    }
}

  • 篮球运动员类（运动员的子类）

    package com.app.demo25_interface_abstract.been;

/**
 * 篮球运动员类
 * 1、需要继承运动员类：Sportsman
 * 2、因此必须重写运动类的方法
 */
public class BasketballSportsman extends Sportsman{
    /*
        提供无参数的构造器
        提供带全部参数的构造器
     */
    public BasketballSportsman() {}
    public BasketballSportsman(String name, int age) {
        // super(): 将构造器篮球运动员对象的属性传递给运动员类(父类)
        super(name, age);
    }

    // 1、重写父类的学习方法
    @Override
    public void study(String name) {
        System.out.println("篮球运动员" + name + "正在学习如何打篮球~~");
    }
}

  • 篮球教练类（教练的子类）

    package com.app.demo25_interface_abstract.been;

/**
 * 篮球教练类
 * 1、需要继承教练类：Coach
 * 2、因此必须重写教练类的方法
 */
public class BasketballCoach extends Coach{
    /*
        提供无参数的构造器
        提供带全部参数的构造器
     */
    public BasketballCoach() {}
    public BasketballCoach(String name, int age) {
        // super(): 将构造篮球教练对象的属性传递给教练类(父类)
        super(name, age);
    }

    // 1、重写父类的教学方法
    @Override
    public void teach(String name) {
        System.out.println("篮球教练" + name + "正在向学员们传授最正宗的篮球技术~~");
    }
}

  • 测试类：

    package com.app.demo25_interface_abstract.test;

import com.app.demo25_interface_abstract.been.*;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 创建乒乓球教练对象
        PingPongCoach ppc = new PingPongCoach("张飞", 66);
        // 乒乓球教练开始教学
        ppc.teach(ppc.getName());
        // 乒乓球教练开始飙英语
        ppc.speakEnglish(ppc.getName());

        System.out.println();

        // 创建乒乓球运动员对象
        PingPongSportsman pps = new PingPongSportsman("甄姬", 23);
        // 乒乓球运动员开始学习
        pps.study(pps.getName());
        // 乒乓球运动员开始说英语
        pps.speakEnglish(pps.getName());


        System.out.println("------------------------");

        // 创建篮球教练对象
        BasketballCoach bbc = new BasketballCoach("赵云", 65);
        // 篮球教练开始教学
        bbc.teach(bbc.getName());

        System.out.println();

        // 创建篮球运动员对象
        BasketballSportsman bbs = new BasketballSportsman("蔡徐坤", 25);
        // 篮球运动员开始学习
        bbs.study(bbs.getName());
    }
}

4、运行结果

乒乓球教练张飞正在向学员们传授最正宗的乒乓球打法~~
乒乓球教练张飞正在飙着一口流利的英语 @^_^@

乒乓球运动员甄姬正在学习如何打乒乓球~~
乒乓球运动员甄姬正在说着一口流利的英语 ~^_^~
------------------------
篮球教练赵云正在向学员们传授最正宗的篮球技术~~

篮球运动员蔡徐坤正在学习如何打篮球~~

Process finished with exit code 0
学不会is dog
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 一二三四五_五道java小题,补更四道java小题
weixin_39820910的博客
02-16 453
一:分析以下需求，并用代码实现1.定义List集合，存入多个字符串2.删除集合中字符串"def"3.然后利用迭代器遍历集合元素并输出import java.util.ArrayList;import java.util.List;public class Topic1{public static void main(String[] args) {ArrayList arrayList = new...
Java多态&接口&抽象类&内部类练习
m0_59525910的博客
02-22 458
jdk1.8接口中允许定义`含有方法体的非抽象方法`，但是需要关键字`default`修饰 题目中method没有default修饰。Animal本质的类型为Dog，不能将Dog转换成Cat，Dog和Cat之间不存在子父类的继承关系。答：InerImol不是一个抽象类，需要重写FU类Animal里的方法，题中没有重写所以报错。8.请分析如下程序在控制台的输出结果是什么并说明原因？2.请分析如下程序是否会报错并说明原因？7.请分析如下程序在控制台的输出结果是什么并说明原因？因为:接口和接口之间是继承。
Java 继承，多态，接口练习
wangjh11234的博客
03-21 2613
Java 继承，多态，接口练习
JAVA多态与接口练习题
有朋自远方来，不亦乐乎。
11-26 1393
主观题： 有一个接口Operation，如下所示： interface Operation{ void open( ); void show( ); void close( );} （1）编写窗帘类Curtain和灯类Light来实现接口Operation。 （2）编写一个ElectricCurtain类继承自Curtain，该类增加一个方法ref，该方法调用open方法。 （3）编写一个公共类Test，其中包含main方法，static ...
【java】继承与多态 接口练习
m0_74951130的博客
06-21 378
第一行n表示对象个数，对象类型用Rectangle、Circle区分，Rectangle表示长方形对象，后面输入长，宽，输入Circle表示圆对象，后面是输入半径。定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求面积、周长的方法。分别输出所有容器对象的面积之和、周长之和，结果保留小数点后2位。在这里给出相应的输出。面积之和：472290.12。在这里给出一组输入。周长之和：56771.13。
抽象类_接口_多态_继承整合案例.docx
08-04
抽象类_接口_多态_继承整合案例.。
day01-继承&修饰符&多态&抽象类.pdf
08-23
1.继承 2.修饰符 3.多态 4.抽象类 小车穿沿在蜿蜒曲折的盘山公路上
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
最新发布
03-03
- **接口与抽象类的区别**：接口用于约定，抽象类用于共享实现。 - **多态的应用**：通过接口或继承实现多态，理解其在设计模式中的应用。 8. **异常处理** - **异常分类**：检查型异常与运行时异常的区别。 - ...
JavaSE:java学习练习
06-16
深入学习时，要关注对象导向编程（OOP）的概念，包括封装、继承、多态和抽象。这些概念是Java编程的核心，也是其他面向对象语言的基础。 集合框架是JavaSE中的重要部分，包括ArrayList、LinkedList、HashMap、...
JavaSE之多态体系
07-21
例如，如果有一个`Animal`抽象类和多个具体的动物类(`Dog`, `Cat`)，我们可以创建一个`Animal`类型的列表，然后添加各种动物对象，统一调用`Animal`类中定义的方法。 总的来说，JavaSE中的多态是面向对象编程的重要...
java多态和接口的练习题
等,一起的博客
02-18 545
假设动物园某管理员（Master类）每天需要给他所负责饲养的狮子(Lion)，猴子(Monkey)，鸟(Bird)喂食，用一个程序模拟喂食过程。 饲养员喂动物时，不同的动物执行吃的功能。三种不同动物吃的东西不同。狮子吃肉，猴子吃香蕉，鸟吃米。
练习-Java继承和多态之接口(19)
weixin_46075438的博客
02-13 5046
任务描述 本关任务： 编写一个学校接待方面的程序，招待不同身份的人的食宿问题。 /** * 编写一个学校接待方面的程序，招待不同身份的人的食宿问题 */ // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码 /********** Begin **********/ // 定义一个接口类 Person interface Person{ // 定义 eat()，实现输出吃饭的功能，无返回值 public abstract void eat(); //
9-java学习-多态、抽象类、接口-案例代码
weixin_42401546的博客
02-14 197
9-java学习-多态、抽象类、接口-案例代码 一、多态 1.多态：一种事物，在不同时刻所表现出的不同状态。 ​ 多态的前提要有继承。没有继承，那么动态就无从谈起 ​ 多态要有方法重写，如果没有方法重写，多态也就没有意义 ​ 父类引用指向子类对象 public class MyTest { public stat...
JAVA练习题35：多态综合训练
m0_46457497的博客
11-08 1567
此题目为多态的综合训练根据需求完成代码:定义狗类属性：年龄，颜色行为:eat(String something)(something表示吃的东西)看家lookHome方法(无参数)定义猫类属性：年龄，颜色行为:eat(String something)方法(something表示吃的东西)逮老鼠catchMouse方法(无参数)定义Person类//饲养员属性：姓名，年龄行为：keepPet(Dog dog,String something)方法。
多态的综合练习（Java）
时刻总结
12-22 435
​
Java · 图书管理系统代码练习 · 抽象类 · 封装 · 继承 · 多态 · 接口
sfg0861的博客
09-24 856
图书管理小系统，主要利用 JavaSE 所学到的知识点：类、抽象类、封装、继承、多态、接口等进行一个简单的代码练习。
Java_笔记_多态_包_final_权限修饰符_代码块
SisinRyu的博客
12-08 804
Java_笔记_多态_包_final_权限修饰符_代码块
Java抽象类练习
zhkey123的博客
11-29 1217
题目要求 编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个 Employee对象的生日，则将该雇员的工资增加100元。 定义一个Employee类，该类包含： private成员变量name,number,birthday，其中birthday 为MyDate类的对象； abstract方法earnings()； toString()方法输出对象的name,number和birthday。 Employee.java public abstract class Employee {
java关于主人喂猫和狗的程序_Java小程序之 人(person)喂养猫（cat）和狗（dog）统称为动物（Animal),要求：运用抽象类、继承 提示：Animal为抽象类，Cat、Dog为......
weixin_42696333的博客
02-16 2334
抽象类、继承的练习请细细品味！点赞，关注！支持一下，给点动力！1.定义动物类属性：年龄，颜色生成空参有参构造，set和get方法行为：eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)2.定义狗类继承动物类，行为：eat(String something)方法,看家lookHome方法(无参数)3.定义猫类继承动物类，行为：e...
JavaSE接口与抽象类解析及多态理解
本文主要介绍了Java编程中关于接口、抽象类以及多态的相关知识点，通过四个训练案例详细解析了接口的特点、接口与抽象类的区别以及多态的理解和应用。 1. 接口特点与成员特性： - 接口中的方法默认使用`public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值