题目：
请编写一个交通工具信息查询系统，其中包含一个抽象父类：交通工具（Transports）类，四个具体子类飞机（Plane）类，轮船（Ship）类，火车（Train）类和巴士（Bus）类，一个单独的城市（City）类以及一个主方法类。其中每个类的属性及方法会再单独文件中给出。要求用户选择所在城市以及目标城市，系统创建相对应的航线对象，将所有对象保存在一个集合中并输出给用户。若目标城市不存在，则用户可以根据给出条件自行添加。
结构：
1抽象父类transports
4子类飞机，轮船，火车，巴士
1城市类
1主方法类
Transports（抽象）:
属性：所属公司，型号
方法：计算所需时间,输出信息
飞机类：
属性：飞行速度，座位数，最大飞行高度，是否跨国
轮船类：
属性：最大载客量，航速，是否跨国
火车类：
属性：车厢数，每节车厢载客量、速度
巴士类：
属性：最大载客量，速度
城市类：
属性：城市名称，X坐标，Y坐标，是否沿海，是否为海岛，所属国家
城市：
A，100，50，是，否，X
B，200，300，是，否，X
C，500，350，是，是，X
D，1500，640，否，否，Y
E，800，500，是，否，Y
F，1100，500，是，否，Y
航线要求：
飞机：城市距离>300km则开设航线
轮船：城市沿海或为海岛则开设航线
火车：两座城市属同一国家且不为海岛则开设
汽车：两座城市属同一国家,不为海岛且城市距离<500km则开设
所属公司：
X国之内为X公司
Y国之内为Y公司
跨国为XY跨国公司
型号：
飞机：跨国为CC（Cross-Country），不跨国为LC（Local）
CC：90km/h，50人，3500m
LC：70km/h，30人，3000m
轮船：S型，100人，20km/h
火车：T型，5节，15人，30km/h
巴士：B型，30人，10km/h
最后的输出效果图
输出的结果样式，可跟自己的需求而改变
上代码
交通工具抽象类
/**
* 交通工具抽象类
*/
public abstract class Transports {
/**
* 公司
*/
protected String company;
/**
* 型号
*/
protected String model;
public Transports(String company, String model) {
this.company = company;
this.model = model;
}
/**
* 计算时间
*
* 距离 除以 速度
*
* @param distance 距离
*/
public abstract void calculateTime(double distance);
/**
* 输出交通工具的信息
*/
public abstract void printInfo();
}飞机类
/**
* 飞机类
*/
public class Plane extends Transports {
/**
* 速度
*/
private int speed;
/**
* 座位数
*/
private int seats;
/**
* 最大高度
*/
private int maxHeight;
/**
* 是否跨国
*/
private boolean crossCountry;
private City startCity;
private City endCity;
public Plane(String company, String model, int speed, int seats, int maxHeight, boolean crossCountry) {
super(company, model);
this.speed = speed;
this.seats = seats;
this.maxHeight = maxHeight;
this.crossCountry = crossCountry;
}
@Override
public void calculateTime(double distance) {
// 计算所需时间的逻辑
System.out.println("所需时间：" + Math.round(distance / speed * 100.0) / 100.0 + "小时");
System.out.println("-------------------------------------");
}
@Override
public void printInfo() {
// 输出飞机信息的逻辑
System.out.println("飞机公司：" + company);
System.out.println("飞机型号：" + model);
System.out.println("飞机速度：" + speed + "km/h");
System.out.println("飞机座位数：" + seats + "人");
System.out.println("飞机最大飞行高度：" + maxHeight + "m");
System.out.println("飞机可否出国：" + (crossCountry ? "是" : "否"));
}
}轮船类
/**
* 轮船类
*/
public class Ship extends Transports {
/**
* 容量
*/
private int capacity;
/**
* 速度
*/
private int speed;
/**
* 是否跨国
*/
private boolean crossCountry;
public Ship(String company, String model, int capacity, int speed, boolean crossCountry) {
super(company, model);
this.capacity = capacity;
this.speed = speed;
this.crossCountry = crossCountry;
}
@Override
public void calculateTime(double distance) {
// 计算所需时间的逻辑
System.out.println("所需时间：" + Math.round(distance / speed * 100.0) / 100.0 + "小时");
System.out.println("-------------------------------------");
}
@Override
public void printInfo() {
// 输出轮船信息的逻辑
System.out.println("轮船公司：" + company);
System.out.println("轮船型号："+ model);
System.out.println("轮船容量："+ capacity + "人");
System.out.println("轮船速度："+ speed + "km/h");
System.out.println("是否可跨国："+ (crossCountry ? "是" : "否"));
}
}火车类
/**
* 火车类
*/
public class Train extends Transports {
/**
* 车厢数
*/
private int carriages;
/**
* 每节车厢容量
*/
private int capacityPerCarriage;
/**
* 速度
*/
private int speed;
public Train(String company, String model, int carriages, int capacityPerCarriage, int speed) {
super(company, model);
this.carriages = carriages;
this.capacityPerCarriage = capacityPerCarriage;
this.speed = speed;
}
@Override
public void calculateTime(double distance) {
// 计算所需时间的逻辑
System.out.println("所需时间：" + Math.round(distance / speed * 100.0) / 100.0 + "小时");
System.out.println("-------------------------------------");
}
@Override
public void printInfo() {
// 输出火车信息的逻辑
System.out.println("火车公司：" + company);
System.out.println("火车型号：" + model);
System.out.println("车厢数量：" + carriages + "节");
System.out.println("每节车厢载客量：" + capacityPerCarriage + "人");
System.out.println("行驶速度：" + speed + "km/h");
}
}巴士类
/**
* 巴士类
*/
public class Bus extends Transports {
/**
* 容量
*/
private int capacity;
/**
* 速度
*/
private int speed;
public Bus(String company, String model, int capacity, int speed) {
super(company, model);
this.capacity = capacity;
this.speed = speed;
}
@Override
public void calculateTime(double distance) {
// 计算所需时间的逻辑
System.out.println("所需时间：" + Math.round(distance / speed * 100.0) / 100.0 + "小时");
System.out.println("-------------------------------------");
}
@Override
public void printInfo() {
// 输出巴士信息的逻辑
System.out.println("巴士公司：" + company);
System.out.println("巴士型号：" + model);
System.out.println("巴士容量：" + capacity + "人");
System.out.println("巴士速度：" + speed + "km/h");
}
}城市类
/**
* 城市类
*/
public class City {
/**
* 城市名称
*/
private String name;
/**
* X坐标
*/
private int xCoordinate;
/**
* Y坐标
*/
private int yCoordinate;
/**
* 是否为沿海城市
*/
private boolean coastal;
/**
* 是否为岛屿
*/
private boolean island;
/**
* 所属国家
*/
private String country;
public City(String name, int xCoordinate, int yCoordinate, boolean coastal, boolean island, String country) {
this.name = name;
this.xCoordinate = xCoordinate;
this.yCoordinate = yCoordinate;
this.coastal = coastal;
this.island = island;
this.country = country;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getxCoordinate() {
return xCoordinate;
}
public void setxCoordinate(int xCoordinate) {
this.xCoordinate = xCoordinate;
}
public int getyCoordinate() {
return yCoordinate;
}
public void setyCoordinate(int yCoordinate) {
this.yCoordinate = yCoordinate;
}
public boolean isCoastal() {
return coastal;
}
public void setCoastal(boolean coastal) {
this.coastal = coastal;
}
public boolean isIsland() {
return island;
}
public void setIsland(boolean island) {
this.island = island;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
@Override
public String toString() {
return "城市名称：" + name + "\n" +
"所属国家：" + country + "\n" +
"是否沿海:" + (coastal ? "是" : "否") + "\n" +
"是否为海岛:" + (island ? "是" : "否") + "\n" +
"X坐标：" + xCoordinate + "\n" +
"Y坐标：" + yCoordinate + "\n" +
"-------------------------------------";
}
}主要运行类
public class MainClass {
public static void main(String[] args) {
// 创建城市对象
City cityA = new City("A", 100, 50, true, false, "X");
City cityB = new City("B", 200, 300, true, false, "X");
City cityC = new City("C", 500, 350, true, true, "X");
City cityD = new City("D", 1500, 640, false, false, "Y");
City cityE = new City("E", 800, 500, true, false, "Y");
City cityF = new City("F", 1100, 500, true, false, "Y");
// 将城市对象添加到城市列表中
List<City> cities = new ArrayList<>();
cities.add(cityA);
cities.add(cityB);
cities.add(cityC);
cities.add(cityD);
cities.add(cityE);
cities.add(cityF);
System.out.println("以下是已有的城市列表：");
for (City city : cities) {
System.out.println(city);
}
// 用户输入所在城市和目标城市
Scanner scanner = new Scanner(System.in);
System.out.println("请输入所在城市名称：");
String fromCityName = scanner.nextLine();
System.out.println("请输入目标城市名称：");
String toCityName = scanner.nextLine();
// 查找所在城市和目标城市对象
City fromCity = cities.stream()
.filter(city -> city.getName().equals(fromCityName))
.findFirst()
.orElse(null);
City toCity = cities.stream()
.filter(city -> city.getName().equals(toCityName))
.findFirst()
.orElse(null);
// 如果目标城市不存在，允许用户自行添加
if (toCity == null) {
System.out.println("目标城市不存在，请自行添加：");
System.out.println("请输入城市名称：");
String newCityName = scanner.nextLine();
System.out.println("请输入X坐标：");
int xCoordinate = scanner.nextInt();
scanner.nextLine(); // 消耗换行符
System.out.println("请输入Y坐标：");
int yCoordinate = scanner.nextInt();
scanner.nextLine(); // 消耗换行符
System.out.println("是否沿海（是/否）：");
boolean isCoastal = scanner.nextLine().equalsIgnoreCase("是");
System.out.println("是否为海岛（是/否）：");
boolean isIsland = scanner.nextLine().equalsIgnoreCase("是");
System.out.println("所属国家：");
String country = scanner.nextLine();
// 创建新城市对象并添加到城市列表中
City newCity = new City(newCityName, xCoordinate, yCoordinate, isCoastal, isIsland, country);
cities.add(newCity);
toCity = newCity; // 更新目标城市对象
}
// 创建交通工具对象并添加到集合中
Set<Transports> transports = new HashSet<>();
if (fromCity != null && toCity != null) {
createTransports(transports, fromCity, toCity);
} else {
System.out.println("无法找到有效的起始城市和目标城市。");
}
}
private static void createTransports(Set<Transports> transports, City fromCity, City toCity) {
// 计算起始城市和目标城市之间的距离
double distance = Math.sqrt(Math.pow(toCity.getxCoordinate() - fromCity.getxCoordinate(), 2) + Math.pow(toCity.getyCoordinate() - fromCity.getyCoordinate(), 2));
// 是否跨国 true 表示跨国
boolean crossCountry = !fromCity.getCountry().equals(toCity.getCountry());
// 所属公司
String countryName = "X公司";
if (crossCountry) {
countryName = "XY跨国公司";
} else if (!crossCountry && fromCity.getCountry().equals("Y公司")) {
countryName = "Y公司";
}
// 判断是否满足开设航线的条件
if (distance > 300) {
// 创建飞机对象
Plane plane = new Plane( countryName,
crossCountry ? "CC" : "LC",
crossCountry ? 90 : 70,
50,
3500,
crossCountry);
transports.add(plane);
}
if (fromCity.isCoastal() || toCity.isCoastal() || fromCity.isIsland() || toCity.isIsland()) {
// 创建轮船对象
Ship ship = new Ship(
countryName,
"S型",
100,
20,
crossCountry
);
transports.add(ship);
}
if (crossCountry && !fromCity.isIsland() && !toCity.isIsland()) {
// 创建火车对象
Train train = new Train(
countryName,
"T型",
5,
15,
30
);
transports.add(train);
}
if (crossCountry && !fromCity.isIsland() && !toCity.isIsland() && distance < 500) {
// 创建巴士对象
Bus bus = new Bus(
countryName,
"B型",
30,
30
);
transports.add(bus);
}
// 显示交通工具信息
System.out.println("\n可用交通工具信息：\n");
for (Transports transport : transports) {
transport.printInfo();
transport.calculateTime(distance);
}
}
}最后
代码还有很多的优化空间，例如：
- 代码复用：避免重复的代码片段。例如，
countryName的确定逻辑在创建不同的交通工具时被重复了。这可以提取到一个单独的方法中。 - 可读性：一些魔法数字和字符串（如 "X公司", "Y公司", 300, 500 等）最好定义为常量，以提高代码的可读性和可维护性。
- 条件判断：尽量简化嵌套的条件判断，以减少代码的复杂性。
- 异常处理：对于可能出错的地方（如计算距离、获取城市坐标等），应该加入适当的异常处理。
- 注释：虽然代码已经有注释，但可以进一步精炼和明确，以便更好地描述每个部分的功能和意图。
- OOP 设计原则：可以考虑使用面向对象的设计原则，如单一职责原则（SRP）和开闭原则（OCP），来进一步优化代码结构。
