É uma prática ruim fazer um levantador retornar "isso"?

É uma boa ou má idéia fazer com que os setters em java retornem "isso"?

public Employee setName(String name){
   this.name = name;
   return this;
}

Esse padrão pode ser útil porque você pode encadear setters como este:

list.add(new Employee().setName("Jack Sparrow").setId(1).setFoo("bacon!"));

em vez disso:

Employee e = new Employee();
e.setName("Jack Sparrow");
...and so on...
list.add(e);

... mas isso vai contra a convenção padrão. Suponho que possa valer a pena apenas porque pode fazer com que o levantador faça outra coisa útil. Eu já vi esse padrão usado em alguns lugares (por exemplo, JMock, JPA), mas parece incomum e geralmente usado apenas para APIs muito bem definidas, onde esse padrão é usado em qualquer lugar.

Atualizar:

O que eu descrevi é obviamente válido, mas o que realmente estou procurando é pensar se isso geralmente é aceitável e se existem armadilhas ou práticas recomendadas relacionadas. Eu sei sobre o padrão Builder, mas ele é um pouco mais envolvido do que o que estou descrevendo - como Josh Bloch descreve, há uma classe estática associada do Builder para criação de objetos.

Não acho que exista algo especificamente errado, é apenas uma questão de estilo. É útil quando:

• Você precisa definir vários campos ao mesmo tempo (inclusive na construção)
• você sabe quais campos precisa definir no momento em que está escrevendo o código e
• existem muitas combinações diferentes para quais campos você deseja definir.

Alternativas para esse método podem ser:

1. Um mega construtor (desvantagem: você pode passar muitos valores nulos ou padrão, e fica difícil saber qual valor corresponde a qual)
2. Vários construtores sobrecarregados (desvantagem: fica difícil quando você tem mais do que alguns)
3. Métodos de fábrica / estáticos (desvantagem: o mesmo que os construtores sobrecarregados - fica difícil quando há mais do que alguns)

Se você apenas definir algumas propriedades por vez, diria que não vale a pena retornar 'this'. Certamente diminui se você decidir retornar outra coisa, como um indicador de status / sucesso / mensagem.

Não é uma prática ruim. É uma prática cada vez mais comum. A maioria dos idiomas não exige que você lide com o objeto retornado, se não desejar, para que ele não mude a sintaxe de uso "normal" do setter, mas permita que você encadeie os setters.

Isso geralmente é chamado de padrão de construtor ou interface fluente .

Também é comum na API Java:

String s = new StringBuilder().append("testing ").append(1)
  .append(" 2 ").append(3).toString();

Para resumir:

• é chamado de "interface fluente" ou "encadeamento de métodos".
• isso não é Java "padrão", embora você o veja mais hoje em dia (funciona muito bem no jQuery)
• viola a especificação do JavaBean e, portanto, rompe com várias ferramentas e bibliotecas, especialmente os construtores JSP e Spring.
• isso pode impedir algumas otimizações que a JVM normalmente faria
• algumas pessoas acham que ele limpa o código, outras acham "horrível"

Alguns outros pontos não mencionados:

• Isso viola o princípio de que cada função deve fazer uma (e apenas uma) coisa. Você pode ou não acreditar nisso, mas em Java eu ​​acredito que funciona bem.

• Os IDEs não vão gerá-los para você (por padrão).

• Finalmente, aqui está um ponto de dados do mundo real. Eu tive problemas ao usar uma biblioteca criada assim. O construtor de consultas do Hibernate é um exemplo disso em uma biblioteca existente. Como os métodos set * da consulta estão retornando consultas, é impossível saber apenas olhando a assinatura como usá-la. Por exemplo:

  Query setWhatever(String what);

• Isso introduz uma ambiguidade: o método modifica o objeto atual (seu padrão) ou, talvez, a consulta seja realmente imutável (um padrão muito popular e valioso) e o método está retornando um novo. Isso apenas torna a biblioteca mais difícil de usar e muitos programadores não exploram esse recurso. Se os setters fossem setters, seria mais claro como usá-lo.

Eu prefiro usar métodos 'with' para isso:

