Hilfe bei Methode

[Wuast]

Hallo Leute.
Ich grübele über eine Methode nach, bin aber etwas ratlos, wie ich das umsetzen kann bzw ob das überhaupt geht.

Ich Habe eine Klasse Admin, die zwei Listen von Benutzern Verwaltet. Als eine von drei möglichen Benutzern des Programms implementiert diese Klasse auch das Interface Funktionen. Dieses gibt eine Methode suche (int suchZahl) vor. Ich dachte, vllt. kann man das übersichtlich gestalten und eine Art Factory bauen.

public class Admin implements Funktionen {
    
    private Optional<Kunde> kunde;
    private Optional<Dienstleister> anbieter;
    
    private ArrayList <Kunde> kundenListe = new <Kunde> ArrayList();
    private ArrayList <Dienstleister> anbieterListe = new <Dienstleister> ArrayList();
    
    @Override
    public void suchen(int suchZahl) {
        if (suchZahl == 0) {
            sucheKunde();    //Problem
        }
    }
    
    Optional<Kunde> sucheKunde (int kundennummer){
        kunde = kundenListe.stream()
                .filter (x -> x.getKundennummer() == kundenNummer)
                .findFirst();
        return kunde;
    }
}

Aber wie komme ich dann an den int Kundennummer, wenn ich später (z.B. im UI) die Methode suchen aufrufe?
Oder würdet ihr das anders angehen?
Hoffe auf ein paar Anregungen liebe Grüße

 

[Jw456]

Na die Methode "suchen" sollte da auch was zurückgeben. Die Nummer und nicht void.
Außerdem hast du eine Liste Kunde.
Die sollte auch vom Datentyp Kunde sein. In dieser Klasse kannst du ja zb deine Kundennummer und andere Kunden typische Daten Speichen.

Diese Liste ist ja später auch nur im Ram also müßte auch gespeichert und vor dem ersten suchen auch wider eingelesen werden.

Da würde sich eine DB anbieten.

 

[Wuast]

Na die Methode "suchen" sollte da auch was zurückgeben. Die Nummer und nicht void.

Da hast du recht. Das kann ja geändert werden. Zum aktuellen Zeitpunkt weiß ich noch nicht, welcher Rückgabetyp sinnvoll ist, weil mein Gedanke bisher war, dass der Admin nach Kunden und nach Dienstleistern suchen kann, aber vllt. auch noch nach Terminen und so weiter.

Außerdem hast du eine Liste Kunde.
Die sollte auch vom Datentyp Kunde sein. In dieser Klasse kannst du ja zb deine Kundennummer und andere Kunden typische Daten Speichen.

Ist sie doch?!

Dass da noch eine DB etc. kommt ist klar, aber da bin ich noch nicht. Ich wollt ja erstmal nur Hilfe bei meiner Methode. Fällt dir da ein, ob ich das in dieser Art und Weise lösen könnte oder bin ich komplett auf dem Holzweg, quasi erzwungener Pseudo-clean-code? Ich kann ja auch alle Methoden einzeln bereitstellen.

Vllt. dieses Vargas an die suche()-Methode übergeben? Oo

 

[KonradN]

Das Grundlegende Problem ist doch erst einmal dass Du eine Methode sucheKunde(int) hast und du rufst diese ohne Parameter auf. Das kann natürlich nicht funktionieren. Wenn die Methode einen int Parameter erwartet, dann musst Du natürlich diesen Parameter auch angeben.

 

[Jw456]

Dann zeige doch mal Die Klasse „Kunden“ damit wir sehen wie du die Kundennummer da speicherst und wie du da auch wieder darauf zugreifen kannst.

Auch das If == 0 sehe ich als falsch an. Du willst doch suchen, wenn was in der Liste ist.

in etwas so

public class Admin {
    public static void main(String[] args) {
        Admin admin = new Admin();
        admin.kundenListe.add(new Kunde(12345, "Hans"));
        admin.kundenListe.add(new Kunde(345,"Max"));
        admin.kundenListe.add(new Kunde(42123  ,"Fritz"));

        System.out.printf("Der Name von 345 ist "+ admin.suchen(345).get().getName());
    }

        private Optional<Kunde> kunde;
       // private Optional<Dienstleister> anbieter;

        private ArrayList<Kunde> kundenListe = new <Kunde> ArrayList();
        //private ArrayList <Dienstleister> anbieterListe = new <Dienstleister> ArrayList();


        public  Optional<Kunde> suchen(int suchZahl) {
            if (suchZahl != 0) {
                return sucheKunde(suchZahl);    //Problem
            }
            return null;
        }

