10

1. 为某研究所编写一个通用程序，用来计算每一种交通工具运行 1000公里所需的时间.已知每种交通工具的参数都是3个整数常量A、B、C的表达式。

现有两种工具：Car 和Plane，
其中Car 的速度运算公式为：A*B/C，
Plane 的速度运算公式为 ：A+B+C。

要求在未来如果增加第3种交通工具（如Ship）的时候，可以做到复用已有代码。
Ship的速度运算公式为 ：A+B/C。

这里复用已有代码的意思是，比如专门定义了一个方法，用来计算所有交通工具的，移动指定距离所用的时间
, 可以不改变这个方法，继续用它计算新增加的交通工具的运行时间
double calculateTime(int distance， 计算对象) {
return 计算结果
}
要求自己设计该系统，并测试。

package Q1;


// 该接口只定义了一个功能，即计算某种类型交通工具，移动指定距离，所用时间
interface TimeCalculator {
    /*
        该方法的作用是 计算某种交通工具，移动指定举例所花的时间
     */
    double calculate(int distance);

}

/**
 *
 * 该类抽象所有，类型交通工具的共性，3个参数a, b, c,

 * 同时，所有交通工具都需要计算所需的时间，该计算方法我放在了TimeCalculator接口中

 */

abstract class Vehicle implements TimeCalculator{
/*
    不管哪种交通工具都需要这些参数来计算自己的速度
 */

    private int a;
    private int b;
    private int c;
    public Vehicle(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
    /*
        获取某交通工具的速度的方法，因为每种交通工具速度的计算方式不一样
        留给子类去实现就好了
     */
    public abstract double getSpeed();
/*
    计算某种交通工具移动指定距离，锁需要的时间，该方法
    我专门放在一个接口中声明，也可以不使用接口
    因为只要知道了速度，和距离时间是按照相同的方式计算，
    所以这里直接实现了计算时间的方法

 */

    @Override
    public double calculate(int distance) {
        return distance / getSpeed();
    }
    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }
    public void setB(int b) {
        this.b = b;
    }
    public int getC() {
        return c;
    }
    public void setC(int c) {
        this.c = c;
    }
}

class Car extends Vehicle {
    public Car(int a, int b, int c) {
        super(a, b, c);
    }
    @Override
    public double getSpeed() {
        return getA() + getB() + getC();
    }

}

class Plane extends Vehicle {
    public Plane(int a, int b, int c) {
        super(a, b, c);
    }
    @Override
    public double getSpeed() {
        return 1.0 * getA() * getB() / getC();
    }
}

class Ship extends Vehicle {
    public Ship(int a, int b, int c) {
        super(a, b, c);
    }

    @Override
    public double getSpeed() {
        return 1.0 * getA() + getB() / getC();

    }
}
    // 测试类
    public class Demo {
        public static void main(String[] args) {
            TimeCalculator calculator = new Car(10, 20, 2);
            System.out.println(calculateTime(1000, calculator));

            calculator = new Plane(10, 20, 2);
            System.out.println(calculateTime(1000, calculator));

            calculator = new Ship(10, 20, 2);
            System.out.println(calculateTime(1000, calculator));
        }

        // 用该方法计算所有的交通工具时间
        public static double calculateTime(int distance, TimeCalculator calculator) {
            return calculator.calculate(distance);
        }
    }

2.完成课堂上没有讲完的案例
教练和运动员案例(只不过把篮球改成了足球哈，称呼变了)
乒乓球运动员和足球运动员。
乒乓球教练和足球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类

乒乓球用运动员 属性 name age salary learnEnglish()
行为 eat() sleep() train() match()

足球运动员 属性 name age salary
行为 eat() sleep() train() match()

乒乓球教练: nama age salary bonus
eat()，sleep(), teach()，learnEnglish()

足球教练： nama age salary bonus
eat()，sleep(), teach()

package Q2;

import org.omg.CORBA.PUBLIC_MEMBER;

class Human {
    String name;
    int age;
    int salary;

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

    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

abstract class Athlete extends Human {
    public Athlete(String name, int age, int salary){
        super(name, age, salary);
    }

    public abstract void train();
    public abstract void match();
}

abstract class Coach extends Human {
    int bonus;

    public Coach(String name, int age, int salary, int bonus){
        super(name, age, salary);
        this.bonus = bonus;
    }

    public abstract void teach();
}

interface SpecialSkill {
    void learnEnglish();
}

class TableTennisAthlete extends Athlete implements SpecialSkill {
    public TableTennisAthlete(String name, int age, int salary){
        super(name, age, salary);
    }

    @Override
    public void train(){
        System.out.println("练习乒乓球");
    }

    @Override
    public void match() {
        System.out.println("乒乓球比赛");
    }

    @Override
    public void learnEnglish() {
        System.out.println("球员学习英语");
    }
}

class TableTennisCoach extends Coach implements SpecialSkill {
    public TableTennisCoach(String name, int age, int salary, int bonus) {
        super(name, age, salary, bonus);
    }

    @Override
    public void teach() {
        System.out.println("指导乒乓球");
    }

    @Override
    public void learnEnglish() {
        System.out.println("教练学习英语");
    }
}

class BasketBallAthlete extends Athlete {
    public BasketBallAthlete(String name, int age, int salary){
        super(name, age, salary);
    }

    @Override
    public void train(){
        System.out.println("练习篮球");
    }

    @Override
    public void match() {
        System.out.println("篮球比赛");
    }
}

class BasketBallCoach extends Coach {
    public BasketBallCoach(String name, int age, int salary, int bonus) {
        super(name, age, salary, bonus);
    }

    @Override
    public void teach() {
        System.out.println("指导篮球");
    }
}
public class Demo {
    public static void main(String[] args) {
        Athlete athlete = new BasketBallAthlete("王大", 18, 7000);
        System.out.println("BasketBallAthlete:");
        athlete.eat();
        athlete.sleep();
        athlete.train();
        athlete.match();
        athlete = new TableTennisAthlete("李二", 18, 8000);
        System.out.println("TableTennisAthlete:");
        athlete.eat();
        athlete.sleep();
        athlete.train();
        athlete.match();
        ((TableTennisAthlete) athlete).learnEnglish();
        Coach coach = new BasketBallCoach("张三", 28, 7000, 10000);
        System.out.println("BasketBallCoach:");
        coach.eat();
        coach.sleep();
        coach.teach();
        coach = new TableTennisCoach("钱四", 28, 8000, 10000);
        System.out.println("TableTennisCoach:");
        coach.eat();
        coach.sleep();
        coach.teach();
        ((TableTennisCoach) coach).learnEnglish();
    }
}

3. 根据注释填写(1), (2),(3)处的代码
   public class Test{
   public static void main(String[] args){
   //创建并初始化Bean1类对象bean1
   (1)
   bean1.i++;
   // 创建并初始化Bean2类对象bean2
   (2)
   bean2.j++;
   //创建并初始化Bean3类对象bean3
   (3)
   bean3.k++;
   }
   class Bean1{
   public int i = 0;
   }

   static class Bean2{
   public int j = 0;
   }
   }

class Bean{
class Bean3{
public int k = 0;
}
}