public String getFoo() { return foo; }
public void setFoo(String foo) { this.foo = foo; }
public Employee withFoo(String foo) {
  setFoo(foo);
  return this;
}

Portanto:

list.add(new Employee().withName("Jack Sparrow")
                       .withId(1)
                       .withFoo("bacon!"));

Aviso : essa withXsintaxe é comumente usada para fornecer "setters" para objetos imutáveis; portanto, os chamadores desses métodos podem esperar razoavelmente que eles criem novos objetos em vez de mutarem a instância existente. Talvez uma redação mais razoável seja algo como:

list.add(new Employee().chainsetName("Jack Sparrow")
                       .chainsetId(1)
                       .chainsetFoo("bacon!"));

Com a convenção de nomenclatura chainsetXyz (), praticamente todos devem estar felizes.

Se você não deseja retornar 'this'do configurador, mas não deseja usar a segunda opção, pode usar a seguinte sintaxe para definir propriedades:

list.add(new Employee()
{{
    setName("Jack Sparrow");
    setId(1);
    setFoo("bacon!");
}});

Como um aparte, acho que é um pouco mais limpo em C #:

list.Add(new Employee() {
    Name = "Jack Sparrow",
    Id = 1,
    Foo = "bacon!"
});

Ele não apenas quebra a convenção de getters / setters, como também quebra a estrutura de referência do método Java 8. MyClass::setMyValueé um BiConsumer<MyClass,MyValue>e myInstance::setMyValueé um Consumer<MyValue>. Se você retornar seu setter this, ele não será mais uma instância válida Consumer<MyValue>, mas sim um Function<MyValue,MyClass>, e fará com que qualquer coisa que use referências de método a esses setters (supondo que sejam métodos nulos) seja interrompida.

Eu não sei Java, mas eu fiz isso em C ++. Outras pessoas disseram que torna as linhas muito longas e muito difíceis de ler, mas eu já fiz isso assim muitas vezes:

list.add(new Employee()
    .setName("Jack Sparrow")
    .setId(1)
    .setFoo("bacon!"));

Isto é ainda melhor:

list.add(
    new Employee("Jack Sparrow")
    .Id(1)
    .foo("bacon!"));

pelo menos eu acho. Mas não hesite em me votar e me chamar de péssimo programador, se desejar. E não sei se você pode fazer isso em Java.

Este esquema (trocadilhos), chamado de 'interface fluente', está se tornando bastante popular agora. É aceitável, mas não é realmente minha xícara de chá.

Como ele não retorna nulo, não é mais um configurador de propriedade JavaBean válido. Isso pode importar se você é uma das sete pessoas no mundo usando ferramentas visuais "Bean Builder" ou uma das 17 usando elementos JSP-bean-setProperty.

Pelo menos em teoria , isso pode danificar os mecanismos de otimização da JVM, definindo dependências falsas entre chamadas.

Supõe-se que seja açúcar sintático, mas de fato pode criar efeitos colaterais na máquina virtual do Java 43 super-inteligente.

É por isso que eu voto não, não use.

Não é uma prática ruim. Mas não é compatível com o JavaBeans Spec .

E há muita especificação depende desses acessadores padrão.

Você sempre pode fazê-los coexistir um com o outro.

public class Some {
    public String getValue() { // JavaBeans
        return value;
    }
    public void setValue(final String value) { // JavaBeans
        this.value = value;
    }
    public String value() { // simple
        return getValue();
    }
    public Some value(final String value) { // fluent/chaining
        setValue(value);
        return this;
    }
    private String value;
}

Agora podemos usá-los juntos.

new Some().value("some").getValue();

Aí vem outra versão para objeto imutável.

public class Some {

    public static class Builder {

        public Some build() { return new Some(value); }

        public Builder value(final String value) {
            this.value = value;
            return this;
        }

        private String value;
    }

    private Some(final String value) {
        super();
        this.value = value;
    }

    public String getValue() { return value; }

    public String value() { return getValue();}

    private final String value;
}

Agora podemos fazer isso.

new Some.Builder().value("value").build().getValue();

Se você usar a mesma convenção em todo o aplicativo, tudo bem.

