JAVA接口案例（猫和狗、运动员和教练）

1. 案例：猫和狗
   需求：对猫和狗进行训练，他们就可以跳高了，这里加入了跳高功能，请采用抽象类和接口来实现猫和狗的案例，并在测试类中进行测试。
   分析：
   （1）定义接口（Jumpping）
   成员方法：跳高();
   （2）定义动物类（Animal）
   成员变量：姓名、年龄；
   构造方法：无参、带参
   成员方法：get/set方法，吃饭()；
   （3）定义猫类（Cat），继承动物类
   构造方法：无参、带参
   成员方法：重写吃饭(……)，重写跳高（……）
   （4）定义狗类（Dog），继承动物类
   构造方法：无参、带参
   成员方法：重写吃饭(……)，重写跳高（……）
   （5）定义测试类（AnimalDemo），写代码测试
   完整代码：

package intertext;

public interface Jumpping {
    public abstract void Jumpping();
}

package intertext;

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

    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 abstract void eat();
}

package intertext;

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

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

    @Override
    public void Jumpping() {
        System.out.println("猫可以跳高了");
    }

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

package intertext;

public class Demo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.Jumpping();

        Animal a = new Cat();
        a.setName("mimi");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        Animal a1 = new Cat("titi",6);
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();

        Cat c = new Cat();
        c.setName("xixi");
        c.setAge(7);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.Jumpping();
    }
}

运行结果：

猫可以跳高了
mimi,5
猫吃鱼
titi,6
猫吃鱼
xixi,7
猫吃鱼
猫可以跳高了

2. 案例：运动员和教练
   需求：现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练，为了出国交流，跟乒乓球相关的人员都需要学习英语，请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。
   分析：
   【从具体到抽象】
   
   实现：
   【从抽象到具体】
   使用：
   【使用的是具体的类的对象】
   （1）定义说英语接口：
   成员方法：说英语();
   （2）定义抽象人类：
   成员变量：姓名，年龄；
   构造方法：无参，带参；
   成员方法：get/set方法，吃饭()；
   （3）定义抽象教练类，继承人类：
   构造方法：无参，带参；
   成员方法：教();
   （4）定义抽象运动员类，继承人类：
   构造方法：无参，带参；
   成员方法：学习();
   （5）定义具体篮球教练类，继承教练类：
   构造方法：无参，带参；
   成员方法：重写吃饭()(……),重写教()(……)
   （6）定义具体乒乓球教练类，继承教练类：
   构造方法：无参，带参；
   成员方法：重写吃饭()(……),重写教()(……)，重写说英语()(……)
   （7）定义具体篮球运动员类，继承运动员类：
   构造方法：无参，带参；
   成员方法：重写吃饭()(……),重写学习()(……)
   （8）定义具体乒乓球运动员类，继承运动员类：
   构造方法：无参，带参；
   成员方法：重写吃饭()(……),重写学习()(……)，重写说英语()(……)
   （9）定义测试类，写代码测试。
   完整代码：

package qiu;

public interface speakE {
    void SpeakEnglish();
}

package qiu;

public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 abstract void eat();
}

package qiu;

public abstract class teacher extends Person {
    public teacher() {
    }

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

    public abstract void teach();

}

package qiu;

public abstract class student extends Person{
    public student() {
    }

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

    public abstract void study();
}

package qiu;

public class bsTeacher extends teacher {
    public bsTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("篮球教练教学");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃饭");
    }
}

package qiu;

public class ppTeacher extends teacher implements speakE {
    public ppTeacher() {
    }

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

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃饭");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教学");
    }

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

package qiu;

public class bsStudent extends student {
    public bsStudent() {
    }

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

    @Override
    public void eat() {
        System.out.println("篮球运动员吃饭");
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学习");
    }
}

package qiu;

public class ppStudent extends student implements speakE {
    public ppStudent() {
    }

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

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃饭");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习");
    }

    @Override
    public void SpeakEnglish() {
        System.out.println("乒乓球运动员说英语");
    }


}

package qiu;

public class Demo {
    public static void main(String[] args) {
        ppStudent ps = new ppStudent();
        ps.setName("Tom");
        ps.setAge(18);
        System.out.println(ps.getName()+","+ps.getAge());
        ps.eat();
        ps.study();
        ps.SpeakEnglish();


        ppStudent ps1 = new ppStudent("Bob",19);
        System.out.println(ps1.getName()+","+ps1.getAge());
        ps1.eat();
        ps1.study();
        ps1.SpeakEnglish();
    }
}

运行结果：

Tom,18
乒乓球运动员吃饭
乒乓球运动员学习
乒乓球运动员说英语
Bob,19
乒乓球运动员吃饭
乒乓球运动员学习
乒乓球运动员说英语