接口练习题

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量817 收藏 5
点赞数
分类专栏： 练习题 接口 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67796933/article/details/124657896
版权

目录

案例：猫和狗

案例：运动员和教练

案例：猫和狗

需求：对猫狗进行训练，它们就可以调高了，这里加入调高功能。请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。

思路：

  • 定义接口（Jumpping）：

成员方法：跳高（）；

  • 定义抽象动物类（Animal）：

成员变量：姓名，年龄；

构造方法：无参，带参；

成员方法：get/set方法，吃饭（）；

  • 定义具体的猫类（Cat）：

构造方法：无参，带参；

重写方法：跳高（）；吃饭（）；

  • 定义具体的狗类（Dog）：

构造方法：无参，带参；

重写方法：跳高（）；吃饭（）；

  • 定义测试类（AnimalDemo），写代码测试。

代码演示：

public abstract class Animal {
    private String name;
    private int age;
    //无参
    public Animal() {
    }
    //带参
    public Animal(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 abstract void eat();
}
interface Jumpping {
    //抽象类方法
    void jump();
}
class Cat extends Animal implements Jumpping {
    //给出无参带参/构造方法
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    //重写jump方法
    @Override
    public void jump() {
        System.out.println("猫猫经过训练学会了跳高");
    }
    //重写eat方法
    @Override
    public void eat() {
        System.out.println("爱吃鱼");
    }
}
class Dog extends Animal implements Jumpping{
    //有参无参
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    //重写get/set方法
    @Override
    public void jump() {
        System.out.println("狗狗经过训练学会了跳高");
    }

    @Override
    public void eat() {
        System.out.println("爱吃骨头");
    }
}
/*
    测试类
 */
class AnimalDemo {
    public static void main(String[] args) {
        //无参，父类引用子类对象
        Animal a = new Cat();
        a.setName("加菲猫");
        a.setAge(5);
        System.out.print(a.getName()+","+a.getAge()+"岁");
        a.eat();
        //接口指向子类
//        可以写作：
//        Jumpping j = new Cat();
//        j.jump();或者：
        Jumpping j = (Cat) a;
        ((Cat) a).jump();

        //带参，父类引用子类对象
        a = new Cat("布偶猫",3);
        System.out.print(a.getName()+","+a.getAge()+"岁");
        a.eat();
        j.jump();

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

        /*发现一个问题，接口只能调接口里面的方法
        抽象类只能调抽象类有的方法，而我们以后用的时候
        他不是按照父类引用子类对象、接口指向子类这两种方式来使用的。
        因为Cat类里面继承自Animal并且实现了Jumpping接口
        Cat里面的内容是最多的，所以一般来说我们直接写具体类对象：
         */
        //无参
        Cat c = new Cat();
        c.setName("橘猫");
        c.setAge(1);
        System.out.print(c.getName()+","+c.getAge()+"岁");
        c.eat();
        c.jump();
        //带参
        Cat c1 = new Cat("小花猫",2);
        System.out.print(c1.getName()+","+c1.getAge()+"岁");
        c1.eat();
        c1.jump();
        System.out.println("------------");


        //无参，父类引用子类对象
        Animal d = new Dog();
        d.setName("小黑");
        d.setAge(4);
        System.out.print(d.getName()+","+d.getAge()+"岁");
        d.eat();
        //接口指向子类
        Jumpping j1 = (Dog) d;
        j1.jump();

        //带参，父类引用子类对象
        d = new Dog("小黄",2);
        System.out.print(d.getName()+","+d.getAge()+"岁");
        d.eat();
        //接口指向子类
        j1.jump();
        System.out.println("------------");
        //此处与上面同理
        //无参
        Dog D = new Dog();
        D.setName("旺财");
        D.setAge(1);
        System.out.print(D.getName()+","+D.getAge()+"岁");
        D.eat();
        D.jump();

        //带参
        Dog D1 = new Dog("招财",3);
        System.out.print(D1.getName()+","+D1.getAge()+"岁");
        D1.eat();
        D1.jump();
    }
}

案例：运动员和教练

需求：我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，那些接口，并用代码实现。

分析：

具体事物：乒乓球运动员，篮球运动员；乒乓球教练，篮球教练，所以它们都是具体的类。

找出具体事物的共性：篮球运动员和乒乓球运动员都要学习它们的技能，它们都是运动员，所以可以提取出一个抽象的运动员类再提取出一个学习方法是抽象的；因为篮球运动员和乒乓球运动员它们学习的内容不一样，所以它们以后继承这个运动员类就可以了

同理，两个教练也可以提取出一个抽象的教练类，它们要教学员东西，所以可以提取出一个教的抽象方法，因为乒乓球教练和篮球教练教的内容是不同的。

然后不管教练还是运动员 它们都是人，人都具有一个共性的内容：姓名、年龄这样的成员变量，还有一个吃饭的抽象方法，（在这假设教练和运动员吃的东西是不一样的）。

然后它们因为要出国交流就需要学习英语，而学英语是一个抽象的行为：因为可能学会可能学不会，也有可能某些人不用学，有些人要学。

分析之后实现应该是从抽象到具体。（也就是做的时候应该先定义接口定义抽象人类、运动员类、教练类再写具体的子类或者叫实现类）

使用：使用的是具体的类的对象（因为具体类里面包含的内容才是最多的）

思路：

