Risposte:
Non so cosa vuoi fare, ma è così che ho tradotto il tuo codice di esempio ...
package test;
/**
* @author The Elite Gentleman
*
*/
public enum Strings {
STRING_ONE("ONE"),
STRING_TWO("TWO")
;
private final String text;
/**
* @param text
*/
Strings(final String text) {
this.text = text;
}
/* (non-Javadoc)
* @see java.lang.Enum#toString()
*/
@Override
public String toString() {
return text;
}
}
In alternativa, puoi creare un metodo getter per text
.
Ora puoi farlo Strings.STRING_ONE.toString();
final
sarebbe il migliore.
new
come lo è il costruttore private
. In sostanza, la creazione di oggetti è vietata e final
non è realmente necessaria in questo caso.
setText(String)
enum e questo può scatenare l'inferno :) final
tipo di documenti il tuo intento che è una costante con il supporto del compilatore. Se dovessi usare le String
costanti non lo dichiareresti public static String
, giusto?
Valori stringa personalizzati per Enum
da http://javahowto.blogspot.com/2006/10/custom-string-values-for-enum.html
Il valore di stringa predefinito per java enum è il suo valore nominale o il nome dell'elemento. Tuttavia, è possibile personalizzare il valore della stringa sovrascrivendo il metodo toString (). Per esempio,
public enum MyType {
ONE {
public String toString() {
return "this is one";
}
},
TWO {
public String toString() {
return "this is two";
}
}
}
L'esecuzione del seguente codice di test produrrà questo:
public class EnumTest {
public static void main(String[] args) {
System.out.println(MyType.ONE);
System.out.println(MyType.TWO);
}
}
this is one
this is two
bin
directory: EnumTest $ MyType.class EnumTest $ MyType $ 1.class EnumTest $ MyType $ 2.class, che si sommano reale veloce. Meglio farlo come la risposta prevista, passando valori al costruttore enum. In realtà non sono d'accordo con l'override toString()
; Credo che sia meglio usare un getter esplicito come getKey()
poiché l'override toString()
può essere inaspettato da un altro utente dell'enum.
Usa il suo name()
metodo:
public class Main {
public static void main(String[] args) throws Exception {
System.out.println(Strings.ONE.name());
}
}
enum Strings {
ONE, TWO, THREE
}
rese ONE
.
Strings.STRING_ONE.name()
produce "STRING_ONE", non "ONE". Questa semplicemente non è una buona risposta. Non puoi avere una stringa che non sia un identificatore Java valido, ecc.
name()
può essere influenzato da un programma di offuscamento. Mi sono imbattuto in un problema simile qualche tempo fa. Ad esempio, con Proguard è necessario aggirare il problema. Vedere Elaborazione delle classi di enumerazione
Impostare il nome enum in modo che corrisponda alla stringa desiderata o, più in generale, è possibile associare attributi arbitrari ai valori enum:
enum Strings {
STRING_ONE("ONE"), STRING_TWO("TWO");
private final String stringValue;
Strings(final String s) { stringValue = s; }
public String toString() { return stringValue; }
// further methods, attributes, etc.
}
È importante avere le costanti in alto e i metodi / attributi in basso.
A seconda di cosa intendi per "usali come stringhe", potresti non voler usare un enum qui. Nella maggior parte dei casi, la soluzione proposta da The Elite Gentleman ti permetterà di usarli attraverso i loro metodi toString, ad esempio in System.out.println(STRING_ONE)
o String s = "Hello "+STRING_TWO
, ma quando hai davvero bisogno di stringhe (ad esempio STRING_ONE.toLowerCase()
), potresti preferire definirli come costanti:
public interface Strings{
public static final String STRING_ONE = "ONE";
public static final String STRING_TWO = "TWO";
}
toLowerCase()
mia soluzione, possono andare Strings.STRING_TWO.toString().toLowerCase()
.
interface
al posto di una final
classe con private
costruttore. È una pratica scoraggiata.
Puoi usarlo per la stringa Enum
public enum EnumTest {
NAME_ONE("Name 1"),
NAME_TWO("Name 2");
private final String name;
/**
* @param name
*/
private EnumTest(final String name) {
this.name = name;
}
public String getName() {
return name;
}
}
E chiama dal metodo principale
public class Test {
public static void main (String args[]){
System.out.println(EnumTest.NAME_ONE.getName());
System.out.println(EnumTest.NAME_TWO.getName());
}
}
Se non si desidera utilizzare i costruttori e si desidera avere un nome speciale per il metodo, provare questo:
public enum MyType {
ONE {
public String getDescription() {
return "this is one";
}
},
TWO {
public String getDescription() {
return "this is two";
}
};
public abstract String getDescription();
}
Sospetto che questa sia la soluzione più rapida . Non è necessario utilizzare le variabili final .
private String text
dovrebbe essere definitivo.