抽象类的集合（或类似的东西......）

场景

我正在用 Java 编写一个涉及汽车的程序。

注意：我（尽我所能）简化了这个场景，使其更通用且更容易理解。我实际上并不是在和汽车打交道。

我创建了一个Cars类，它是一个集合Car对象。

The Car对象有一个speed（双）和一个year（整数）。构造函数将年份作为参数，例如：

public class Car {
    private int year;
    private double speed;

    public Car(int year) {
        this.year = year;
    }
}

这是棘手的部分......汽车必须有一种类型（比如说克尔维特或旧车）。克尔维特将有一个speed of 0.9一个旧车会有一个speed of 0.1. A Car如果不指定它应该是什么类型的汽车，则永远无法实例化。现在，要制造一辆汽车，我们需要：

Car car = new Car(1998, Corvette);

我们刚刚创建的克尔维特将是Car对象具有speed of 0.9.

问题

我的实际情况涉及到的车种类比较多，每辆车除了有几个特定的​​属性speed（也许还有字段color, numDoors and fuelTankSize）。由于汽车种类繁多（每种汽车都有自己的特定属性），代码变得比我想象的更加复杂。

可能的解决方案

1. 我可以使用子类，即有一个抽象Car扩展的类Corvette and Clunker，但是我遇到了使用的问题Cars对象（因为我无法收集无法实例化的东西）。请参阅下面的编辑。

2. 使用枚举（例如CarKind）似乎需要几个凌乱的 switch 语句：

   • 来填充speed每辆车的场
   • 创造Car对象来自Cars class
   • etc.

您可以如何提供帮助

我正在寻找一种解决方案，允许单个Cars类包含每个Car目的。我don't想要不同的收藏（比如Corvettes, Clunkers）。我也在寻找一种允许创建的解决方案Car基于单个汽车类型属性的对象...如前所述，创建一个新的Car同类Corvette会导致speed of 0.9。不应该有其他方法来指定汽车speed.

在这种情况下有最佳实践吗？我举的例子够清楚了吗？

Thanks.

编辑：我不想收集摘要的原因Car对象是因为Cars集合就是创建和操作Car对象，无论其种类如何。Car抽象似乎使事情变得复杂。如果您认为这是最好的解决方案，请相应地回答。

我正在寻找一种解决方案，允许单个 Cars 类包含 每个汽车对象。我不想要不同的收藏（比如克尔维特， 旧车）。我也在寻找一种允许创建的解决方案 基于单个汽车类型属性的汽车对象...如 前面提到过，创造一款类似 Corvette 的新车将导致 以0.9的速度。不应该有其他方法来指定汽车 速度。

天哪，天哪，有很多方法可以解决这个问题，我们可以继续一整天！我会做一次大脑转储，希望这对你来说不会太难处理。

解决方案1：使用策略。

策略基本上是一种将大量可替换逻辑与另一个类分开的方法。在这种情况下，每辆车都需要进行不同的设计。对此，有一个策略是完美的。

抱歉，如果我不小心混入了一些 C#...自从我使用 java 以来已经很长时间了。

public interface CarCreationStrategy{
   void BuildCar(Car theCar);
}

public class CorvetteStrategy implements CarCreationStrategy{
   public void BuildCar(Car theCar){
      theCar.Type = "Corvette";
      theCar.Speed = 0.9;
      theCar.Comments = "Speedster!";
   }
}

public class ToyotaStrategy implements CarCreationStrategy{
   public void BuildCar(Car theCar){
      theCar.Type = "Toyota";
      theCar.Speed = "0.5";
      theCar.Comments = "Never dies, even if you drop it from the top of a building";
   }
}

现在，您可以向汽车构造函数传递策略。

public class Car{
   // Variables ...

   public Car(CarCreationStrategy strategy, int year){
      strategy.BuildCar(this); // Implements your properties here.
      this.year = year;
   }
}

所以，你现在得到的东西真是太棒了！

List<Car> cars = new List<Car>();
cars.Add(new Car(new CorvetteStrategy(),1999));
cars.Add(new Car(new ToyotaStrategy(),2011);

这将完全满足您的要求。

然而，你会得到策略和汽车之间的耦合。

解决方案2：使用Factory。

Factory 也是一个不错的解决方案，而且可能更容易。您要做的就是拥有一个 CarFactory，其中具有用于创建每种类型汽车的多个工厂方法。

public class CarFactory{
   public static Car BuildCorvette(int year){
      Car car = new Car(year);
      car.Type = "Corvette;
      car.Speed = 0.9";
      return car;
   }

   public static Car BuildToyota(int year){
      Car car = new Car(year);
      car.Type = "Toyota;
      car.Speed = 0.5";
      return car;
   }
}

Usage:

List<Car> cars = new List<Car>();
cars.Add(CarFactory.BuildCorvette(1999));
cars.Add(CarFactory.BuildToyota(2011));

所以这样做的好处是您现在不必担心实例化 Car。它全部由 CarFactory 处理，将您的“实例化逻辑”与代码解耦。但是，您仍然需要知道要构建哪辆车并相应地调用该方法，这仍然是一个小的耦合。

解决方案3：策略工厂！

所以，如果我们想摆脱最后一点耦合，让我们将两者结合在一起！

public class CarFactory{
   public static Car BuildCar(CarCreationStrategy strategy, int year){
      Car car = new Car(year);
      strategy.BuildCar(car);
      return car;
   }
}

List<Car> cars = new List<Car>();
cars.Add(CarFactory.BuildCar(new CorvetteStrategy(),1999));
cars.Add(CarFactory.BuildCar(new ToyotaStrategy(),2011);

现在你有了一个制造汽车的策略，一个为你制造汽车的工厂，以及一辆没有你原来的额外接头的汽车。太棒了，不是吗？

如果您使用过 Swing，您会注意到这就是它们处理诸如布局之类的一些事情的方式（GridBagLayout、GridLayout 都是策略）。还有一个 BorderFactory。

改进

抽象策略

public interface CarCreationStrategy{
   void BuildCar(Car theCar);
}

public class AbstractStrategy:CarCreationStrategy{
   public string Type;
   public double Speed;
   public string Comments;

   public void BuildCar(Car theCar){
       theCar.Type = this.Type;
       theCar.Speed = this.Speed;
       theCar.Comments = this.Comments;
   }
}

public class CorvetteStrategy extends AbstractStrategy{
   public CorvetteStrategy(){
      this.Type = "Corvette";
      this.Speed = 0.9;
      this.Comments = "Speedster!";
   }
}

public class ToyotaStrategy extends AbstractStrategy{
   public ToyotaStrategy{
      this.Type = "Toyota";
      this.Speed = "0.5";
      this.Comments = "Never dies, even if you drop it from the top of a building";
   }
}

使用它可以让您灵活地动态创建 AbstractStrategies（例如，从数据存储中提取汽车属性）。