0

我有一个 BasicFooBuilder 类，它有一个 buildFoo 方法接受一个 Foo 并构建一些东西。但后来我想创建一个完整的构建器层次结构和我想要使用的更复杂的对象。目前我有这样的事情：

public interface Builder{
 public void buildFoo(BasicFoo foo);
}

public class BasicFooBuilder implements Builder{
 @override
 public void buildFoo(BasicFoo foo){
  //Do something
 }
}

public class FancyFooBuilder extends BasicFooBuilder{
 @override
 public void buildFoo(BasicFoo foo){
  ((FancyFoo)foo).doSomethingFancy();
 }
 //More stuff inherited from basic foo
}

public class FancierFooBuilder extends FancyFooBuilder{
 @override
 public void buildFoo(BasicFoo foo){
  ((FancierFoo)foo).doSomethingFancier();
 }
 //More stuff inherited from basic foo and fancy foo
}

类层次结构是这样的：

BasicFoo
  |
  FancyFoo
    |
    FancierFoo

所以问题是这样的：

如果不在子类的覆盖方法中进行所有强制转换，我怎么能做到以上几点？

4

1 回答 1

2

您将需要一个泛型类型参数，它基本上代表您正在构建的类本身。您不能将其完全限制为仅一类，但您可以接近。

public interface Builder<T extends BasicFoo> {
 public void buildFoo(T foo);
}

public class BasicFooBuilder<T extends BasicFoo> implements Builder<T> {
 @Override
 public void buildFoo(BasicFoo foo){
  //Do something
 }
}

public class FancyFooBuilder<T extends FancyFoo> extends BasicFooBuilder<T> {
 @Override
 public void buildFoo(T foo){
  foo.doSomethingFancy();
 }
 //More stuff inherited from basic foo
}

public class FancierFooBuilder<T extends FancierFoo> extends FancyFooBuilder<T> {
 @Override
 public void buildFoo(T foo){
  foo.doSomethingFancier();
 }
 //More stuff inherited from basic foo and fancy foo
}
于 2013-11-04T22:00:25.200 回答