        Optional<Kunde> sucheKunde (int kundennummer){
            kunde = kundenListe.stream()
                    .filter (x -> x.getKundennummer() == kundennummer)
                    .findFirst();
            return kunde;
        }
}

 

[Robertop]

Da hast du recht. Das kann ja geändert werden. Zum aktuellen Zeitpunkt weiß ich noch nicht, welcher Rückgabetyp sinnvoll ist, weil mein Gedanke bisher war, dass der Admin nach Kunden und nach Dienstleistern suchen kann, aber vllt. auch noch nach Terminen und so weiter.

Wenn die Dinge, die gesucht werden, nichts gemeinsam haben (z.B. Kunde und Termine), dann bleibt da als Datentyp eigentlich nur Object übrig, außer die haben irgendein gemeinsamen Interface. Aber das wäre aus meiner Sicht nicht die richtige Art, das zu implementieren. Die Frage ist ja auch, wie der Anwender der Suchfunktion dann sagen kann, was er sucht.

Sauberer wäre, da verschiedene Funktionen anzubieten, also z.B. "sucheKunde", "sucheDienstleister" und "sucheTermin".

public  Optional<Kunde> suchen(int suchZahl) {
            if (suchZahl != 0) {
                return sucheKunde(suchZahl);    //Problem
            }
            return null;
        }

Anstatt return null würde ich hier Optional.empty() nehmen, sonst zwingt man dem Aufrufenden trotz Optional einen Nullcheck auf.

 

[Jw456]

Anstatt return null würde ich hier Optional.empty() nehmen, sonst zwingt man dem Aufrufenden trotz Optional einen Nullcheck auf.

ja besser, wenn man Optional verwenden tut.

 

[Wuast]

Das Grundlegende Problem ist doch erst einmal dass Du eine Methode sucheKunde(int) hast und du rufst diese ohne Parameter auf. Das kann natürlich nicht funktionieren. Wenn die Methode einen int Parameter erwartet, dann musst Du natürlich diesen Parameter auch angeben.

Darüber bin ich ja gestolpert. Und dann habe ich mich gefragt, ob das überhaupt sinnvoll ist und auf diese Art und Weise elegant zu lösen wäre oder wie Robert vorschlägt

Sauberer wäre, da verschiedene Funktionen anzubieten, also z.B. "sucheKunde", "sucheDienstleister" und "sucheTermin".

.

Dann zeige doch mal Die Klasse „Kunden“ damit wir sehen wie du die Kundennummer da speicherst und wie du da auch wieder darauf zugreifen kannst.

Auch das If == 0 sehe ich als falsch an. Du willst doch suchen, wenn was in der Liste ist.

in etwas so

public class Admin {
    public static void main(String[] args) {
        Admin admin = new Admin();
        admin.kundenListe.add(new Kunde(12345, "Hans"));
        admin.kundenListe.add(new Kunde(345,"Max"));
        admin.kundenListe.add(new Kunde(42123  ,"Fritz"));

        System.out.printf("Der Name von 345 ist "+ admin.suchen(345).get().getName());
    }

[/QUOTE]


[/QUOTE]
[/QUOTE]
Die Suchzahl sollte den nachgelagerten Methodenaufruf steuern. if == 0, Methode sucheKunde. if == 1, Methode sucheDienstleister. In dieser Art. Aber da diese Methoden ja bestimmte Parameter benötigen, braucht(e) dass einen Kniff, z.B. dachte ich, dass es doch vllt. möglich (und sinnvoll??) sein könnte, wenn man einer Methode eine Beliebige Anzahl an Werten übergeben kann.
Methode Kunde ist bis dato recht unspektakulär:

[CODE=java]mport java.time.LocalDate;

public class Kunde extends Nutzer implements Funktionen {
 
    private LocalDate alter;
 
    public Kunde (String vorname, String nachname) {
        this.vorname = vorname;
        this.nachname = nachname;
        this.Id = generiereZufallsId();
    }
 
    public Kunde() {
    }
 
    @Override
    public void suche(int suchZahl) {
        if (suchZahl == 0) {
            sucheDienstleister();
        }
        if (suchZahl == 1) {
            sucheTermin();
        }
    }
 
    public void sucheDienstleister() {  
    }
 
    public void sucheTermin() {
    }
 
