it-swarm.it

(no) Proprietà in Java?

Quindi, fino a poco tempo fa, mi sono tenuto un Java n00b, e la mia prima vera esposizione ha provocato uno shock minore: Java non ha proprietà in stile C #!

Ok, posso conviverci. Tuttavia, posso anche giurare che ho visto il codice getter/setter di proprietà in Java in un codice base, ma non riesco a ricordare dove. Come è stato realizzato? C'è un'estensione linguistica per questo? È collegato a NetBeans o qualcosa del genere?

53
Ishmaeel

Esiste un modello "standard" per getter e setter in Java, chiamato Proprietà Bean . Fondamentalmente ogni metodo che inizia con get, senza argomenti e restituendo un valore, è un getter di proprietà per una proprietà chiamata come il resto del nome del metodo (con una lettera iniziale minuscola). Allo stesso modo set crea un setter di un metodo void con un singolo argomento.

Per esempio:

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

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

La maggior parte degli IDE Java generano questi metodi per te se li chiedi (in Eclipse è semplice come spostare il cursore su un campo e premere ctrl-1, quindi selezionare l'opzione dall'elenco).

Per quel che vale, per leggibilità puoi usare is e has al posto di get anche per le proprietà di tipo booleano, come in:

public boolean isAwesome();

public boolean hasAwesomeStuff();
61
Calum

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: 

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.

6
Cheekysoft

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.

6
Hank Gay
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/

6
dantuch

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

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.
3
th1rdey3

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.

3
Bill Michell

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
}
2
Mark Embling

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

1

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.

1
TK.

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
1
Patrick PIGNOL

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,

0
levteck