  • 定义说英语的接口：

成员方法：说英语（）；

  • 定义抽象人类：

成员变量：姓名，年龄；

构造方法：无参，带参；

成员方法：get/set方法，吃饭（）；

  • 抽象教练类，继承人类：

构造方法：无参，带参；

成员方法：教（）；

  • 抽象运动员类，继承人类：

构造方法：无参，带参；

成员方法：学习（）；

  • 定义具体的篮球教练类，继承教练类：

构造方法：无参，带参；

成员方法：重写教（）{…}，重写吃饭（）{…}。

  • 定义具体的乒乓球教练，继承教练类实现说英语接口：

构造方法：无参，带参；

成员方法：重写教（）{…}，重写吃饭（）{…}，重写说英语（）{…}。

  • 定义具体的篮球运动员类，继承运动员类：

构造方法：无参，带参；

成员方法：重写学习（）{…}，重写吃饭（）{…}。

  • 定义具体的乒乓球运动员类，继承运动员类：

构造方法：无参，带参；

成员方法重写吃饭（）{…}，重写学习（）{…}，重写说英语（）{…}。

  • 最后要有一个测试类写代码进行测试

代码演示：

 

/*
    1.定义英语接口
 */
public interface English {
    //说英语的抽象方法
    void sayEnglish();
}
/*
    2.定义抽象人类
        人要有名字、年龄
        人要吃饭
 */
abstract class People {
    //3.成员变量名字、年龄
    private String name;
    private int age;

    //4.无参带参
    public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //5.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;
    }
    //6.eat吃饭方法
    public abstract void eat();
}
/*
    7.定义抽象教练
        继承人类
 */
abstract class Coach extends People{
    //8.无参带参构造方法
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }
    //9.特有的教人方法
    public abstract void tech();
}
/*
    10.定义抽象运动员类
        继承人类
 */
abstract class Athletes extends People {
    //11.无参带参构造方法
    public Athletes() {
    }

    public Athletes(String name, int age) {
        super(name, age);
    }
    //12.特有的学习方法
    public abstract void study();
}
/*
    13.定义具体的篮球教练类
        继承教练类，教练继承人所以要重写两个方法
 */
class Basketball_Coach extends Coach{
    //14.无参带参构造方法

    public Basketball_Coach() {
    }

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

