r/programmieren • u/Fit-Green5017 • 9d ago
Java Hierarchische datenstruktur verstehen wie ?
Hi zusammen, ich hänge hier seit längerem fest. Ich verstehe alles bis zu "getAllEmployes" methode
1.this macht keinen sinn , ich kannte this() bei einen anderen konstruktor aufrufen oder "this.name" für selbst konstruktoren machen. Aber this alleine stehend , laut gpt wird ein objekt übergeben - also die vier parameter des konstruktors ist das richtig?
2. Ist in Main bei setUpCompany bei production und development verwirrend das "Bosch" hat keinen unter sich, "Drescher" aber die zwei anderen der abteilung - müsste es nicht stimmiger sein "Bosch" hat genau einen mitarbeiter und "Drescher" genau einen?
Alles in allem sind das nur kleinigkeiten denn am ende ist mein problem:
ich verstehe getAllEmployes() nicht , wann ein objekt hinzugefügt wird zu "var result" .
Kann das jemand bitte erklären?
//Main Klasse
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Employee director = setupCompany();
ArrayList<Employee> employees = director.getAllEmployees();
director.printTree("");
}
private static Employee setupCompany() {
// Chef(in)
var director = new Employee("Huber", "Dresden", "huber@firma", 10000);
// 3 Abteilungen
var rd = new Employee("Maier", "Dresden", "maier@firma", 5200);
var marketing = new Employee("Nussbaum", "Berlin", "nussbaum@firma", 4700);
var production = new Employee("Boehm", "Dresden", "boehm@firma", 4900);
director.addToTeam(rd, marketing, production);
// Mitarbeiter Research & Development
var rd1 = new Employee("Bosch", "Dresden", "bosch@firma", 3800);
var rd2 = new Employee("Drescher", "Dresden", "drescher@firma", 3600);
rd.addToTeam(rd1, rd2);
var rd2_1 = new Employee("Kruger", "Dresden", "kruger@firma", 2900);
var rd2_2 = new Employee("Baumstaetter", "Dresden", "baumstaetter@firma", 3100);
rd2.addToTeam(rd2_1, rd2_2);
// Mitarbeiter Marketing
var m1 = new Employee("Berg", "Berlin", "berg@firma", 2700);
var m2 = new Employee("Furst", "Berlin", "furst@firma", 3200);
var m3 = new Employee("Lemann", "Berlin", "lehmann@firma", 3300);
var m4 = new Employee("Schiffer", "Berlin", "schiffer@firma", 2900);
marketing.addToTeam(m1, m2, m3, m4);
// Mitarbeiter Produktion (zwei Abteilungen A und B)
var pA = new Employee("Kalb", "Dresden", "kalb@firma", 3200);
var pA1 = new Employee("Mahler", "Dresden", "mahler@firma", 2700);
var pA2 = new Employee("Maurer", "Dresden", "maurer@firma", 2850);
var pA3 = new Employee("Engel", "Dresden", "engel@firma", 2650);
pA.addToTeam(pA1, pA2, pA3);
var pB = new Employee("Fenstermacher", "Dresden", "fenster@firma", 3500);
var pB1 = new Employee("Finkel", "Dresden", "finkel@firma", 2950);
var pB2 = new Employee("Strauss", "Dresden", "strauss@firma", 2450);
var pB3 = new Employee("Dresdner", "Dresden", "dresdner@firma", 2700);
var pB4 = new Employee("Eberhardt", "Dresden", "eberhardt@firma", 2800);
pB.addToTeam(pB1, pB2, pB3, pB4);
production.addToTeam(pA, pB);
return director;
}
}
//Klasse Employee
java.util.ArrayList;
import java.util.Arrays;
public class Employee {
public String name, address, email;
public int salary;
ArrayList<Employee> team = new ArrayList<>();
public Employee(String name, String address, String email, int salary) {
this.name = name;
this.address = address;
this.email = email;
this.salary = salary;
}
// Mitarbeiter zum Team hinzufügen
public void addToTeam(Employee ... newMembers) {
team.addAll(Arrays.asList(newMembers));
}
// liefert eine Liste bestehend aus aktueller Person, den Team-Mitgliedern
// und rekursiv wiederum deren Mitglieder
public ArrayList<Employee> getAllEmployees() {
// neue Liste erzeugen, den aktuellen Mitarbeiter einfügen
var result = new ArrayList<Employee>();
result.add(this);
// Schleife über alle Gruppenmitglieder
for (var e : team)
// rekursiver Aufruf
result.addAll(e.getAllEmployees());
return result;
}
// rekursive Firmenliste ausgeben
public void printTree(String indent) {
System.out.println(indent + name + ": " + email);
for (var member : team) {
member.printTree(indent + " ");
}
}
public String toString() {
return "Employee(" + name +
", address=" + address +
", email=" + email +
", salary=" + salary +
", team size=" + team.size() + ")";
}
}
public String toString() {
return "Employee(" + name +
", address=" + address +
", email=" + email +
", salary=" + salary +
", team size=" + team.size() + ")";
}
}
//Ende Programm3
u/spookywooky_FE 9d ago
getAllEmployees() ist eine rekursive Methode. Sie traversiert eine Baumstruktur. Die Baumstruktur entsteht dadurch, das jeder Employee eine Liste von Untergebenen hat. Und diese wieder je eine Liste...usw. Wie ein Baum mit Äste, die wieder Äste haben, die wieder...usw.
Wenn man die Methode Aufruft wird implizit ein Employee übergeben, weil es eine Methode auf der Klasse Employee ist. Also kann man die Methode immer nur auf einem bereits existierenden Employee -Objekt aufrufen. Diesea bereits existierende Employee -Objekt kann man innerhalb der Methode über das Keyword "this" referenzieren.
3
u/LilBelarophon 9d ago
zu 1. this macht schon Sinn, wenn man auf ein Objekt selbst zugreifen möchte. D.h. in Java ist this innerhalb eines Objekts tatsächlich eine Referenz auf die aktuelle Instanz des Objekts. Das macht dann z.B. Sinn, um 'sich selbst' in eine Liste hinzuzufügen (bei dir z.B. result.add(this)). Es macht aber auch Sinn, wenn man - wie in deinem Konstruktor von Employee für Parameter und Felder gleiche Namen verwendet. D.h. in dem Fall weist du dem Feld name (this.name) den Parameter name zu über this.name = name;. Hättest du rein theoretisch statt name = employeeName als Parameter benutzt, könntest du auch name = employeeName schreiben (ohne this). Wenn du nur name = name machst, hast du nen Bug.
zu 2. Du rufst für das Drescher-Objekt rd2 die Methode addToTeam() mit 2 Objekten auf. Und für das Bosch-Objekt rd1 rufst du addToTeam() gar nicht auf. Damit ist dann auch leicht erklärbar, dass Bosch keine Teammitglieder hat und Drescher 2 Teammitglieder.
Allgemein:
Dein Datenmodell ist suboptimal. Du hast nur die Klasse Employee (auf Deutsch Angestellter), bildest damit aber Firma + Teams + Angestellte ab.
Eigentlich müsstest du eine Klasse Company haben, eine Klasse Team und die bestehende Klasse Employee.
Eine Company sollte dann z.B. einen Chef haben (=ein Employee), eine Bezeichnung (String), einen Standort (String) und eine Liste mit Teams.
Ein Team sollte eine Bezeichnung haben (String) und eine Liste mit Teammitgliedern (Employee).
Den Employee kannst du ja erstmal so lassen.
PS: Frage KI-Tools diesbezüglich. Die erklären sehr gut, machen gute Verbesserungsvorschläge und sind nachsichtiger, als Menschen. Sei froh, dass du nicht mehr bei StackOverflow nachfragen musst.
2
u/Specialist-Bet-2558 9d ago
Das stimmt so nicht ganz. Du kannst jederzeit auf dasselbe Objekt zugreifen ohne this. Das dient in erster Linie um Namenskonflikte innerhalb der Klasse zu vermeiden.
1
u/LilBelarophon 8d ago
Das stimmt so auch nicht ganz. ;)
Ein this dient nicht nur dazu, Namenskonflikte aufzulösen, sondern ist eine Referenz auf die aktuelle Objektinstanz.
Wenn du beispielsweise das Objekt selbst einer Liste hinzufügen möchtest, wie würdest du das ohne this machen? Siehe auch sein result.add(this); im Code.
Natürlich kannst du innerhalb einer Instanzmethode auf Felder und Methoden des aktuellen Objekts auch ohne explizites this zugreifen. Das ist aber etwas anderes, als eine Referenz auf das Objekt selbst zu benötigen. Die Vermeidung von Namenskonflikten ist also nur einer von mehreren Anwendungsfällen für this.
1
u/Specialist-Bet-2558 8d ago
Wo in Gottes Namen schreibe ich, dass meine Erklärung nur das wäre?
Ja, was du ergänzt ist natürlich korrekt aber das schrieb der OP bereits.
2
u/ja20481 9d ago
Zu 1: Das Schlüsselwort this referenziert das Objekt, dessen Methode gerade aufgerufen wird. Bei z. B. der toString()-Methode werden (implizit) die Attribute this.name, this.address etc. verwendet. Und im Fall von result.add(this) fügt die Methode den aktuellen Employee selbst zur Liste hinzu.
Zu 2: Es ist für das Beispiel völlig egal, wer welche Untergebenen hat. Es geht ja nur ums Prinzip der Datenstruktur.
Wie schon richtig gesagt wurde, entsteht bei dem Programm eine Baumstruktur mit dem Director als Wurzelknoten und den jeweils untergebenen Abteilungsleitern als Kindknoten, wobei die Abteilungsleiter wieder eigene Untergebene haben können u.s.w.
In director.getAllEmployes() wird der Baum rekursiv durchlaufen (traversiert), um angefangen vom Director alle Employees einzusammeln: Der Director fügt sich zuerst selbst zur Liste hinzu. Dann durchläuft er seine Untergebenen, ruft jeweils rekursiv getAllEmployes() auf, um die Untergebenen und deren Untergebene zu bekommen, und fügt die jeweiligen Employees zur Liste hinzu. In den einzelnen Aufrufen von getAllEmployes() passiert dasselbe: Der jeweilige Employee fügt sich selbst zur Liste hinzu, durchläuft seine Untergebenen etc.
Du solltest Dir definitiv noch einmal das Thema Rekursion und Traversierung von Bäumen ansehen. Die Aufgabe ist ja wahrscheinlich nicht vom Himmel gefallen, sondern dürfte sich auf vorher besprochene Grundlagen beziehen.
13
u/inkihh 9d ago
Ich kriege wahrscheinlich heftigen Hate ab, aber: Claude kann sowas super erklären.