it-swarm-pt.tech

(não) Propriedades em Java?

Então, eu me mantive intencionalmente um Java n00b até recentemente, e minha primeira exposição real trouxe um choque menor: o Java não tem propriedades de estilo C #!

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

53
Ishmaeel

Existe um padrão "padrão" para getters e setters em Java, chamado Bean properties . Basicamente, qualquer método que comece com get, não tendo argumentos e retornando um valor, é um getter de propriedade para uma propriedade nomeada como o resto do nome do método (com uma letra inicial em minúsculas). Da mesma forma, 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 gerará esses métodos para você se você perguntar a eles (no Eclipse é tão simples quanto mover o cursor para um campo e pressionar ctrl-1 e, em seguida, selecionar a opção na lista).

Por que vale a pena, para legibilidade, você pode realmente usar is e has no lugar de get para propriedades de tipo booleano também, como em:

public boolean isAwesome();

public boolean hasAwesomeStuff();
61
Calum

Eu estou surpreso que ninguém mencionou 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. Ele também está ficando 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. Portanto, é bastante semelhante às propriedades auto-implementadas de C # .

Você pode obter mais informações sobre os getters e setters do lombok here .
Você deve definitivamente verificar outros recursos também. Meus favoritos são: 

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

31
Aleks-Daniel Jakimenko-A.

O "Java Property Support" foi proposto para o Java 7, mas não entrou na linguagem.

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

6
Cheekysoft

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 alguns dos outros idiomas na JVM, por exemplo, Groovy, você obtém propriedades substituíveis semelhantes a C #, por exemplo,

int foo

que é acessado com um .foo simples e aproveita as implementações padrão getFoo e setFoo que você pode substituir conforme necessário.

6
Hank Gay
public class Animal {

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

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

6
dantuch

Você pode não precisar de prefixos "get" e "set", para parecer 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());
    }
}
4
LEMUEL ADANE

De Jeffrey Richter / CLR via C # : (acho que estas 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 de campo nunca lança uma exceção.
  • Uma propriedade não pode ser passada como um parâmetro out ou ref para um método; um campo pode. 
  • Um método de propriedade pode levar muito tempo para ser executado; o acesso de campo sempre completa imediatamente. Um motivo comum para usar propriedades é executar a sincronização de encadeamentos, , Que pode interromper o encadeamento para sempre e, portanto, uma propriedade não deve ser usada Se a sincronização de encadeamentos 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 de System.MarshalByRefObject), chamar o método de propriedade será muito lento e portanto, um método é preferido a uma propriedade. Na minha opinião, as classes derivadas de MarshalByRefObject nunca devem usar propriedades.
  • Se chamado várias vezes em uma linha, um método de propriedade pode retornar um valor diferente a cada Hora; um campo retorna o mesmo valor a cada vez. A classe System.DateTime tem uma propriedade readonly Now que retorna a data e a hora atuais. Toda vez que você consultar essa 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. A propriedade [Environment_ TickCount é outro exemplo desse erro.
  • Um método de propriedade pode causar efeitos colaterais observáveis; acesso de campo nunca faz. 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 qualquer comportamento diferente no tipo.
  • Um método de propriedade pode exigir memória adicional ou retornar uma referência a algo Que não faz parte do estado do objeto, portanto, modificar o objeto retornado não tem efeito No objeto original; Consultar um campo sempre retorna uma referência a um objeto garantido como parte do estado do objeto original. Trabalhar com uma propriedade Que retorna uma cópia pode ser muito confuso para os desenvolvedores, e essa característica é freqüentemente Não documentada.
3
th1rdey3

A maioria dos IDEs para Java gerará automaticamente o código getter e setter para você, se você desejar. Existem diversas convenções diferentes, e um IDE como o Eclipse permitirá que você escolha qual delas você quer usar, e até mesmo permite que você defina o seu próprio.

O Eclipse inclui até a refatoração automatizada que permitirá que você envolva uma propriedade em um getter e setter e modificará todo o código que acessa a propriedade diretamente, para fazer com que ela use 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 poderiam ser quebradas por tal refatoração.

3
Bill Michell

Minha experiência em Java também não é tão alta, então qualquer um fica à 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
}
2
Mark Embling

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 agora, 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 amostras disponíveis e não há dependências de tempo de execução no código gerado.

Envie-me um e-mail se você experimentá-lo e encontrá-lo útil! - Scott

1
Scott Stanchfield

Se você estiver usando o Eclipse, então ele tem os recursos para gerar automaticamente o método getter e setter para os atributos internos, pode ser uma ferramenta útil e que economiza tempo.

1
TK.

Não há nenhuma palavra-chave de propriedade em Java (como você poderia encontrá-lo em C #) a maneira mais próxima de ter 1 get/setter de Word é 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
1
Patrick PIGNOL

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

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

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

Boa sorte,

0
levteck