使用泛型 <K> 减少重复代码？

Question

我有以下代码。如您所见，我正在执行类似的逻辑，但一次用于自行车，一次用于汽车。我可以使用<K> 来减少重复的代码吗？我没有使用过<K>，所以我不确定我可以在哪里以及如何准确地合并它。我在哪里可以决定是拨打getCarsWithFeature还是getBikesWithFeature？

最好的做法是减少行数（可能会降低可读性）还是拥有类似重复的代码？

public Set<Car> getPremiumCars(String filter) {
    final Callable<Set<Car>> retryGetCars = new RetryingCallable<>(retryStrategy(), getCars(filter));  
    return retryGetCars.call();
}

public Callable<Set<Car>> getCars(String feature) {
    return new Callable<Set<Car>>() {
        @Override
        public Set<Car> call() throws Exception {
            Set<Car> cars = getCarsWithFeature(feature); 
            return Collections.unmodifiableSet(cars);
        }
    };
}

public Set<Bike> getPremiumBikes(String filter) {
    final Callable<Set<Bike>> retryGetBikes = new RetryingCallable<>(retryStrategy(), getBikes(filter));
    return retryGetBikes.call();            
}

public Callable<Set<Bike>> getBikes(String feature) {
    return new Callable<Set<Bike>>() {
        @Override
        public Set<Bike> call() throws Exception {
            Set<Bike> bikes = getBikesWithFeature(feature); 
            return Collections.unmodifiableSet(bikes);
        }
    };
}

Answer 1

我不知道你的全部代码，但我建议两个类都实现相同的接口 - 比如说Vehicle：

  public interface Vehicle {
  }

然后你可以编写最近可以重用的代码：

  public <T extends Vehicle> Set<T> getPremiumVehicle(Function<String, Callable<Set<T>>> vehicleSupplier, String filter) throws Exception {
    final Callable<Set<T>> retryGetCars = new RetryingCallable<T>(retryStrategy(), vehicleSupplier.apply(filter));
    return retryGetCars.call();
  }

  public <T extends Vehicle> Callable<Set<T>> getVehicle(Function<String, Set<T>> vehicleSupplier, String feature) {
    return () -> {
      Set<T> vehicles = vehicleSupplier.apply(feature);
      return Collections.unmodifiableSet(vehicles);
    };
  }

现在，您可以重用上面的代码，例如：

  public Set<Car> getPremiumCars(String filter) throws Exception {
    return getPremiumVehicle(this::getCars, filter);
  }

  public Set<Bike> getPremiumBikes(String filter) throws Exception {
    return getPremiumVehicle(this::getBikes, filter);
  }

  public Callable<Set<Car>> getCars(String feature) {
    return getVehicle(this::getCarsWithFeature, feature);
  }

  public Callable<Set<Bike>> getBikes(String feature) {
    return getVehicle(this::getBikesWithFeature, feature);
  }

Answer 2

创建一个 Car 和 Bike 的基类，然后把通用方法放在那里。 然后从中扩展汽车和自行车。使用基类更新通用方法。下面给出了实现的示例提示：

class Vehicle {
  public Set<Vehicle> getWithFilter(String filter) {
    final Callable<Set<Vehicle>> retryGet = new RetryingCallable<>(retryStrategy(), get(filter));
    return retryGet.call();            
  }
  public Callable<Set<Vehicle>> getWithFeature(String feature) {
    return new Callable<Set<Vehicle>>() {
        public Set<Vehicle> call() throws Exception {
            Set<Vehicle> vehicles = getWithFeature(feature); 
            return Collections.unmodifiableSet(vehicles);
        }
    };
  }

} 
class Car extends Vehicle {
}
class Bike extends Vehicle {
}

现在调用使用：

Car car = new Car();
car.getWithFilter(/* Pass parameter*/);

Bike bike = new Bike();
bike.getWithFilter(/* Pass parameter*/);