(não) Propriedades em Java?

Question

Então, eu mantive deliberadamente um Java n00b até recentemente, e minha primeira exposição real causou um pequeno choque:Java não possui propriedades de estilo C#!

Ok, posso viver com isso.No entanto, também posso jurar que vi código getter/setter de propriedade em Java em uma base de código, mas não consigo lembrar onde.Como isso foi conseguido?Existe uma extensão de idioma para isso?Está relacionado ao NetBeans ou algo assim?

Answer 1

Existe um padrão "padrão" para getters e setters em Java, chamado Propriedades do feijão.Basicamente qualquer método começando com get, sem receber argumentos e retornando um valor, é um getter de propriedade para uma propriedade nomeada como o restante do nome do método (com uma letra inicial minúscula).Da mesma maneira set cria um setter de um método void com um único argumento.

Por exemplo:

// Getter for "awesomeString"
public String getAwesomeString() {
  return awesomeString;
}

// Setter for "awesomeString"
public void setAwesomeString( String awesomeString ) {
  this.awesomeString = awesomeString;
}

A maioria dos IDEs Java irá gerar esses métodos para você se você perguntar (no Eclipse é tão simples quanto mover o cursor para um campo e pressionar ctrl-1 e selecionar a opção na lista).

Pelo que vale, para facilitar a leitura você pode realmente usar is e has no lugar de get também para propriedades do tipo booleano, como em:

public boolean isAwesome();

public boolean hasAwesomeStuff();

Answer 2

Estou surpreso que ninguém tenha mencionado projeto lombok

Sim, atualmente não há propriedades em java.Existem alguns outros recursos ausentes também.
Mas felizmente temos projeto lombok que está tentando melhorar a situação.Também está se tornando cada vez mais popular a cada dia.

Então, se você estiver usando o lombok:

@Getter @Setter int awesomeInteger = 5;

Este código vai gerar getAwesomeInteger e setAwesomeInteger também.Então é bastante semelhante a Propriedades autoimplementadas em C#.

Você pode obter mais informações sobre getters e setters lombok aqui.
Você definitivamente deveria dar uma olhada outras características também.Meus favoritos são:

• valor
• NoArgsConstructor, RequiredArgsConstructor, AllArgsConstructor
• Histórico!

O Lombok está bem integrado com IDEs, então vai mostrar os métodos gerados como se existissem (sugestões, conteúdo da classe, ir para declaração e refatoração).
O único problema com o lombok é que outros programadores podem não saber disso.Você pode sempre delombok o código, mas isso é mais uma solução alternativa do que uma solução.

Answer 3

"Java Property Support" foi proposto para Java 7, mas não foi incluído na linguagem.

Ver http://tech.puredanger.com/java7#property para mais links e informações, se estiver interessado.

Answer 4

A convenção do bean é escrever código como este:

private int foo;
public int getFoo() {
    return foo;
}
public void setFoo(int newFoo) {
    foo = newFoo;
}

Em algumas das outras linguagens na JVM, por exemplo, Groovy, você obtém propriedades substituíveis semelhantes a C#, por exemplo,

int foo

que é acessado com um simples .foo e aproveita a inadimplência getFoo e setFoo implementações que você pode substituir conforme necessário.

Answer 5

public class Animal {

    @Getter @Setter private String name;
    @Getter @Setter private String gender;
    @Getter @Setter private String species;
}

Isso é algo como propriedades C#.Isso é http://projectlombok.org/

Answer 6

Você pode não precisar dos prefixos "get" e "set", para fazer com que pareça mais com propriedades, você pode fazer assim:

public class Person {
    private String firstName = "";
    private Integer age = 0;

    public String firstName() { return firstName; } // getter
    public void firstName(String val) { firstName = val; } // setter

    public Integer age() { return age; } // getter
    public void age(Integer val) { age = val; } //setter

