为某研究所编写一个通用程序，用来计算每一种交通工具运行 1000公里所需的时间

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

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

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

package com.wangdao.day11;
/**
* @author Yuechao Yang E-mail:[email protected]
* @version 创建时间：2019年4月5日 下午11:23:53
* 类说明
* 这里改成常量所以这样做，如果是变量的话，接口里不能声明A,B,C
*/
public class Time3 {

	public static void main(String[] args) {
		Carss car = new Carss();
		Planess plane=new Planess();
        Shipss ship=new Shipss();

        System.out.println("车的时间"+car.time());
        System.out.println("飞机的时间"+plane.time());
        System.out.println("船的时间"+ship.time());
	}

}
interface Toolss{
	int a = 100, b = 200, c = 300, l = 1000;
	abstract double time();
}
class Carss implements Toolss{
	public double time() {
		return l/(a*b/c);
	}
}
class Planess implements Toolss{
	public double time() {
		return l/(a+b+c);
	}
}
class Shipss implements Toolss{
	public double time() {
		return l/(a+b/c);
	}
}

下面是用接口做的，a, b, c 是变量

public class Time2 {

	public static void main(String[] args) {
		Cars car = new Cars();
		Planes plane=new Planes();
        Ships ship=new Ships();

        System.out.println("车的时间"+car.speed(3,4,5));
        System.out.println("飞机的时间"+plane.speed(3,4,5));
        System.out.println("船的时间"+ship.speed(3,4,5));
	}

}
interface Tool{
	abstract double speed(int a, int b, int c);
}
class Cars implements Tool{
	public double speed(int a, int b, int c) {
		return 1000/(a*b/c);
	}
}
class Planes implements Tool{
	public double speed(int a, int b, int c) {
		return 1000/(a+b+c);
	}
}
class Ships implements Tool{
	public double speed(int a, int b, int c) {
		return 1000/(a+b/c);
	}
}

下面是用抽象类做的

public class Time{
    public static void main(String[] args) {
        Tools car=new Car();
        Tools plane=new Plane();
        Tools ship=new Ship();

        System.out.println("车的时间"+car.time(3,4,5));
        System.out.println("飞机的时间"+plane.time(3,4,5));
        System.out.println("船的时间"+ship.time(3,4,5));
    }
}

//抽象类不能实例化
abstract  class Tools{
   
    public Tools(){

    }
    //抽象方法 强制子类执行
    abstract double time(int A,int B,int C);
}

class Car extends Tools{


    double time(int A,int B,int C){
        return 1000/(A*B/C);
    }
}

class Plane extends Tools{

    double time(int A,int B,int C){
        return 1000/(A+B+C);
    }
}

class Ship extends Tools{

    double time(int A,int B,int C){
        return 1000/(A+B/C);
    }
}

应该最好用接口实现吧，接口是把各个方法放在一起，能不用抽象就不用（存疑，以后学习更深再来填坑）