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?
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();
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.
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)
out
o ref
a un metodo; un campo può. 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à.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.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,