    public void bucheTermin () {      
    }
 
}

EDIT:Sorry ich habe dein Zitat verhunzt weil versehentlich darin meinen Code platziert. Jetzt kriege ich den nicht mehr raus. Hoffe es ist trzd verständlich

 

[KonradN]

Scheiss Editor im Browser! Ich habe so viel Erläuterung geschrieben und dann einmal auf die Back Funktionalität im Browser gekommen und alles weg! Wieso funktioniert das automatische Zwischenspeichern nicht? Ich habe da keinen Bock drauf! Sorry, wenn es jetzt kurz wird und meine Stimmung mangelhaft ist!

Ich habe den Eindruck, dass Du hier über Refactorings nachdenkst aber Du hast noch keinen Ansatz, der gehen kann!

Du willst eine suchen Methode - dann musst Du schauen, was diese braucht und alle notwendigen Daten zur Verfügung stellen. Du brauchst z.B. die id um nach der id suchen zu können. Also musst Du die zur Verfügung stellen!

Da gibt es grob 3 Möglichkeiten, die da in Frage kommen:

• Parameter - einfach per Parameter die notwendigen Daten übergeben
• Instanz- und Klassenvariablen - dann werden die Daten vorab gesetzt z.B. per Konstruktor
• Die Instanz kann sich die Daten irgendwie beschaffen durch Aufrufe auf Dingen, die in Variablen bekannt sind.

Also brauchst Du einfach noch einen zusätzlichen Parameter in der suchen Methode: Die id des gesuchten Elements.

Dann kannst Du Refactorings machen um den Code sauber zu gestallten.

Konstanten statt magic numbers! Dieses 0, 1, 2, ... Absolut unleserlich. Was macht denn ein suchen(0, ....)? Das sieht doch niemand! Also mach Konstanten so dass Du da ein suchen(SUCHE_KUNDEN, ....) oder so bekommst.

Enums - Wenn Du da 3 feste Werte hast: Warum nicht ein Enum als Parameter. Dann ist da auch keine Verwechslung möglich. Nicht dass Du die zwei Parameter vertauschst oder so.

Verteiler Methoden vermeiden - Wozu eine Verteiler Methode, die über eine Reihe ifs oder ein switch dann auf entsprechende Methoden aufteilt. Das hatte man oft vor Java 8 in UIs ... Da wurde iim Event Handling abgeprüft, von welchem Control das Event ausgelöst wurde um dann Aktionen zu machen ... Schrecklich! ... ==> Direkt die einzelnen Methoden aufrufen! Also warum ein suche(SUCHE_KUNDEN, gesuchteId) wenn ein sucheKunden(gesuchteId) direkt aufgerufen werden kann?

Weitere Möglichkeiten, um sowas aufzulösen (denn das direkte Aufrufen geht oft auch nicht):

Bei Enums hast Du unter dem Strich spezielle Klassen. Da ist alles möglich, was nicht durch die Java Spezifikation explizit verboten wurde. Da kannst Du also auch Dinge speichern und damit für jede Instanz einen speziellen Methodenaufruf hinterlegen.

Du kannst eine Map aufbauen mit der Auswahl als Key und einem funktionalen Interface mit der Aktion als Value. Dann musst Du nur die Map abfragen um dann den Aufruf machen zu können.

Favor Composition over Inheritance (FCoI)
Das kann man nicht konkret bei Dir sagen, aber man muss aufpassen, dass man das mächtige Instrument Inhertance nicht unnötig verwendet und damit Code zu komplex macht.

Vermeide doppelten Code
Doppelten Code kann man oft vermeiden. Wenn Du also dieses durchgehen von Elementen hast um nach einer Id zu suchen, dann kann man das ggf. vereinheitlichen...

Das war ein absoluter Schnelldurchlauf. Die einzelnen Punkte hatte ich ursprünglich alle mit mindestens 1 - 2 Absätzen erläutert und die Anwendung erklärt! Aber danke meinem Browser für den Verlust. Das sollte man aber alles auch im Netz finden können. Zur Not konkret nachfragen! Eine Option werde ich einmal kurz aufzeigen...

 

[KonradN]

Nur mal, um etwas zu skizzieren, was Du nutzen könntest...

Erst einmal hast Du Datenklassen - Entities ... Kunde und so. Und diese haben gemeinsame Dinge, die Du in eine Basisklasse ziehen kannst. Suche nach Id hast Du da jetzt als Beispiel, daher bauen wir da einfach einmal schnell etwas auf mit einer Id (Und ich lasse alles andere weg - natürlich ist Kunde nicht leer sondern hat dann Kundenspezifische Dinge!):

public class BaseEntity {
    private int id;

    public int getId() {
        return id;
    }
}

public class Kunde extends BaseEntity {
}

So Entities willst Du in einer Liste speichern können und die Liste dann nach id Durchsuchen können:

public class BaseEntityList <T extends BaseEntity>  {
    // Composition over inheritance! :-))
    private ArrayList<T> baseData = new ArrayList<>();

