Day 13 JavaObject03作业

作业：

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

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

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

要求自己设计该系统，并测试。

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()

参考答案：

1.

public interface TimeCalculator {
    /*
     * 该方法的作用是 计算某种交通工具，移动指定举例所花的时间
     */
    double calculateTime(int distance);
}

/**
 *
 * 该类抽象所有，类型交通工具的共性，3个参数a, b, c, 同时，所有交通工具都需要计算所需的时间，该计算方法我放在了TimeCalculator接口中
 */
public 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 calculateTime(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;
    }
}

public class Car extends Vehicle {

    public Car(int a, int b, int c) {
        super(a, b, c);
    }

    @Override
    public double getSpeed() {
        return getA() + getB() + getC();
    }
}

public 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();
    }
}

public 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 Test {

    public static void main(String[] args) {

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

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

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

2.

/**
 *
 * Human中定义所有运动员和教练员都具有的属性 name age salary 行为 eat(), sleep()
 */
public class Human {

    private String name;
    private int age;
    private int salary;

    public Human() {
    }

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

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

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

    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 int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }
}

/**
 *
 * 定义运动员都具有的行为：train(), match() 虽然所有运动员都有这样的行为，但是不同的运动员，训练和比赛的内容都不相同，
 * 所有Athlete类定义为抽象类
 *
 */
public abstract class Athlete extends Human {

    public abstract void train();

    public abstract void match();
}

/**
 *
 * 定义教练都具有的行为：teach(),以及属性bonus 虽然所有教练都有这样的行为，但是不同的教练，教的内容都不相同， 所有Coach类定义为抽象类
 */
public abstract class Coach extends Human {

    private int bonus;

    public abstract void teach();

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }
}

public class TabletennisAthlete extends Athlete implements SpecialSkill {

    @Override
    public void train() {
        System.out.println(getName() + " train table tennis");
    }

    @Override
    public void match() {
        System.out.println(getName() + "match table tennis");
    }

    @Override
    public void leaningEnglish() {
        System.out.println("athlete " + getName() + " learning english");
    }
}

public class TabletennisCoach extends Coach implements SpecialSkill {

    @Override
    public void teach() {
        System.out.println(getName() + "teach table tennis");
    }

    @Override
    public void leaningEnglish() {
        System.out.println("coach " + getName() + " learning english");
    }
}

public class FootballAthlete extends Athlete {

    @Override
    public void train() {
        System.out.println(getName() + " train basketball");
    }

    @Override
    public void match() {
        System.out.println(getName() + "match basketball");
    }
}

public class FootballCoach extends Coach {

    @Override
    public void teach() {
        System.out.println(getName() + "teach basketball");
    }
}