    //15.重写写吃饭和教的方法
    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝牛奶");
    }

    @Override
    public void tech() {
        System.out.println("篮球教练教运球和投篮");
    }
}
/*
    16.定义具体的乒乓球教练
        继承教练类
        乒乓球教练会说会说英语
 */
class Table_Tennis_Coach extends Coach implements English{
    //17.无参带参构造方法
    public Table_Tennis_Coach() {
    }

    public Table_Tennis_Coach(String name, int age) {
        super(name, age);
    }
    //18.重写eat和tech方法和English方法
    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小龙虾，喝矿泉水");
    }

    @Override
    public void tech() {
        System.out.println("乒乓球教练教如何发球和接球");
    }

    @Override
    public void sayEnglish() {
        System.out.println("乒乓球教练说英语");
    }
}

/*
    19.定义具体的篮球运动员类
        继承运动员类
 */
class Basketball_Player extends Athletes{
    //20.无参带参构造方法
    public Basketball_Player() {
    }

    public Basketball_Player(String name, int age) {
        super(name, age);
    }
    //21.重写eat和study方法
    @Override
    public void eat() {
        System.out.println("篮球运动员吃回锅肉,喝牛奶");
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
}
/*
    22.定义具体的乒乓球运动员类
        继承运动员类
        乒乓球运动员会说英语
 */
class Table_Tennis_Player extends Athletes implements English{
    //23.无参带参构造方法

    public Table_Tennis_Player() {
    }

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

    //24.重写eat、study、sayEnglish方法

    @Override
    public void eat() {
        System.out.println("乒乓球运动吃鸡胸肉,喝小米粥");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学如何发球和接球");
    }

