(no) Proprietà in Java?

Sono sorpreso che nessuno menzionasse project lombok

Sì, attualmente non ci sono proprietà in Java. Ci sono anche altre caratteristiche mancanti.
Ma fortunatamente abbiamo project lombok che sta cercando di migliorare la situazione. Sta diventando sempre più popolare ogni giorno.

Quindi, se stai usando lombok:

@Getter @Setter int awesomeInteger = 5;

Questo codice genererà anche getAwesomeInteger e setAwesomeInteger. Quindi è abbastanza simile alle proprietà auto-implementate di C # .

Puoi avere maggiori informazioni su getter e setter di lombok qui .
Dovresti assolutamente controllare altre caratteristiche anche . I miei preferiti sono: 

• val
• NoArgsConstructor, RequiredArgsConstructor, AllArgsConstructor
• Registri!

Lombok è ben integrato con gli IDE, quindi mostrerà metodi generati come se esistessero (suggerimenti, contenuti di classe, dichiarazioni e refactoring).
L'unico problema con lombok è che altri programmatori potrebbero non saperlo. Puoi sempre delombok il codice ma è piuttosto una soluzione alternativa a una soluzione.

"Java Property Support" è stato proposto per Java 7, ma non è riuscito a farlo nella lingua.

Vedi http://tech.puredanger.com/Java7#property per ulteriori collegamenti e informazioni, se interessati.

La convenzione bean è scrivere codice come questo:

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

In alcune delle altre lingue sulla JVM, ad esempio, Groovy, ottieni proprietà sovrascrivibili simili a C #, ad es.

int foo

a cui si accede con un semplice .foo e sfrutta le implementazioni getFoo e setFoo predefinite che è possibile sovrascrivere se necessario.

public class Animal {

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

Questo è qualcosa come proprietà C #. È http://projectlombok.org/

Potrebbe non essere necessario per i prefissi "get" e "set", per renderlo simile alle proprietà, è possibile farlo in questo modo:

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());
    }
}

Da Jeffrey Richter's book CLR via C # : (penso che questi potrebbero essere i motivi per cui le proprietà non vengono ancora aggiunte in Java)

• Un metodo di proprietà può generare un'eccezione; l'accesso al campo non genera mai un'eccezione.
• Una proprietà non può essere passata come parametro out o ref a un metodo; un campo può. 
• Un metodo di proprietà può richiedere molto tempo per essere eseguito; l'accesso al campo termina sempre immediatamente. Un motivo comune per utilizzare le proprietà è eseguire la sincronizzazione dei thread, Che può interrompere il thread per sempre e, pertanto, una proprietà non dovrebbe essere Utilizzata se è richiesta la sincronizzazione dei thread. In questa situazione, è preferibile un metodo . Inoltre, se è possibile accedere alla classe in remoto (ad esempio, la classe è derivata da System.MarshalByRefObject), la chiamata del metodo property sarà molto lenta e Pertanto , un metodo è preferito a una proprietà. A mio parere, le classi derivate da MarshalByRefObject non dovrebbero mai usare proprietà.
• Se chiamato più volte di seguito, un metodo di proprietà può restituire un valore diverso per ogni tempo un campo restituisce lo stesso valore ogni volta. La classe System.DateTime ha una proprietà read__ly Now che restituisce la data e l'ora correnti. Ogni volta che si interroga thisproperty, verrà restituito un valore diverso. Questo è un errore e Microsoft desidera che Possano correggere la classe rendendo Now un metodo invece di una proprietà. Environment 's TickCount property è un altro esempio di questo errore.
• Un metodo di proprietà può causare effetti collaterali osservabili; l'accesso al campo non lo fa mai. In altre parole , Un utente di un tipo dovrebbe essere in grado di impostare varie proprietà definite da un tipo in Qualsiasi ordine che sceglie senza notare alcun comportamento diverso nel tipo.
• Un metodo di proprietà può richiedere memoria aggiuntiva o restituire un riferimento a qualcosa Che non è in realtà parte dello stato dell'oggetto, pertanto la modifica dell'oggetto restituito non ha alcun effetto Sull'oggetto originale; l'interrogazione di un campo restituisce sempre un riferimento a un oggetto che è garantito essere parte dello stato dell'oggetto originale. Lavorare con una proprietà Che restituisce una copia può essere molto confuso per gli sviluppatori e questa caratteristica è spesso Non documentata.

La maggior parte degli IDE per Java genererà automaticamente il codice getter e setter per te, se lo desideri. Esistono diverse convenzioni e un IDE come Eclipse ti consentirà di scegliere quale utilizzare e persino di definire il tuo.

Eclipse include anche il refactoring automatizzato che ti permetterà di avvolgere una proprietà in un getter and setter e modificherà tutto il codice che accede direttamente alla proprietà, per far sì che usi getter e/o setter.

Naturalmente, Eclipse può solo modificare il codice che conosce: qualsiasi dipendenza esterna che potresti avere potrebbe essere compromessa da un tale refactoring.

Anche la mia esperienza in Java non è così alta, quindi chiunque si senta libero di correggermi. Ma AFAIK, la convenzione generale è di scrivere due metodi in questo modo:

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

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

Sto solo rilasciando le annotazioni Java 5/6 e un processore di annotazioni per aiutare questo.

Controlla http://code.google.com/p/javadude/wiki/Annotazioni

La documentazione è un po 'leggera in questo momento, ma il quickref dovrebbe dare l'idea.

Fondamentalmente genera una superclasse con i getter/setter (e molte altre opzioni di generazione del codice).

Potrebbe essere una classe di esempio

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

Sono disponibili molti più campioni e non vi sono dipendenze di runtime nel codice generato.

Mandami una mail se la provi e la trovi utile! -- Scott

Se si utilizza Eclipse, ha la capacità di generare automaticamente il metodo getter e setter per gli attributi interni, può essere uno strumento utile e che fa risparmiare tempo.

Non c'è alcuna parola chiave di proprietà in Java (come si potrebbe trovare in C #) il modo più vicino per avere 1 getter/setter di Word è come fare in 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

Come accennato in precedenza per Eclipse, l'ambiente di sviluppo integrato (IDE) spesso può creare automaticamente metodi di accesso.

Puoi anche farlo usando NetBeans. 

Per creare metodi di accesso per la classe, apri un file di classe, quindi fai clic con il pulsante destro del mouse in qualsiasi punto dell'editor del codice sorgente e scegli il comando di menu Refactor, Encapsulate Fields. Si apre una finestra di dialogo. Fare clic su Seleziona tutto, quindi fare clic su Refactor . Voilà,

In bocca al lupo,