Vergleich Enum-Einträge - Java

Question

Lassen Sie uns sagen, dass ich ein paar Maschinen haben:

//Test code of course. 
public class Start{ 
    public static void main(String args[]){ 
    System.out.println(Machine.COFFEE_GRINDER.getCatalogId()); 
    System.out.println(Machine.COFFEE_MACHINE.isOfType(Machine.BASIC_MACHINE)); 
    //The above should be true. 
    } 

    private enum Machine { 
    BASIC_MACHINE (-1), 
    BEVERAGE (-1), 
    COFFEE(-1), 
    COFFEE_GRINDER (5), 
    COFFEE_MACHINE (6), 
    GARDEN (-1), 
    LAWN_MOWER (28); 

    private final int catalogId; 

    public int getCatalogId(){ 
     return catalogId; 
    } 

    public boolean isOfType(Machine to){ 
     return this == to; 
    } 

    Machine (int catalogId) { 
     this.catalogId = catalogId; 
    } 
    } 
} 

Im Beispiel oben dort Maschinen sind, wie sie in einem Katalog erscheinen würde und ID-Nummern, die mit ihnen haben. Es gibt auch Abschnitte und Abschnitte von Abschnitten. Eine BEVERAGE-Maschine ist also immer noch eine BASIC_MACHINE. Eine KAFFEE-Maschine ist immer noch eine GETRÄNKE-Maschine.

Einige Funktionen in einem Programm müssen, bevor sie ihre Funktion ausführen, überprüfen, ob es sich bei der Maschine tatsächlich um ein BEFORE-Gerät handelt. Sowohl COFFEE_GRINDERs als auch COFFEE_MACHINEs aus dem Katalog würden ausgecheckt und die Funktion sollte durchlaufen werden.

Das Verhalten, das ich suche, ist vergleichbar mit instanceof oder die Vererbung von abstrakten Klassen. Wie auch immer, ein COFFEE_MACHINE ist eigentlich eine Art BASIC_MACHINE und ich möchte das überprüfen.

So:

Machine.COFFEE_MACHINE isa Machine.COFFEE 
Machine.BEVERAGE isa MACHINE.BASIC_MACHINE 
Machine.LAWN_MOWER isa Machine.GARDEN == Machine.BASIC_MACHINE 
Machine.COFFEE_MACHINE isnota Machine.COFFEE_GRINDER 
Machine.LAWN_MOWER isnota Machine.COFFEE 

Answer 1

Eine mögliche Lösung ist eine Vererbung Rückrufe und eine gespeicherte geordneter Typ zu imitieren. Ich bin gespannt, ob das der beste Weg ist.

dies umgesetzt würde wie folgt aussehen:

//Test code of course. 
public class Start{ 
    public static void main(String args[]){ 
    System.out.println(Machine.COFFEE_GRINDER.getCatalogId()); 
    System.out.println(Machine.COFFEE_MACHINE.isOfType(Machine.BASIC_MACHINE)); //Should be true. 
    } 

    private enum Machine { 
    BASIC_MACHINE (-1), 
    BEVERAGE (-1, BASIC_MACHINE), 
    COFFEE(-1, BEVERAGE), 
    COFFEE_GRINDER (5, COFFEE), 
    COFFEE_MACHINE (6, COFFEE), 
    GARDEN (-1, BASIC_MACHINE), 
    LAWN_MOWER (28, GARDEN); 

    private int catalogId; 
    private Machine superMachine; 

    public int getCatalogId(){ 
     return catalogId; 
    } 

    public Machine getSuperMachine(){ 
     return superMachine; 
    } 

    //With callback to superMachine (if present) 
    public boolean isOfType(Machine to){ 
     return this == to || (getSuperMachine() != null && getSuperMachine().isOfType(to)); 
    } 

    Machine (int catalogId) { 
     this.catalogId = catalogId; 
    } 

    Machine (int catalogId, Machine superMachine) { 
     this(catalogId); 
     this.superMachine = superMachine; 
    } 
    } 
} 

Answer 2

Wenn ich Ihr Ziel richtig verstehen, wollen Sie ein Netzwerk von Beziehungen zwischen den enum Konstanten auszudrücken. Bedenken Sie, dass die Vererbung nicht notwendigerweise mit der Beziehung übereinstimmt, die Sie ausdrücken möchten. Vererbung Modelle eine is-a Beziehung zwischen Typen; Sie möchten eine Beziehung zwischen Instanzen. Vielleicht verwenden Sie eine andere Terminologie als "Super/Erben", auch wie "Eigentümer-Besitzer". Sie könnten einen Zeiger auf eine owner Instanz in jeder Konstante einbetten und eine azyklische gerichtete Graphenstruktur in einem statischen Initialisierer und dem Konstruktor erstellen.

public enum NetworkedMachine 
{ 
BASIC_MACHINE(-1, null), 
BEVERAGE(-1, BASIC_MACHINE), 
COFFEE(-1, BASIC_MACHINE), 
COFFEE_GRINDER(5, COFFEE), 
COFFEE_MACHINE(6, COFFEE), 
GARDEN(-1, BASIC_MACHINE), 
LAWN_MOWER(28, GARDEN), 
; 

static final Map<NetworkedMachine, Set<NetworkedMachine>> owners; 
static { 
    Map<NetworkedMachine, Set<NetworkedMachine>> ownership = new HashMap<>(); 
    for (NetworkedMachine machine : values()) { 
    ownership.put(machine, new HashSet<>()); 
    } 
    for (NetworkedMachine machine : values()) { 
    if (machine.owner != null) { 
     ownership.get(machine.owner).add(machine); 
    } 
    } 
    for (NetworkedMachine machine : values()) { 
    Set<NetworkedMachine> owns = ownership.get(machine); 
    ownership.put(machine, Collections.unmodifiableSet(owned)); 
    } 
    owners = Collections.unmodifiableMap(ownership); 
} 

private final int catalogId; 
private final NetworkedMachine owner; 

NetworkedMachine(int catalogId, NetworkedMachine machine) { 
    this.catalogId = catalogId; 
    this.owner = machine; 
} 

public int getCatalogId() { 
    return catalogId; 
} 

public NetworkedMachine getOwner() { 
    return owner; 
} 

public Set<NetworkedMachine> getOwns() { 
    return owners.get(this); 
} 

public boolean isOwned() { 
    return owner != null; 
} 

} 

Testausgang:

BASIC_MACHINE id: -1, owner: [null], owns: [GARDEN, BEVERAGE, COFFEE] 
BEVERAGE id: -1, owner: [BASIC_MACHINE], owns: [] 
COFFEE id: -1, owner: [BASIC_MACHINE], owns: [COFFEE_GRINDER, COFFEE_MACHINE] 
COFFEE_GRINDER id: 5, owner: [COFFEE], owns: [] 
COFFEE_MACHINE id: 6, owner: [COFFEE], owns: [] 
GARDEN id: -1, owner: [BASIC_MACHINE], owns: [LAWN_MOWER] 
LAWN_MOWER id: 28, owner: [GARDEN], owns: []