    @Override
    public void sayEnglish() {
        System.out.println("乒乓球运动员说英语");
    }
}
/*
    测试类
 */
class Demo {
    public static void main(String[] args) {
        System.out.println("---------乒乓球教练-------");
        //25.无参形式
        //26.创建乒乓球教练对象
        Table_Tennis_Coach ttt = new Table_Tennis_Coach();
        ttt.setName("孔令辉");
        ttt.setAge(47);
        System.out.print(ttt.getName()+","+ttt.getAge()+"岁");
        ttt.eat();
        ttt.tech();
        ttt.sayEnglish();

        System.out.println("---------乒乓球运动员-------");
        //27.创建乒乓球运动员对象
        Table_Tennis_Player ppp = new Table_Tennis_Player();
        ppp.setName("张继科");
        ppp.setAge(34);
        System.out.print(ppp.getName()+","+ppp.getAge()+"岁");
        ppp.eat();
        ppp.study();
        ppp.sayEnglish();

        System.out.println("---------篮球教练-------");
        //28.创建篮球教练对象
        Basketball_Coach bb = new Basketball_Coach();
        bb.setName("杜锋");
        bb.setAge(41);
        System.out.print(bb.getName()+","+bb.getAge()+"岁");
        bb.eat();
        bb.tech();

        System.out.println("---------篮球运动员-------");
        //29.创建篮球运动员对象
        Basketball_Player pp = new Basketball_Player();
        pp.setName("郭艾伦");
        pp.setAge(36);
        System.out.print(pp.getName()+","+pp.getAge()+"岁");
        pp.eat();
        pp.study();

        System.out.println("---------乒乓球教练-------");
        //30.带参形式
        //31.创建具体乒乓球教练类对象
        Table_Tennis_Coach ttc = new Table_Tennis_Coach("刘国梁",43);
        System.out.print(ttc.getName()+","+ttc.getAge()+"岁");
        ttc.eat();ttc.tech();ttc.sayEnglish();

        System.out.println("---------乒乓球运动员-------");
        //32.创建具体乒乓球运动员对象
        Table_Tennis_Player ttp = new Table_Tennis_Player("张怡宁",28);
        System.out.print(ttp.getName()+","+ttp.getAge()+"岁");
        ttp.eat();ttp.study();ttp.sayEnglish();

        System.out.println("---------篮球教练-------");
        //33.创建具体篮球教练对象
        Basketball_Coach bc = new Basketball_Coach("姚明",48);
        System.out.print(bc.getName()+","+bc.getAge()+"岁");
        bc.eat();bc.tech();

        System.out.println("---------篮球运动员-------");
        //34.创建具体篮球运动员
        Basketball_Player bp = new Basketball_Player("周琦",31);
        System.out.print(bp.getName()+","+bp.getAge()+"岁");
        bp.eat();bp.study();


    }
}

贰陆.256
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
接口练习01
weixin_44627303的博客
08-09 643
接口 面向接口编程01 练习时候遇到一个根据继承接口不同而选择性调用方法的问题，记录一下 需求： （1） 定义一个接口Assaultable（可攻击的），该接口有一个抽象方法attack()。 （2） 定义一个接口Mobile（可移动的），该接口有一个抽象方法move()。 （3） 定义一个抽象类Weapon，实现Assaultable接口，但并没有给出方法的具体实现。 （4） 定义三个类：Tank、Flighter、MissileTurret，它们都继承自Weapon，分别给出attack()方法的不同实
设计模式
SkadiEyes的博客
04-30 240
工厂模式工厂模式抽象了创建具体对象的过程。工厂模式解决了创建多个相似对象的问题，但是没有解决的对象识别的问题。function people(name, age, job) { var o = new Object(); o.name = name; o.age = age; o.job = job; o.sayName = function () { ...
JAVA 接口抽象类编程题
d774413的博客
10-09 1828
题目：创建昆虫类：首先创建一个飞行的接口Flyable，接口中有一个表示飞行的抽象方法fly(),然后，创建一个抽象的昆虫类Inset，类中有一个int型，表示昆虫有多少条腿的变量legs，有一个有参构造方法，还有一个表示繁殖的抽象方法reprodece()，接着，创建一个苍蝇类，使得之继承昆虫Inset，并实现接口Flyable,最后，测试类Test,并在控制台上输出。
java练习题之接口interface练习
zhzjn的博客
12-26 1369
方法的功能为：求参数的阶乘“long intPower(int m , int n)”方法的功能为：求m 的n 次方“boolean findFactor(int m,int n)”方法的功能为：判断参数的和是否大于 100定义类实现接口，编写应用程序，调用接口中的 3 个方法，并将调用方法的结果输出。MediaPlayer有三个实现类，分别是：DVDPlayer，表示DVD播放器；CDPlayer，表示CD播放器；TapePlayer,表示收音机（播放磁带）。
100道接口测试面试题值得收藏！
m0_70669463的博客
12-01 941
设计接口测试用例时，涉及的是电商系统，其中包括很多修改，如商品.商家、店铺等等，针对这些数据的修改，会涉及到很多参数。如商品的名称，商品的尺码，商品的顔色等等。那在设计实现"修改"接口时，如何确定要传什么参数？是只需要传我要修改的参数，还是全部参数都要传？
JAVA接口练习题
热门推荐
ximmown的博客
04-07 1万+
1.说出下面程序的执行结果: interface InterfaceA {  （public abstract）String S = "good ";  void f(); } abstract class ClassA {  abstract void g(); } class ClassB extends ClassA implements InterfaceA { //B是A的子类和接口A的...
接口练习题.docx
12-14
接口练习题.docx
实施工程师接口作业练习题.pdf
08-30
实施工程师接口作业练习题 本文档提供了一个实施工程师接口作业练习题的解决方案，该练习题旨在帮助初级写接口人员和实施工程师熟悉REST接口的使用和解析。该练习题通过调用天气预报接口，获取城市的天气信息，并...
java 接口练习作业
01-21
在这个"java接口练习作业"中，我们将会探讨接口的使用，以及如何将其应用于集合框架中。 首先，让我们深入了解Java接口的基本概念。接口是完全抽象的类，不能包含实例变量，但可以声明常量。它由一系列无实现的方法...
计算机组成与设计 硬件软件接口习题答案
07-08
《计算机组成与设计：硬件软件接口》是一本深入探讨计算机体系结构的重要教材，由David A. Patterson和John L. Hennessy合著，王党辉等进行了中文翻译。该书详细阐述了计算机内部如何处理数据、执行指令以及硬件与...
面向接口编程小例子练习程序
12-14
面向接口编程小例子练习程序，接口程序练习，使用接口可以优化代码，使程序变得更加简单。
单片机接口与技术 练习题
06-30
【单片机接口与技术】练习题主要涵盖了以下几个方面的知识点： 1. **单片机最小系统**：在图1中，构建一个基于89C51的单片机最小系统，需要以下元件： - （1）晶振电路：89C51需要外部晶振来提供工作时钟，通常...
Java-接口练习
Victor.Chang
04-03 1万+
/**2.编程题: 利用接口做参数，写个计算器，能完成加减乘除运算。 （1）定义一个接口Compute含有一个方法int computer(int n, int m)。 （2）设计四个类分别实现此接口，完成加减乘除运算。 （3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)， 此方法能够用传...
接口的练习
LiLi的博客
11-24 390
需求： 写一个类Army，代表一支军队，这个类有一个属性Weapon数组w（用来存储该军队所拥有的所有武器），该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量。并用这一大小来初数化数组w。 该类还提供一个方法addWeapon（Weapon wa），表示把参数wa所代表的武器加入到数组w中。 在这个类中还定义两个方法attackAll()让数组中的所有武器攻击， 以及moveAll()让w数组中的所有可能移动的武器移动。 【提示】 Weapon是一个父类，应该有
接口练习
xiaoblank的博客
08-10 279
//爬行动物 interface Iwalkable{ void walk(); } //水生动物 interface Iswimable{ void swim(); } //两栖动物 interface Iamable extends Iwalkable,Iswimable{ } class Animal { String name; String color...
免费可练习接口测试的开放接口
竹人的博客
07-26 1万+
接口地址见以下链接地址 http://www.webxml.com.cn/zh_cn/web_services.aspx
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1206
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
java 接口 练习题_Java接口练习题
06-02
好的，我可以为您提供一些 Java 接口练习题，供您练习和巩固相关知识。以下是一些题目： 1. 定义一个接口 Animal，包含方法 eat() 和 sleep()，同时定义一个实现该接口的类 Dog 和 Cat。要求 Dog 和 Cat 实现 eat() 和 sleep() 方法，其中 eat() 方法输出 "I am a dog/cat, and I am eating"，sleep() 方法输出 "I am a dog/cat, and I am sleeping"。 2. 定义一个接口 Shape，包含方法 getArea() 和 getPerimeter()，同时定义一个实现该接口的类 Rectangle 和 Circle。要求 Rectangle 和 Circle 实现 getArea() 和 getPerimeter() 方法，其中 getArea() 方法返回形状的面积，getPerimeter() 方法返回形状的周长。 3. 定义一个接口 Calculator，包含方法 add()、subtract()、multiply() 和 divide()，同时定义一个实现该接口的类 BasicCalculator 和 ScientificCalculator。要求 BasicCalculator 和 ScientificCalculator 实现 add()、subtract()、multiply() 和 divide() 方法，其中 BasicCalculator 实现的方法为简单的四则运算，ScientificCalculator 实现的方法为科学计算器常用的函数，例如 sin、cos、tan 等。 4. 定义一个接口 Sortable，包含方法 sort()，同时定义一个实现该接口的类 BubbleSort 和 QuickSort。要求 BubbleSort 和 QuickSort 实现 sort() 方法，其中 BubbleSort 实现冒泡排序，QuickSort 实现快速排序。 希望这些题目能够帮助您巩固 Java 接口的相关知识。如果您有任何问题或需要更多帮助，请随时告诉我。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贰陆.256

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值