Dynamisches Konsolenprogramm

[looparda]

Hallo, ich hab die Aufgabe eine Konsolenanwendung zu schreiben, die Datensätze verwalten soll (d.h. CRUD Operationen). Ich hab die „Entitäten“ Lieferant, Kunden, Fuhrpark die jeweils verwaltet werden können sollen. Ich habe hierbei 2 Probleme:
1. Dynamische Menüstruktur
2. Dynamische Bearbeitung der Entitäten
Insgesamt wird wohl eine Menustruktur entstehen die wie folgt aussieht:

1 Kunden
   Auflisten
   Anlegen
   Bearbeiten
   Löschen
2 Lieferanten
   Auflisten
   Anlegen
   Bearbeiten
   Löschen
3 Fuhrpark
   Auflisten
   Anlegen
   Bearbeiten
   Löschen

1. Mit jetzigem Wissensstand ende ich in etwas wie diesem:

boolean abbruch = false;
        while( !abbruch ) {
            switch( io.readMainMenu() ) {
                case 1: {
                    switch( io.readKundenverwaltungsMenu() ) {
                        case 1:
                            io.readNewKunde();
                            break;
                        case 2:
                            io.printKunden();
                            break;
                       ...
                    }
                }
                break;
            }
        }

Was ich sehr hässlich finde und nichts mit Objektorientierung zu tun hat.

2. Mit jetzigem Wissensstand ende ich in etwas wie:
Hier das Einlesen/Anlegen eines neuen Kunden - für Lieferant und Fahrzeug wäre es sehr ähnlich da ich alle Parameter des Konstruktors einlese und ggf. Konstruktoren eines Parameters (hier bei Adresse).

public Kunde readNewKunde() {
        return new Kunde(
                readNewAdresse()
        );
    }

    private Adresse readNewAdresse() {
        boolean valid = false;
        
        String firmenname;
        String ansprechpartner;
        String strasse;
        int hausnummer;
        int plz;
        String stadt;
        EULand land = null;
        int telefon;
        do {
            firmenname = read("Firmenname: ");
            ansprechpartner = read("Ansprechpartner: ");
            strasse = read("Strasse: ");
            hausnummer = (int) readNumber("Hausnummer: ");
            plz = (int) readNumber("PLZ: ");
            stadt = read("Stadt: ");
            
            try {
                land = EULand.getKey( read("Land: ") );
                valid = true;
            } catch (UnknownCountryException ex) {
                ausgabe("Unbekanntes Land!");
            }
            telefon = (int) readNumber("Telefon: ");
            
        } while (!valid); 
        
        return new Adresse(
                firmenname,
                ansprechpartner,
                strasse,
                hausnummer,
                plz,
                stadt,
                land,
                telefon
        );
    }

Was noch viel schlimmer ist. Überall finde ich nur Beispiele so wie ich es nun implementiert habe. Ich wiederhole somit aber viel zu viel. Es fühlt sich einfach komplett falsch an.
Ich benötige ein paar Ansätze welche Möglichkeiten es gibt das ganze „richtig“ zu implementieren.

 

[senior.weber]

Hallo,

IMO kommst du um die "Fleissarbeit" leider nicht herum. Wenn du die Sprache Groovy verwenden könntest, würde es einfacher.

Evt könntest du das einlesen noch generischer machen (ungetesteter Pseudocode):

abstract class EingelesenesObjekt{
   public Map<String,String> felder = new HashMap<String,String>();

   public void read(Map<String,String> daten){
      //oder mit reflection
   }
}

class Kontakt extends EingelesenesObjekt{
   String strasse;

   public Kontakt(){
       felder.put("strasse", "");
       felder.put("land", "Deutschland");
   }
 
   public void read(Map<String,String> daten){
      this.strasse = daten.get("strasse");
      ... etc pp..
   }
}

