类、抽象类、接口的综合小练习---运动员和教练案例

运动员和教练案例图解

文字分析和示例代码如下：

/*
    运动员和教练案例：
        乒乓球运动员和篮球运动员。
        乒乓球教练和篮球教练。
        为了出国交流，跟乒乓球相关的人员都需要学习英语。
        请用所学知识：
        分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
    
    整个分析过程，通过画图的讲解，如图所示：    
-----------------------------------------------------------------------------    
    文字的讲解如下：
    分析：从具体到抽象
---------------------------------------        
        乒乓球运动员
            姓名，年龄
            吃饭，学习，睡觉
        篮球运动员
            姓名，年龄
            吃饭，学习，睡觉
        由于有共性功能，所以提取一个抽象运动员类：
        抽象运动员类
            姓名，年龄
            吃饭();
            学习();
            睡觉() {}
---------------------------------------    
        乒乓球教练
            姓名，年龄
            吃饭，教学，睡觉
        篮球教练
            姓名，年龄
            吃饭，教学，睡觉
        由于有共性功能，所以提取一个抽象教练类：
        抽象教练类
            姓名，年龄
            吃饭();
            教学();
            睡觉() {}
---------------------------------------            
        由于抽取后的抽象运动员类和抽象教练类还有共性功能，所以提取一个更抽象的人类：
        抽象人类：
            姓名，年龄
            吃饭();
            睡觉() {}
---------------------------------------            
        抽象运动员类：继承自抽象人类，但又有自己的抽象方法 学习();
        抽象教练类：继承自抽象人类，但又有自己的抽象方法 教学();
        
        学英语是一个扩展的功能，所以要定义一个接口。
        接口：
            说英语();
            
        乒乓球运动员：实现说英语    
        乒乓球教练：实现说英语
-----------------------------------------------------------------------------
    实现：从抽象到具体
        说英语接口
        
        抽象人类
        抽象运动员类
        抽象教练类
        
        具体的说英语的乒乓球运动员类
        具体的篮球运动员类
        
        具体的说英语的乒乓球教练类
        具体的篮球教练类
        
        测试类
-----------------------------------------------------------------------------
    使用：
        使用具体的说英语的乒乓球运动员类和说英语的乒乓球教练类
        以及具体的篮球运动员类和具体的篮球教练类进行测试。
-----------------------------------------------------------------------------
*/
//定义一个说英语的接口
interface SpeakEnglish {
    //说英语
    public abstract void speak();
}

//定义抽象人类
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 void sleep() {
        System.out.println("人都是要睡觉的");
    }
    
    //吃饭是不一样的，所以为抽象方法。
    public abstract void eat();
}

//定义抽象运动员类，继承抽象人类
abstract class Player extends Person {
    public Player() {}
    
    public Player(String name, int age) {
        super(name, age);
    }
    
    //学习的东西不一样，所以为抽象方法。
    public abstract void study();
}

//定义抽象教练类，继承抽象人类
abstract class Coach extends Person {
    public Coach() {}
    
    public Coach(String name, int age) {
        super(name, age);
    }
    
    //教学的东西不一样，所以为抽象方法。
    public abstract void teach();
}

//定义具体的说英语的乒乓球运动员类
class PingPangPlayer extends Player implements SpeakEnglish {
    public PingPangPlayer() {}
    
    public PingPangPlayer(String name, int age) {
        super(name, age);
    }
    
    //吃
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }
    
    //学习
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    
    //说英语
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}

//定义具体的篮球运动员类
class BasketballPlayer extends Player {
    public BasketballPlayer() {}
    
    public BasketballPlayer(String name, int age) {
        super(name, age);
    }
    
    //吃
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
    
    //学习
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
}

//定义具体的说英语的乒乓球教练类
class PingPangCoach extends Coach implements SpeakEnglish {
    public PingPangCoach() {}
    
    public PingPangCoach(String name, int age) {
        super(name, age);
    }
    
    //吃
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }
    
    //教
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }
    
    //说英语
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

//定义具体的篮球教练类
class BasketballCoach extends Coach {
    public BasketballCoach() {}
    
    public BasketballCoach(String name, int age) {
        super(name, age);
    }
    
    //吃
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
    
    //教
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }
}

//测试类
class InterfaceDemo {
    public static void main(String[] args) {
        //测试运动员(乒乓球运动员和篮球运动员)
        //具体的说英语的乒乓球运动员类
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("王浩");
        ppp.setAge(33);
        System.out.println(ppp.getName()+"---"+ppp.getAge());
        ppp.eat();
        ppp.sleep();
        ppp.study();
        ppp.speak();
        System.out.println("----------------");
        //通过带参构造给数据
        ppp = new PingPangPlayer("张继科", 35);
        System.out.println(ppp.getName()+"---"+ppp.getAge());
        ppp.eat();
        ppp.sleep();
        ppp.study();
        ppp.speak();
        System.out.println("----------------");
        
        //具体的篮球运动员类
        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("姚明");
        bp.setAge(34);
        System.out.println(bp.getName()+"---"+bp.getAge());
        bp.eat();
        bp.sleep();
        bp.study();
        //bp.speak(); //报错，因为具体的篮球运动员类没有该方法。
        System.out.println("----------------");
        //通过带参构造给数据
        bp = new BasketballPlayer("林书豪", 28);
        System.out.println(bp.getName()+"---"+bp.getAge());
        bp.eat();
        bp.sleep();
        bp.study();
        System.out.println("----------------");
        
        //测试教练(乒乓球教练和篮球教练)
        //具体的说英语的乒乓球教练类
        PingPangCoach ppc = new PingPangCoach();
        ppc.setName("刘国梁");
        ppc.setAge(45);
        System.out.println(ppc.getName()+"---"+ppc.getAge());
        ppc.eat();
        ppc.sleep();
        ppc.teach();
        ppc.speak();
        System.out.println("----------------");
        //通过带参构造给数据
        ppc = new PingPangCoach("邓亚萍", 50);
        System.out.println(ppc.getName()+"---"+ppc.getAge());
        ppc.eat();
        ppc.sleep();
        ppc.teach();
        ppc.speak();
        System.out.println("----------------");
        
        //具体的篮球教练类
        BasketballCoach bc = new BasketballCoach();
        bc.setName("易建联");
        bc.setAge(35);
        System.out.println(bc.getName()+"---"+bc.getAge());
        bc.eat();
        bc.sleep();
        bc.teach();
        System.out.println("----------------");
        //通过带参构造给数据
        bc = new BasketballCoach("易建联", 35);
        System.out.println(bc.getName()+"---"+bc.getAge());
        bc.eat();
        bc.sleep();
        bc.teach();
    }
}