Por outro lado, se parte existente do seu aplicativo usa a convenção padrão, eu o manteria e adicionaria construtores a classes mais complicadas

public class NutritionalFacts {
    private final int sodium;
    private final int fat;
    private final int carbo;

    public int getSodium(){
        return sodium;
    }

    public int getfat(){
        return fat;
    }

    public int getCarbo(){
        return carbo;
    }

    public static class Builder {
        private int sodium;
        private int fat;
        private int carbo;

        public Builder sodium(int s) {
            this.sodium = s;
            return this;
        }

        public Builder fat(int f) {
            this.fat = f;
            return this;
        }

        public Builder carbo(int c) {
            this.carbo = c;
            return this;
        }

        public NutritionalFacts build() {
            return new NutritionalFacts(this);
        }
    }

    private NutritionalFacts(Builder b) {
        this.sodium = b.sodium;
        this.fat = b.fat;
        this.carbo = b.carbo;
    }
}

Paulo Abrantes oferece outra maneira de tornar os setters JavaBean fluentes: defina uma classe de construtor interno para cada JavaBean. Se você estiver usando ferramentas que ficam confusas com setters que retornam valores, o padrão de Paulo pode ajudar.

Sou a favor de setters terem retornos "this". Eu não me importo se não é compatível com feijão. Para mim, se não há problema em ter a expressão / instrução "=", então os configuradores que retornam valores estão corretos.

Eu preferia essa abordagem, mas decidi contra.

Razões:

• Legibilidade. Torna o código mais legível para cada setFoo () em uma linha separada. Você geralmente lê o código muitas, muitas vezes mais do que a única vez em que o escreve.
• Efeito colateral: setFoo () deve apenas definir o campo foo, nada mais. Retornando isso é um extra "O que foi isso".

O padrão do Builder que vi não usa a convenção setFoo (foo) .setBar (bar), mas mais foo (foo) .bar (bar). Talvez por exatamente essas razões.

É, como sempre, uma questão de gosto. Eu apenas gosto da abordagem "menos surpresas".

Esse padrão específico é chamado de encadeamento de métodos. Link da Wikipedia , isso tem mais explicações e exemplos de como é feito em várias linguagens de programação.

PS: Apenas pensei em deixá-lo aqui, já que eu estava procurando pelo nome específico.

À primeira vista: "Medonho!".

Pensando melhor

list.add(new Employee().setName("Jack Sparrow").setId(1).setFoo("bacon!"));

é realmente menos propenso a erros do que

Employee anEmployee = new Employee();
anEmployee.setName("xxx");
...
list.add(anEmployee);

Tão interessante. Adicionando ideia à maleta de ferramentas ...

Sim, acho que é uma boa ideia.

Se eu pudesse adicionar algo, e esse problema:

class People
{
    private String name;
    public People setName(String name)
    {
        this.name = name;
        return this;
    }
}

class Friend extends People
{
    private String nickName;
    public Friend setNickName(String nickName)
    {
        this.nickName = nickName;
        return this;
    }
}

Isso funcionará:

new Friend().setNickName("Bart").setName("Barthelemy");

Isso não será aceito pelo Eclipse! :

new Friend().setName("Barthelemy").setNickName("Bart");

Isso ocorre porque setName () retorna um povo e não um amigo, e não há PeoplesetNickName.

Como poderíamos escrever setters para retornar a classe SELF em vez do nome da classe?

Algo assim seria bom (se a palavra-chave SELF existir). Existe mesmo assim?

class People
{
    private String name;
    public SELF setName(String name)
    {
        this.name = name;
        return this;
    }
}

Em geral, é uma boa prática, mas pode ser necessário que as funções do tipo set usem o tipo booleano para determinar se a operação foi concluída com êxito ou não, essa também é uma maneira. Em geral, não há dogma para dizer que isso é bom ou de cama, vem da situação, é claro.

Da declaração

list.add(new Employee().setName("Jack Sparrow").setId(1).setFoo("bacon!"));

eu estou vendo duas coisas

1) Declaração sem sentido. 2) Falta de legibilidade.

Isso pode ser menos legível

list.add(new Employee().setName("Jack Sparrow").setId(1).setFoo("bacon!")); 

ou isto