private static void readNewX(EingelesenesObjekt neu) {
        boolean valid = false;
        Map<String,String> result= new HashMap<String,String>();
        do {
         
            for(Map.Entry e:neu.felder.entrySet()){
               String k = e.getKey();
               result.put(k, read(k, result.containsKey(k)?result.get(k):e.getValue()));//2 argument: vorbelegter Wert in der Konsole
            }
 
            try {
                neu.read(result);
                valid = true;
            } catch (UnknownCountryException ex) {
                ausgabe("Unbekanntes Land!");
            }
 
        } while (!valid);

 

[looparda]

Hallo,

vielen Dank für den Beitrag. Diesen Ansatz hatte ich auch schon in dieser Art probiert. Problem ist dass ich somit die Information verliere was eingelesen werden soll und somit die Kontrolle von Eingaben (z.B. Zahl zwischen 1 und 3 einlesen, nur Geldbetrag eingeben usw.) Das ist jedoch nicht allzu tragisch, da ich dies im Konstruktor prüfen kann und dem Benutzer dann die Gelegenheit geben kann von vorn ein neues Objekt anzulegen (Auch nicht so schön aber ok). Vielmehr ist Problem, dass Parameter des Konstruktors nicht primitiv sind sondern wiederum Objekte.
Beispiel hierfür:

abstract public class Entity {
    public Map<String, Object> felder = new LinkedHashMap<>();
    abstract public void read(Map<String,Object> daten);
}

class Auftrag extends Entity {
  Date datum;
  Kunde kunde;

  public Auftrag() {
    this.felder.put("datum", "");
    this.felder.put("kunde", "");
  }
}

@Override
public void read(Map<String, Object> daten) {
  this.datum = new Date( (String) daten.get("datum")); //Problem
  this.kunde = (Kunde) daten.get("kunde"); //Größeres Problem
}

public Auftrag readNewAuftrag() {
  Auftrag auftrag = new Auftrag();
   I_O.readNewEntity( auftrag ); // Auslöser: readNewEntity glaubt alle Parameter können als String eingelesen werden 
  return auftrag;
}

 public static void readNewEntity(Entity neu) {
        I_O io = new I_O();
        boolean valid = false;
        Map<String, Object> result = new LinkedHashMap<>();
        do {
            for (Map.Entry e : neu.felder.entrySet()) {
                String k = (String) e.getKey();
                String current = result.containsKey(k) ? (String) result.get(k) : (String) e.getValue();
                String read = io.read(k, current);
                result.put(k, read);
                result.put(k, (result.containsKey(k) ? (String) result.get(k) : (String) e.getValue()));//2 argument: vorbelegter Wert in der Konsole
            }
            neu.read(result);
            valid = true;
        } while (!valid);
    }

 

[senior.weber]

Hallo,

an sich auch kein Problem, die Entities müssen nur selber wissen wie sie angelegt werden können - denn - es MUSS ja alles als String eingelesen werden können (als Konsoleninput) ->

@Override

SimpleDateFormat erwartetesDateFormat = new SimpleDateFormat("MM.dd.yyyy");

public void read(Map<String, Object> daten) {
  this.datum = erwartetesDateFormat.parse(daten.get("datum"));// wirft Exception wenn Parsen nicht möglich, also read(daten ) immer mit Try..catch..valid

  this.kunde = daten.get("Kunde");//ist ein Kundeobject
}

und evt in der Entity so

public Auftrag() {
    this.felder.put("datum", String.class);//oder Date.class
    this.felder.put("kunde", Entity.class);
  }

und im io so:

 public static void readNewEntity(Entity neu) {
        I_O io = new I_O();
        boolean valid = false;
        Map<String, Object> result = new LinkedHashMap<>();
        do {
            for (Map.Entry e : neu.felder.entrySet()) {
                String k = (String) e.getKey();
                Class typec = e.getValue();
                Object read = io.read(k, typec);
                result.put(k, read);
            }
            neu.read(result);
            valid = true;
        } while (!valid);
    }

im io.read:

if(typec.isAssignableFrom(Entity.class)){
    Entity e= readNewEntity(typec.newInstance());
    return e
}

Hinweis: nicht davon ist getestet - ich will nur eine Idee vermitteln: Die Entites können primitive Typen, Objecte wie Date und andere Entities als Eigenschaften haben, und der I_O läst diese dann rekursiv einlesen - ok?