Java 일반 빌더

Question

BaseBuilder을 확장하려면 일부 DerivedBuilder이 필요하다고 가정합니다. 기본 빌더는 foo (BaseBuilder을 반환)과 같은 몇 가지 메소드가 있습니다. 파생 된 빌더에는 방법 bar이 있습니다. 메소드 bar은 foo 메소드 다음에 호출해야합니다. 그것을하기 위해이 같은 DerivedBuilder에 foo 메소드를 오버라이드 (override) 할 수 있습니다

@Override 
public DerivedBuilder foo() { 
    super.foo(); 
    return this; 
} 

문제는 BaseBuilder가 foo 같은 방법을 많이 가지고 내가 그들의 각 하나를 무시해야한다는 것입니다. 그래서 내가 제네릭을 사용하려고 그렇게하고 싶지 않은 :

public class BaseBuilder<T extends BaseBuilder> { 
    ... 

    public T foo() { 
     ... 
     return (T)this; 
    } 
} 

public class DerivedBuilder<T extends DerivedBuilder> extends BaseBuilder<T> { 
    public T bar() { 
     ... 
     return (T)this; 
    } 
} 

그러나 문제는 내가 아직 여기 DerivedBuilder입니다

new DerivedBuilder<DerivedBuilder>() 
     .foo() 
     .bar() 

에도 T 불구하고 쓸 수 있다는 것입니다. 많은 기능을 오버라이드하지 않기 위해 내가 할 수있는 일은 무엇입니까?

Answer 1

귀하의 문제는 DerivedBuilder의 정의입니다.

public class BaseBuilder<T extends BaseBuilder<T>> { 
    @SuppressWarnings("unchecked") 
    public T foo() { 
     return (T)this; 
    } 
} 

public class DerivedBuilder extends BaseBuilder<DerivedBuilder> { 
    public DerivedBuilder bar() { 
     return this; 
    } 
} 

확인 ideone.com :이 같은 완전하게 정의 파생 된 유형을해야합니다

.

Answer 2

나는 당신의 질문에서 메서드 foo() 메서드 bar() 전에 실행되어야한다는 것을 이해합니다.
올바른 경우 템플릿 디자인 패턴을 적용 할 수 있습니다.
BaseBuilder에 추상 메서드 모음을 만듭니다.
그리고 새로운 방법으로 '템플릿'이라고 말합니다. 메소드 템플릿은 시퀀스를 정의합니다. foo()가 먼저 실행되고 bar()가 먼저 실행됩니다.
DerivedBuilder는 메소드 막대의 구현을 제공합니다. 이 도움이

public abstract class BaseBuilder { 

    public void foo(){ 
     System.out.println("foo"); 
    } 

    public abstract void bar(); 

    public void template(){ 
     foo(); 
     bar(); 
    } 
} 

public class DerivedBuilder extends BaseBuilder{ 

    @Override 
    public void bar() { 
     System.out.println("bar");  
    } 

    public static void main(String[] args) { 
     BaseBuilder builder = new DerivedBuilder(); 
     builder.template(); 
    } 
} 

희망. 인수 new DerivedBuilder<DerivedBuilder<...what?...>>()을 삭제 타입으로 인스턴스화

class DerivedBuilder<T extends DerivedBuilder>; 

: 그리고

Answer 3

대신에 return (T) this;을 캐스팅하는 대신 Class.cast(this)을 작성했습니다.

실현하려면

이

BaseBuilder.build(ExtendedBuilder.class).foo().bar().foo().bar(); 

hierarch의 모든 클래스는 실제 최종 하위 클래스를 알 필요가있다, 따라서 나는 기본 클래스에 팩토리 메소드를build을하기로 결정했습니다.

실제 자식과 this의 캐스트는 return me();을 제공하면서 기본 클래스의 최종 메소드에서도 수행됩니다.당신이 더 중첩하려면

class BaseBuilder<B extends BaseBuilder<B>> { 

    protected Class<B> type; 

    public static <T extends BaseBuilder<T>> T build(Class<T> type) { 
     try { 
      T b = type.newInstance(); 
      b.type = type; 
      return b; 
     } catch (InstantiationException | IllegalAccessException e) { 
      throw new IllegalStateException(e); 
     } 
    } 

    protected final B me() { 
     return type.cast(this); 
    } 

    B foo() { 
     System.out.println("foo"); 
     return me(); 
    } 
} 

class ExtendedBuilder extends BaseBuilder<ExtendedBuilder> { 

    ExtendedBuilder bar() { 
     System.out.println("bar"); 
     return me(); 
    } 
} 

Answer 4

BeyelerStudios's answer 외에도, 당신은 단지 이것을 사용할 수 있습니다 :

class Base<T extends Base<?>> { 
    public T alpha() { return (T) this; } 
    public T bravo() { return (T) this; } 
    public T foxtrot() { return (T) this; } 
} 

class Derived<T extends Derived<?>> extends Base<T> { 
    public T charlie() { return (T) this; } 
    public T golf() { return (T) this; } 
} 

class FurtherDerived<T extends FurtherDerived<?>> extends Derived<T> { 
    public T delta() { return (T) this; } 
    public T hotel() { return (T) this; } 
} 

class MuchFurtherDerived<T extends MuchFurtherDerived<?>> extends FurtherDerived<T> { 
    public T echo() { return (T) this; } 
} 

public static void main(String[] args) { 
    new MuchFurtherDerived<MuchFurtherDerived<?>>() 
     .alpha().bravo().charlie().delta().echo().foxtrot().golf().hotel() 
     .bravo().golf().delta().delta().delta().hotel().alpha().echo() 
     .echo().alpha().hotel().foxtrot(); 
}