list.add(new Employee()
          .setName("Jack Sparrow")
          .setId(1)
          .setFoo("bacon!")); 

Isso é muito mais legível do que:

Employee employee = new Employee();
employee.setName("Jack Sparrow")
employee.setId(1)
employee.setFoo("bacon!")); 
list.add(employee); 

Faço meus setters há um bom tempo e o único problema real é com bibliotecas que atendem aos estritos getPropertyDescriptors para obter os acessadores de bean / escritor do bean. Nesses casos, seu "bean" java não terá os gravadores que você esperaria.

Por exemplo, eu não testei com certeza, mas não ficaria surpreso que Jackson não os reconheça como setters ao criar objetos java a partir do json / maps. Espero estar errado neste (testarei em breve).

De fato, estou desenvolvendo um ORM centralizado em SQL leve e preciso adicionar algum código além de getPropertyDescriptors a setters reconhecidos que retornem isso.

Resposta há muito tempo, mas meus dois centavos ... Está tudo bem. Eu gostaria que essa interface fluente fosse usada com mais frequência.

Repetir a variável 'factory' não adiciona mais informações abaixo:

ProxyFactory factory = new ProxyFactory();
factory.setSuperclass(Foo.class);
factory.setFilter(new MethodFilter() { ...

Isso é mais limpo, imho:

ProxyFactory factory = new ProxyFactory()
.setSuperclass(Properties.class);
.setFilter(new MethodFilter() { ...

Obviamente, como uma das respostas já mencionadas, a API Java teria que ser ajustada para fazer isso corretamente em algumas situações, como herança e ferramentas.

É melhor usar outras construções de idioma, se disponíveis. Por exemplo, em Kotlin, você usaria com , aplicar , ou deixe . Se você usar essa abordagem, não precisará realmente retornar uma instância do seu setter.

Essa abordagem permite que seu código de cliente seja:

• Indiferente ao tipo de retorno
• Mais fácil de manter
• Evite efeitos colaterais do compilador

Aqui estão alguns exemplos.

val employee = Employee().apply {
   name = "Jack Sparrow"
   id = 1
   foo = "bacon"
}


val employee = Employee()
with(employee) {
   name = "Jack Sparrow"
   id = 1
   foo = "bacon"
}


val employee = Employee()
employee.let {
   it.name = "Jack Sparrow"
   it.id = 1
   it.foo = "bacon"
}

Se estou escrevendo uma API, uso "return this" para definir valores que serão definidos apenas uma vez. Se eu tiver outros valores que o usuário possa alterar, use um configurador de nulo padrão.

No entanto, é realmente uma questão de preferência e, em minha opinião, os setters de encadeamento parecem bem legais.

Eu concordo com todos os pôsteres afirmando que isso quebra as especificações do JavaBeans. Há razões para preservar isso, mas também sinto que o uso desse Padrão do Construtor (que foi mencionado) tem seu lugar; contanto que não seja usado em todos os lugares, deve ser aceitável. "It's Place", para mim, é onde o ponto final é uma chamada para um método "build ()".

Existem outras maneiras de definir todas essas coisas, é claro, mas a vantagem aqui é que ela evita 1) construtores públicos de muitos parâmetros e 2) objetos parcialmente especificados. Aqui, você faz o construtor coletar o que é necessário e depois chamar "build ()" no final, o que pode garantir que um objeto parcialmente especificado não seja construído, já que essa operação pode ter menos visibilidade que o público. A alternativa seria "objetos de parâmetro", mas esse IMHO apenas empurra o problema de volta a um nível.

Não gosto de construtores de muitos parâmetros porque eles tornam mais provável a passagem de muitos argumentos do mesmo tipo, o que pode facilitar a transmissão de argumentos errados para parâmetros. Não gosto de usar muitos setters porque o objeto pode ser usado antes de ser totalmente configurado. Além disso, a noção de ter valores padrão baseados em escolhas anteriores é melhor servida com o método "build ()".

Em suma, acho que é uma boa prática, se usada corretamente.

Mau hábito: um setter define um getter

que tal declarar explicitamente um método, que faz isso por U

setPropertyFromParams(array $hashParamList) { ... }