Motivação

Recentemente, procurei uma maneira de inicializar um objeto complexo sem passar muitos parâmetros para o construtor. Eu tentei com o padrão de construtor, mas eu não gosto do fato, que eu não sou capaz de verificar em tempo de compilação se eu realmente definir todos os valores necessários.

Padrão de construtor tradicional

Quando uso o padrão de construtor para criar meuComplex objeto, a criação é mais "typesafe", porque é mais fácil ver o que um argumento é usado para:

new ComplexBuilder()
        .setFirst( "first" )
        .setSecond( "second" )
        .setThird( "third" )
        ...
        .build();

Mas agora tenho o problema, que posso facilmente perder um parâmetro importante. Eu posso verificar isso dentro dobuild() método, mas isso é apenas em tempo de execução. Na compilação não há nada que me avise, se eu perdi alguma coisa.

Padrão de Construtor Aprimorado

Agora, minha ideia era criar um construtor, que "me lembrasse" se perdesse um parâmetro necessário. Minha primeira tentativa é assim:

public class Complex {
    private String m_first;
    private String m_second;
    private String m_third;

    private Complex() {}

    public static class ComplexBuilder {
        private Complex m_complex;

        public ComplexBuilder() {
            m_complex = new Complex();
        }

        public Builder2 setFirst( String first ) {
            m_complex.m_first = first;
            return new Builder2();
        }

        public class Builder2 {
            private Builder2() {}
            Builder3 setSecond( String second ) {
                m_complex.m_second = second;
                return new Builder3();
            }
        }

        public class Builder3 {
            private Builder3() {}
            Builder4 setThird( String third ) {
                m_complex.m_third = third;
                return new Builder4();
            }
        }

        public class Builder4 {
            private Builder4() {}
            Complex build() {
                return m_complex;
            }
        }
    }
}

Como você pode ver, cada setter da classe do construtor retorna uma classe de construtor interna diferente. Cada classe interna do construtor fornece exatamente um método setter e o último fornece apenas um método build ().

Agora, a construção de um objeto novamente se parece com isso:

new ComplexBuilder()
    .setFirst( "first" )
    .setSecond( "second" )
    .setThird( "third" )
    .build();

... mas não há como esquecer um parâmetro necessário. O compilador não aceitaria isso.

Parâmetros opcionais

Se eu tivesse parâmetros opcionais, usaria a última classe interna do construtorBuilder4 para configurá-los como um construtor "tradicional", retornando a si mesmo.

QuestõesEste é um padrão bem conhecido? Tem um nome especial?Você vê alguma armadilha?Você tem alguma idéia para melhorar a implementação - no sentido de menos linhas de código?