    public static void main(String[] args) {
        Person p = new Person();

        //set
        p.firstName("Lemuel");
        p.age(40);

        //get
        System.out.println(String.format("I'm %s, %d yearsold",
            p.firstName(),
            p.age());
    }
}

Answer 7

A maioria dos IDEs para Java gerará automaticamente código getter e setter para você, se você desejar.Existem várias convenções diferentes, e um IDE como o Eclipse permitirá que você escolha qual delas deseja usar e até mesmo definirá a sua própria.

O Eclipse ainda inclui refatoração automatizada que permitirá agrupar uma propriedade em um getter e setter e modificará todo o código que acessa a propriedade diretamente, para fazê-la usar o getter e/ou setter.

É claro que o Eclipse só pode modificar o código que ele conhece - quaisquer dependências externas que você tenha podem ser quebradas por tal refatoração.

Answer 8

De Jeffrey Richter livro CLR via C#:(Acho que essas podem ser as razões pelas quais as propriedades ainda não são adicionadas em JAVA)

• Um método de propriedade pode lançar uma exceção;o acesso ao campo nunca lança uma exceção.
• Uma propriedade não pode ser passada como out ou ref parâmetro para um método;um campo pode.
• Um método de propriedade pode levar muito tempo para ser executado;O acesso ao campo sempre é concluído imediatamente.Um motivo comum para usar as propriedades é executar a sincronização do encadeamento, que pode interromper o thread para sempre e, portanto, uma propriedade não deve ser usada se a sincronização do encadeamento for necessária.Nessa situação, um método é preferido.Além disso, se sua classe puder ser acessada remotamente (por exemplo, sua classe é derivada deSystem.MarshalByRefObject), chamando o método da propriedade será muito lento e, portanto, um método é preferido a uma propriedade.Na minha opinião, as classes derivadas deMarshalByRefObject nunca deve usar propriedades.
• Se chamado várias vezes seguidas, um método de propriedade poderá retornar um valor diferente a cada vez;um campo retorna o mesmo valor todas as vezes.O System.DateTime classe tem somente leituraNow propriedade que retorna a data e hora atuais.Cada vez que você consultar esta propriedade, ela retornará um valor diferente.Isso é um erro, e a Microsoft deseja que eles possam consertar a classe, fazendo agora um método em vez de uma propriedade. EnvironmentéTickCount propriedade é outro exemplo desse erro.
• Um método de propriedade pode causar efeitos colaterais observáveis;o acesso ao campo nunca acontece.Em outras palavras, um usuário de um tipo deve ser capaz de definir várias propriedades definidas por um tipo em qualquer ordem que ele escolher sem perceber nenhum comportamento diferente no tipo.
• Um método de propriedade pode exigir memória adicional ou retornar uma referência a algo que na verdade não faz parte do estado do objeto; portanto, modificar o objeto retornado não tem efeito no objeto original;A consulta de um campo sempre retorna uma referência a um objeto que é garantido para fazer parte do estado do objeto original.Trabalhar com uma propriedade que retorna uma cópia pode ser muito confusa para os desenvolvedores, e essa característica frequentemente não está documentada.

Answer 9

Minha experiência com Java também não é tão boa, então qualquer um fique à vontade para me corrigir.Mas AFAIK, a convenção geral é escrever dois métodos assim:

public string getMyString() {
    // return it here
}

public void setMyString(string myString) {
    // set it here
}

Answer 10

Se você estiver usando o Eclipse, ele terá a capacidade de gerar automaticamente os métodos getter e setter para os atributos internos, podendo ser uma ferramenta útil e que economiza tempo.

Answer 11

Estou apenas lançando anotações Java 5/6 e um processador de anotações para ajudar nisso.

Confira http://code.google.com/p/javadude/wiki/Annotations

A documentação está um pouco leve no momento, mas o quickref deve transmitir a ideia.

Basicamente ele gera uma superclasse com os getters/setters (e muitas outras opções de geração de código).

Uma classe de amostra pode parecer

@Bean(properties = {
    @Property(name="name", bound=true),
    @Property(name="age,type=int.class)
})
public class Person extends PersonGen {
}

Há muito mais exemplos disponíveis e não há dependências de tempo de execução no código gerado.

Envie-me um e-mail se você experimentar e achar útil!--Scott

Answer 12

Não há palavra-chave de propriedade em Java (como você pode encontrar em C#). A maneira mais próxima de ter um getter/setter de palavra é fazer como em C++:

public class MyClass
{
    private int aMyAttribute;
    public MyClass()
    {
        this.aMyAttribute = 0;
    }
    public void mMyAttribute(int pMyAttributeParameter)
    {
        this.aMyAttribute = pMyAttributeParameter;
    }
    public int mMyAttribute()
    {
        return this.aMyAttribute;
    }
}
//usage :
int vIndex = 1;
MyClass vClass = new MyClass();
vClass.mMyAttribute(vIndex);
vIndex = 0;
vIndex = vClass.mMyAttribute();
// vIndex == 1

Answer 13

Conforme mencionado anteriormente para o Eclipse, o ambiente de desenvolvimento integrado (IDE) geralmente pode criar métodos acessadores automaticamente.

Você também pode fazer isso usando o NetBeans.

Para criar métodos acessadores para sua classe, abra um arquivo de classe, clique com o botão direito em qualquer lugar no editor de código-fonte e escolha o comando de menu Refactor, Encapsulate Fields.Uma caixa de diálogo é aberta.Clique em Selecionar tudo e em Refatorar.Voilà,

Boa sorte,