    public void add(T t) {
        baseData.add(t);
    }

    public Optional<T> findById(int id) {
        return baseData
            .stream()
            .filter(t -> t.getId() == id)
            .findFirst();
    }
}

Das kann man dann ggf. noch als Map oder so aufbauen...

public enum Entities {
    KUNDE
}

public class Usage {
    
    private Map<Entities, BaseEntityList> data = new EnumMap<>(Entities.class);
    
    public Usage() {
        BaseEntityList<Kunde> kunden = new BaseEntityList<>();
        data.put(Entities.KUNDE, kunden);
    }
    public Optional<BaseEntity> find(Entities entity, int id) {
        BaseEntityList list = data.get(entity);
        return list.findById(id);
    }
}

Das zeigt etwas, wie eine Map verwendet werden könnte. Hier allerdings nicht mit einem funktionalen Interface sondern direkt mit den Daten, auf denen dann etwas gemacht wird. Die find Methode hat aber jetzt keine Typ-Prüfung mehr und Du musst einen Cast machen um zum Kunden zu kommen.
Die Methode skizziert das auch nur - man muss da natürlich sicher stellen, dass ein Eintrag in der Map war und den Cast könnte man per Generics machen, so dass man das nicht mehr bei jedem Aufruf machen muss. Das ist aber an der Stelle jetzt erst einmal egal.

Das wäre so ein einfacher Aufbau, wie er evtl. denkbar wäre. Generell ist halt immer die Frage, was man alles an Anforderungen hat und so. Uns fehlt hier einfach viel zu viel an Informationen.

 

[KonradN]

Das mit dem Generic in der Find Methode habe ich einfach einmal schnell umgesetzt - so richtig gefallen tut es mir nicht. In der Enum geben wir jedem Eintrag noch die Klasse der Entity und dann können wir das nutzen:

public enum Entities {
    KUNDE(Kunde.class);

    private Class<? extends BaseEntity> clazz;
    Entities(Class<? extends BaseEntity> clazz) {
        this.clazz = clazz;
    }

    public static Entities fromClass(Class<? extends BaseEntity> clazz) {
        for (Entities entity : Entities.values()) {
            if (entity.clazz.equals(clazz)) {
                return entity;
            }
        }
        throw new IllegalArgumentException("No entity found for class " + clazz);
    }
}

package test;

import java.util.EnumMap;
import java.util.Map;
import java.util.Optional;

public class Usage {

    private Map<Entities, BaseEntityList> data = new EnumMap<>(Entities.class);

    public Usage() {
        BaseEntityList<Kunde> kunden = new BaseEntityList<>();
        data.put(Entities.KUNDE, kunden);
        Kunde kunde = find(Kunde.class, 1).orElseThrow();
    }
    
    public <T extends BaseEntity> Optional<T> find(Class<T> clazz, int id) {
        Entities entity = Entities.fromClass(clazz);
        BaseEntityList list = data.get(entity);
        return list.findById(id);
    }
}

Ohne das wäre es auf etwas hinaus gelaufen wie:
Kunde kunde = (Kunde) find(Entities.KUNDE, 1).orElseThrow();
oder so ...

Das "orElseThrow()" war jetzt nur auf die Schnelle - statt dessen sollte man natürlich weiter mit Optional<Kunde> arbeiten und da dann wirklich prüfen ... Code kommt so mehr oder weniger 1:1 als Vorschlag von GitHub Copilot ...

 

[Wuast]

So viel zum Thema "Kurze Antwort" Konrad, du kannst es nicht lassen. Dafür schon mal vielen Dank!. Da muss ich mir bei Gelegenheit mal richtig Zeit für nehmen

 

[KonradN]

So viel zum Thema "Kurze Antwort"

Dann überleg mal, was es vorher gewesen sein musste zu den Refactorings

 

[KonradN]

Bezüglich der "if Sequenzen" und deren Vermeidung gibt es nun eine ausführliche Erläuterung bei meinen JAdventure Ausführungen im Anhang:
if Sequenzen vermeiden | JAdventure - Kurs zur Softwareentwicklung

 

[Wuast]

Bezüglich der "if Sequenzen" und deren Vermeidung gibt es nun eine ausführliche Erläuterung bei meinen JAdventure Ausführungen im Anhang:
if Sequenzen vermeiden | JAdventure - Kurs zur Softwareentwicklung

sehr schön, danke! sind gute Tipps bei! Und mir wird gerade deutlich, dass ich unbedingt die Design Patterns wiederholen muss...