Lookup-Kartenwerte und ruft angepassten Implementierungen

Question

Ich habe den Ausführungen meiner Klassen:

public interface Device { 
    void create(); 
} 

public class Printer implements Device { 
    @Override 
    public void create() { 
} 

public class Mouse implements Device { 
    @Override 
    public void create() { 
} 



public class ProcessImpl implements Processor { 

    private final Map<String, Set<String>> deviceMap = new HashMap<>(); 

    @Override 
    public void process(String input) { 
     populateMap(input); 

     //call to `provision(deviceMap)` 

} 

deviceMap Werte wie dies beispielsweise angeordnet sind: {123 = [P, M], 224 = [C, P, M]}

wo 123 eine ID und Stringwerte C', P , M` Geräte repräsentiert gegen die entsprechende ID geschaffen werden.

Meine Frage ist, wie kann ich über diese Karte in provision(deviceMap) Methode und create die Geräte durch den Aufruf ihrer entsprechenden create() Methode iterieren. (Erzielung von Polymorphismus), z.B.

Wenn P -> Rufen Sie create() in Printer Implementierung von Device. Was ist gutes Design/Muster, das ich verwenden kann, um die Klassen zu strukturieren? Kann enum dabei helfen oder gibt es einen besseren Reiniger Ansatz?

Answer 1

entschuldigen uns für die wahrscheinlich falsch Java-Syntax und Konventionen (Ich bin ein C# -Entwickler), aber:

Sie können eine Fabrik haben, die eine Zuordnung zwischen den erlaubten Strings zu den Device Typen haben:

public interface IDeviceFactory { 
    Device getDevice(string string input); 
} 

public class MappingDeviceFactory implements IDeviceFactory { 

    private Map<String, Device> _mapping; 

    public MappingDeviceFactory(Map<String, Device> mapping) { 
     _mapping = mapping; 
    } 

    public Device getDevice(string string input) { 
     //Look in the mapping for the input and return that device. 
    } 
} 

Eine andere Möglichkeit ist, dass jedes Gerät „sagen“, welche Art von Eingabe ist es für:

public interface Device { 
    String _type; 
    void create(); 
} 

public abstract class DeviceBase { 
    public String _type; 

    public DeviceBase(String type) { 
     _type = type; 
    } 

    public abstract void create(); 
} 

public class Printer implements DeviceBase { 
    public Printer() super ("P") {} 
    @Override 
    public void create() {} 
} 

und dann in Ihrer Implementierung der IDeviceFactory von oben hat nur statt einer Abbildung eine Sammlung von Device und die Sammlung Suche nach den gegebenen input

---

über die enum vs. String für die Abbildung:

• Ich würde lieber für die enum über die Strings gehen, weil es mir hilft, die Weitergabe falscher Werte zu verhindern.
• Wenn Sie jedoch nicht alle Arten von Device s zum Zeitpunkt der Kompilierung kennen (dh Sie können einen Wert für sie in der enum haben; Würde in einem Fall passieren, dass andere Leute mehr schreiben Device s und dass Sie laden diese Dateien im laufenden Betrieb), dann würde ich für eine der beiden gehen:
  • Haben Sie ein Objekt DeviceRequestBase mit: PrinterDeviceRequest, MouseDeviceRequest ... dann wird die Fabrik, wenn die Anforderung an den Gerätetyp zwischen der Art abzubilden.
  • Wenn dies wie ein Overkill fühlt und Sie brauchen es nicht so erweiterbar zu sein - dann bleiben nur auf die string s