Java, wie man benutzerdefinierte Variablen verwaltet

Question

Ich entwickle eine Software, in der ich dem Benutzer erlauben möchte, seine eigenen Variablen zu erstellen und zu verwalten. Ich möchte dem Benutzer die Möglichkeit geben, Doubles, Integers und Strings zu erstellen und dann manuell ihre Werte festzulegen (all dies geschieht über eine Benutzeroberfläche). Im Moment versuche ich mich für ein Modell zu entscheiden, das all diese benutzerdefinierten Variablen verwaltet.

Mein erster Gedanke war, dass es schön wäre, eine Karte zu haben, die Variablen durch ihren Namen und verwenden Sie einen „one-size-fits-all“ ‚Variable‘ Klasse ...

Map<String, Variable> myVars; 

I holt gedacht, um die Variable Klasse so etwas wie dies zu definieren ...

public class Variable<T> 
{ 

private T value; 

public void setValue(T value) 
{ 
    this.value = value; 
} 

public T getValue() 
{ 
    return value; 
} 

} 

aber ich denke, dieser Ansatz mir erfordert die Karte als Map<String, Variable<T> > zu definieren, aber ich möchte nicht einen einzigen Typ T für die gesamte Karte wählen, aber erlauben Sie der Karte, eine Kombination zu enthalten von ganzen Zahlen, Doppeln und Strings.

Ein zweiter Gedanke war, eine Container-Klasse zu erstellen, die drei verschiedene Maps verwaltet, jeweils eine für Strings, Integers und Doubles. Die drei Karten sind vom Anrufer isoliert, und der Anrufer muss lediglich einen String (den Variablennamen) an einen Getter liefern, und der Container würde den Wert der Variablen von der entsprechenden Karte erhalten. Der Container könnte sich auch um Probleme wie die Beibehaltung der Eindeutigkeit von Schlüsseln auf allen drei Karten kümmern.

Ein Stub etwas könnte wie folgt aussehen ...

public class VariableContainer { 

private Map<String, Double> doubleVars = new HashMap(); 
private Map<String, String> stringVars = new HashMap(); 
private Map<String, Integer> intVars = new HashMap(); 

public Object get(String varName) 
{ 
    if (doubleVars.containsKey(varName)) { 
     return doubleVars.get(varName); 
    } else if (stringVars.containsKey(varName)) { 
     return stringVars.get(varName); 
    } else if (intVars.containsKey(varName)) { 
     return intVars.get(varName) 
    } else { 
     // varName not found 
    } 
} 
} 

jedoch jetzt der Aufrufer der get Methode muss Inspektion tun instanceof, um festzustellen, welche Art von Objekt zurückgegeben wurde.

In diesem Sinne, wenn Überprüfung seitens des Anrufers erforderlich ist, vielleicht wäre es am einfachsten über eine abstrakte Variable Klasse oder eine Container-Klasse nur Stick mit

Map<String, Object> 

und vergessen.

Vielleicht noch eine weitere Option ist es, eine Wildcard zurückzukehren, wie in der Antwort auf diese Frage beschrieben: Avoiding Returning Wildcard Types

Hat jemand irgendwelche Gedanken oder Erfahrungen auf einem guten Weg, dies zu nähern? Danke für jede Eingabe.

Answer 1

OK folgende scheint zu funktionieren:

public class Variable<T> 
{ 

    private T value; 

    public void setValue(T value) 
    { 
     this.value = value; 
    } 

    public T getValue() 
    { 
     return value; 
    } 

    public String toString() 
    { 
     return value.toString(); 
    } 
} 

Map<String, Variable<?>> myVars = new HashMap<>(); 

Variable<Double> v1 = new Variable<>(); 
v1.setValue(3.0); 

Variable<String> v2 = new Variable<>(); 
v2.setValue("hello"); 

myVars.put("doubleVar", v1); 
myVars.put("stringVar", v2); 

System.out.println("doubleVar = " + myVars.get("doubleVar")); 
System.out.println("stringVar = " + myVars.get("stringVar")); 

Die obigen Drucke:

doubleVar = 3,0

stringVar = hallo

Answer 2

Sie können uns Übergeordnete Funktion.

class Container{ 
    // get(); 
} 
class StringContiner extends Container{ 
    // get() return string; 
} 
class IntContainer extends Container{ 
    // get() return return int; 
} 
class DoubleContainer extends Container{ 
    // get() return double; 
}