# Personen vergleichen



## Sabine.Quast (15. Jun 2020)

Hallo,

ich hab folgendes Problem, ich muss Kinder anlegen und sie miteinander vergleichen ob sie Geschwister sind, nur weis ich nicht wie ich denen Eltern zuordnen kann, bzw sie als Kind zuweise und wie vergleiche ich, ob sie die selben Eltern haben (vlt.: child1.equals(cild2)...).

Das wird gefordert:

Modellieren Sie eine Klasse _Person_. Eine Person hat folgende Eigenschaften:

Einen Namen (_name_), der sich aus Titel, Vornamen, Nachname und Geburtsname zusammensetzt. (Legen Sie hierfür einen eigenen Datentyp an)
Ein Alter (_age_).
Eine Anschrift (address), welche sich aus Straße, Hausnummer, Postleitzahl, Wohnort und Land zusammensetzt. (Legen Sie hierfür einen eigenen Datentyp an)
Einen Vater (father) vom Datentyp _Father_. Legen Sie hierfür eine Klasse_ Father_ als Unterklasse von _Person_ an. Ein Vater kann (in unserem Beispiel) maximal 3 Kinder haben. Legen Sie für jedes Kind ein Attribut (_child1, child2, child3_) an in der Klasse _Father_ an.
Eine Mutter (mother) vom Datentpy _Mother_. Legen Sie eine Klasse Mother als Unterklasse von Person analog zu Father an.
Die Klasse_ Person_ hat folgende Operationen:

_isSibling(Person p): _Diese Operation gibt an, ob die Person p ein Geschwister von der betrachteten Person ist. Dafür müssen Vater und Mutter übereinstimmen.
_isHalfSibling(Person p)_: Diese Operation gibt an, ob die Person p ein Halbgeschwister von der betrachteten Person ist. Dafür darf nur ein Elternteil übereinstimmen.
_livesInTheSameCity(Person p): _Diese Operation gibt an, ob die Person p und die betrachtete Person in derselben Stadt leben.
_compareAge(Person p):_ Diese Operation gibt an, ob die Person p älter, jünger oder gleich alt wie die betrachtete Person ist. Entsprechend gibt sie auf der Konsole den Wert _older_, _younger_ oder _same age_ auf dem Bildschirm aus.
Legen Sie eine Klasse _PersonTest_ an.

Legen Sie beliebige Personen (Väter, Mütter etc.) an und gestalten Sie die Details (Name, Vornamen, Anschrift etc.) nach Ihren Vorstellungen aus. Schreiben Sie beispielhaften Code in dem Sie alle 4 Operationen der Klasse Person nutzen so dass:
_isSibling_ zu true auswertet.
_isHalfSibling_ zu true auswertet.
_livesInTheSameCity_ einmal zu true und einmal zu false auswertet.
Alle 3 Fälle von_ compareAge_ vorkommen.


Und das hab ich bisjetzt geschaft:


```
public class Person {

    Name name = new Name();
    int age;
    Address address = new Address();

    public Person(String titel, String vorname, String nachname, String geburtsname, String strasse, String hausnummer,
            int plz, String wohnort, String land) {

        this.name.titel = titel;
        this.name.vorname = vorname;
        this.name.nachname = nachname;
        this.name.geburtsname = geburtsname;
        System.out.println(
                this.name.titel + " " + this.name.vorname + " " + this.name.nachname + " " + this.name.geburtsname);

        this.address.strasse = strasse;
        this.address.hausnummer = hausnummer;
        this.address.plz = plz;
        this.address.wohnort = wohnort;
        this.address.land = land;
        System.out.println(this.address.strasse + " " + this.address.hausnummer + " " + this.address.plz + " "
                + this.address.wohnort + " " + this.address.land);
    }

    public int age(int age) {
        this.age = age;
        return age;
    }
   
   

}
```


```
class Name {
    String titel;
    String vorname;
    String nachname;
    String geburtsname;
}
```


```
class Address {

    String strasse;
    String hausnummer;
    int plz;
    String wohnort;
    String land;

}
```


```
class Father {

    Person child1;
    Person child2;
    Person child3;
   
    public Father() {
        super();
    }

    public Father(String titel, String vorname, String nachname, String geburtsname, String strasse, String hausnummer,
            int plz, String wohnort, String land) {
        super();
        System.out.println(titel+" "+vorname+" "+nachname+" "+geburtsname);
        System.out.println(strasse+" "+hausnummer+" "+plz+" "+wohnort+" "+land);
    }

   
       
  
    public Person getChild1() {
        return child1;
    }

    public void setChild1(Person child1) {
        this.child1 = child1;
    }

    public Person getChild2() {
        return child2;
    }

    public void setChild2(Person child2) {
        this.child2 = child2;
    }

    public Person getChild3() {
        return child3;
    }

    public void setChild3(Person child3) {
        this.child3 = child3;
    }
   
   
     
}
```



```
class Mother {

    Person child1;
    Person child2;
    Person child3;

    public Mother() {
        super();
    }

  public Mother(String titel, String vorname, String nachname, String geburtsname, String strasse, String hausnummer,
            int plz, String wohnort, String land) {
        super();
        System.out.println(titel + " " + vorname + " " + nachname + " " + geburtsname);
        System.out.println(strasse + " " + hausnummer + " " + plz + " " + wohnort + " " + land);
    }

    public Person getChild1() {
        return child1;
    }

    public void setChild1(Person child1) {
        this.child1 = child1;
    }

    public Person getChild2() {
        return child2;
    }

    public void setChild2(Person child2) {
        this.child2 = child2;
    }

    public Person getChild3() {
        return child3;
    }

    public void setChild3(Person child3) {
        this.child3 = child3;
    }

}
```


```
class PersonTest {

    public static void main(String[] args) {

        Father v1 = new Father("Herr", "Max", "Müller", "Otto", "Straße", "13", 10555, "Berlin",
                "Deutschland");

        Mother m1 = new Mother("Frau", "Laura", "Müller", "Lara", "Straße", "13", 10555, "Berlin",
                "Deutschland");
       
    }

}
```


Ich danke herzlichst für jede hilfreiche Antwort,

lg Sabine.


----------



## kneitzel (15. Jun 2020)

Was auffällt an Deinem Code:
a) Du hast bisher nirgends equals überschrieben. Zum Vergleichen von Instanzen musst Du equals überschreiben.
b) Father / Mother sollen Unterklassen von Person sein.
c) Person soll father / mother haben.

Zum Thema equals überschreiben gibt es einige Seiten...

Wenn father/mother vorhanden wären, dann kannst Du prüfen, ob z.B. der Father gleich ist:
`person1.getFather().equals(person2.getFather())`

Bei den einzelnen Methoden, die Du implementieren sollst, musst Du dann nur fragen, was erfüllt sein muss. Dazu kannst Du zum Beispiel dir die Logik aufmalen:

```
Vg, Mg, G, HG
 0,  0, 0,  0
 0,  1, 0,  1
 1,  0, 0,  1
 1,  1, 1,  0

mit:
Vg: Vater gleich
Mg: Mutter gleich
G: Geschwister
HG: Halbgeschwister
```


----------



## Sabine.Quast (15. Jun 2020)

.


----------



## Sabine.Quast (15. Jun 2020)

JustNobody hat gesagt.:


> Was auffällt an Deinem Code:
> a) Du hast bisher nirgends equals überschrieben. Zum Vergleichen von Instanzen musst Du equals überschreiben.
> b) Father / Mother sollen Unterklassen von Person sein.
> c) Person soll father / mother haben.
> ...



Danke für deine Antwort,

ich hab die Aufgabe oft neu begonnen und dabei dieses mal übersehen das Mother und Father keine Unterklassen sind. Ist jetzt korrigiert.

Meinst du mit Person soll Father/Mother haben, damit sie als Attribut setzen?

Wie weise ich dem Child ein Father zu, so dass ich sie dann später vergleichen kann?

Mein Gedanke wäre vlt so:
Father person1 = new Father();
person1.child1..... (Father zuweisen, aber wie anlegen das es mir nach dem Punkt vorgeschlagen und Father v1 ist mit all seinen Parametern?)

um dann später dein Vorschlag um die beiden zu vergleichen
person1.getFather().equals(person2.getFather())


----------



## mihe7 (15. Jun 2020)

Sabine.Quast hat gesagt.:


> ich hab folgendes Problem, ich muss Kinder anlegen und sie miteinander vergleichen ob sie Geschwister sind


Gut, dass das in einem Java-Forum steht...  



JustNobody hat gesagt.:


> a) Du hast bisher nirgends equals überschrieben. Zum Vergleichen von Instanzen musst Du equals überschreiben.



Das würde ich hier nicht unbedingt sagen. Evtl. soll es gerade um den Identitätsvergleich gehen. So könnten auch zwei Max Müller an der selben Adresse wohnen, z. B. in verschiedenen Familien. Wenn Person#equals dann für beide true liefert, wäre das ungünstig.


----------



## kneitzel (15. Jun 2020)

mihe7 hat gesagt.:


> Das würde ich hier nicht unbedingt sagen. Evtl. soll es gerade um den Identitätsvergleich gehen. So könnten auch zwei Max Müller an der selben Adresse wohnen, z. B. in verschiedenen Familien. Wenn Person#equals dann für beide true liefert, wäre das ungünstig.



Also ich möchte nicht ausschließen, dass dies hier in der Übung so ist - abhängig davon, ob das Thema equals bereits behandelt wurde.

Die Problematik selbst sehe ich nicht: Wenn unterschiedliche Familien, dann werden Vater / Mutter unterschiedlich sein.

Zwei unterschiedliche Personen mit gleichem Namen, Adresse, Alter und Eltern? Also bei Zwillingen beide Jungen gleich zu benennen halte ich doch für einen Fall, den man evtl. nicht berücksichtigen müsste.

Vater und Sohn mit gleichem Namen ("Junior" und "Senior" halt) wird sowohl durch das Alter als auch durch den Vater unterschiedlich sein.


----------



## Sabine.Quast (15. Jun 2020)

JustNobody hat gesagt.:


> Also ich möchte nicht ausschließen, dass dies hier in der Übung so ist - abhängig davon, ob das Thema equals bereits behandelt wurde.
> 
> Die Problematik selbst sehe ich nicht: Wenn unterschiedliche Familien, dann werden Vater / Mutter unterschiedlich sein.
> 
> ...



Also ich hab jetzt in Person Father father/ Mother mother und die Getter und Setter angelget.

In PersonTest hab ich jetzt versucht Childs anzulegen, test weise nur deren Vorname.

Person p1 = new Person();
	p1.father.child1.name.vorname ="Mely";

	Person p2 = new Person();
	p2.father.child1.name.vorname = "Mely";

Meine Frage ist nun wie übergebe ich sie der isSibling Methode so das ich sie vergleichen kann.

Das Thema euqals wurde nicht wirklich behandelt jedoch gehe ich stark davon aus das es in der Aufgabe essentiel ist.

lg. Sabine


----------



## kneitzel (15. Jun 2020)

Also erst einmal zu equals: https://www.geeksforgeeks.org/overriding-equals-method-in-java/ - Da siehst Du eine gute Möglichkeit, wie Du equals überschreibst. Ist halt immer das gleiche Schema:
1. Referenz prüfen - das geht schnell und erspart einem alle weiteren Tests. (Wenn wir vor dem selben Haus stehen, dann müssen wir nicht durch alle Räume gehen und alle Gegenstände miteinander vergleichen  )
2. Klasse der Instanz prüfen. (Wenn ich vor einem Hochhaus stehe und Du stehst vor einem Einfamilienhaus - dann müssen wir nicht vergleichen, ob sich die Häuser gleichen!)
3. Cast zur eigentlichen Klasse
4. Check aller Elemente. Aber Achtung: Was da noch fehlt ist der equals Aufruf auf der Parent Klasse bei Ableitungen. Father und Mother sind ja von Person abgeleitet, d.h. die Prüfung der Elemente aus Person ist ja in der equals Methode dort!)


Aber auf Grund Deines Codes denke ich mal, dass da einige Dinge nicht passen (`p1.father.child1.name.vorname ="Mely";`):
a) Wenn eine neue Person erstellt wird, dann sollte da der Vater erst einmal null sein. So lange Du keinen Vater übergeben hast, ist halt kein Vater bekannt. (p1.father.child1 Zugriffe müssten eine NullPointerException werfen!)
b) Die Instanzvariablen sollten private sein. Aus einer Testklasse dürftest Du also nicht auf die Variablen selbst zugreifen können!

Also der Code zum Testen sollte also sowas sein (Parameter in Konstruktoren habe ich mal weg gelassen, aber die solltest Du haben!):


```
Father father = new Father(...);
Mother mother = new Mother(...);

Person p1 = new Person(......);
p1.setFather(father);
p1.setMother(mother);

Person p2 = new Person(.....);
p2.setFather(father);
p2.setMother(mother);

// Nun hast Du zwei Instanzen p1/p2, die du prüfen kannst.
```

Und die Prüfung für Siblings ist natürlich: p1 hat den gleichen Vater wie p2 UND p1 hat die gleiche Mutter wie p2. Dies müsstest Du dann nur noch schreiben. (Wobei der Code hierfür ja schon fast in #4 steht!)

Aber ehe Du zu solchen Tests kommst, sollten andere Tests erfolgreich sein. So z.B. der Vergleich von Adressen. Also Tests wie:

```
Address address1 = new Address(...);
Address address2 = new Address(...); // Gleiche Parameter wie bei ersten Aufruf!
Assert.areEqual(address1, address2);

// Und dann noch sicher stellen, dass es nicht mehr gleich ist, sobald ein Wert unterschiedlich ist ...
// bei n Elementen sind das dann mind. n Tests mit Assert.areNotEqual.

// Wenn man null Werte mit testen möchte, dann wird es noch deutlich mehr, weil man dann für jeden Test
// noch die Fälle hat: beide null, nur erster null, nur zweiter null
```

Ob Du es so umfangreich aufbauen möchtest, musst Du für Dich entscheiden.
Aber die equals Methoden aller Klassen müssten halt getestet worden sein, denn darauf baust Du dann ja auf.


----------



## JennyL (15. Jun 2020)

Ich finde equals() für diese Aufgabe unangebracht. Jeder Mensch ist einzigartig, d.h. (genetisch) unterschiedlich. Es reicht für alle Operationen also aus, auf referentielle Gleichheit zu prüfen. Insofern hat @mihe7 völlig recht, und Nobody möchte wieder etwas implementieren was unnötig ist.


----------



## kneitzel (15. Jun 2020)

JennyL hat gesagt.:


> Ich finde equals() für diese Aufgabe unangebracht. Jeder Mensch ist einzigartig, d.h. (genetisch) unterschiedlich. Es reicht für alle Operationen also aus, auf referentielle Gleichheit zu prüfen. Insofern hat @mihe7 völlig recht, und Nobody möchte wieder etwas implementieren was unnötig ist.



Das ist super, das Du das so empfindest. Aber wer den Thread aufmerksam gelesen hat, der wird gelesen haben, dass @Sabine.Quast darauf auch schon reagiert hat und geschrieben hat:  "jedoch gehe ich stark davon aus das es in der Aufgabe essentiel ist."

Daher: Wenn sie meint, dass es essentiell für die Aufgabe ist, dann darf man das durchaus erwähnen, wie dies zu implementieren wäre.


----------



## mihe7 (15. Jun 2020)

@JennyL darum geht es nicht einmal:



JustNobody hat gesagt.:


> Die Problematik selbst sehe ich nicht: Wenn unterschiedliche Familien, dann werden Vater / Mutter unterschiedlich sein.


Den Objekten fehlt konzeptionell schlicht die Identität. Es ist schon ein Unterschied, ob ich nun der Bruder von jemandem bin, weil er die_selben_ Eltern hat oder seine Eltern nur zufällig genauso heißen, gleich alt sind und im gleichen Wohnblock wohnen  

equals() würde ich hier überschreiben, wenn ich letzteres haben wollte (value objects).

Kann natürlich sein, dass sich hinter der Aufgabe ein didaktisch besonders toller Ansatz verbergen soll. Keine Ahnung. 



JustNobody hat gesagt.:


> 4. Check aller Elemente. Aber Achtung: Was da noch fehlt ist der equals Aufruf auf der Parent Klasse bei Ableitungen. Father und Mother sind ja von Person abgeleitet, d.h. die Prüfung der Elemente aus Person ist ja in der equals Methode dort!)


Nochmal Achtung: hier muss man aufpassen, dass man nicht auch die child-Elemente vergleicht - sonst läuft man ggf. in eine Endlosschleife.


----------



## Sabine.Quast (15. Jun 2020)

JustNobody hat gesagt.:


> Also erst einmal zu equals: https://www.geeksforgeeks.org/overriding-equals-method-in-java/ - Da siehst Du eine gute Möglichkeit, wie Du equals überschreibst. Ist halt immer das gleiche Schema:
> 1. Referenz prüfen - das geht schnell und erspart einem alle weiteren Tests. (Wenn wir vor dem selben Haus stehen, dann müssen wir nicht durch alle Räume gehen und alle Gegenstände miteinander vergleichen  )
> 2. Klasse der Instanz prüfen. (Wenn ich vor einem Hochhaus stehe und Du stehst vor einem Einfamilienhaus - dann müssen wir nicht vergleichen, ob sich die Häuser gleichen!)
> 3. Cast zur eigentlichen Klasse
> ...




Dein Code hat hat mich zur Lösung der Aufgabe geführt. Ich war mir bei Getter und Setter sehr unsicher und hab  versucht es ohne sie  zulösen, aber scheinbar ist es damit viel einfacher.



Also equals und überladen wurde letztens kurz behandelt, deswegen bin ich davon ausgegangen, das es zur Lösung führt. Da Vergleichsoperatoren nicht funktionierten.
Doch jetzt Funktionieren beide Varianten. 
Welche davon wäre angebrachter?
 Ich sehe da nicht so ganz den unterschied, außer das der untere anfangs nicht ging. Was für Probleme könnte equals verursachen?

if(this.getFather().equals(p.getFather()) && this.getMother().equals(p.getMother())) {return true;}

	if(this.getFather()== p.getFather() && this.getMother()==p.getMother()) {return true;}


----------



## mihe7 (15. Jun 2020)

Also, die Objekte stehen ja irgendwo im Speicher. Der Referenzvergleich (==) prüft, ob die Adressen identisch sind. Falls ja  handelt es sich um das selbe(!) Objekt. Mit equals kannst Du Objekte auf inhaltliche Gleichheit hin überprüfen (wenn Du equals überschreibst). D. h. Du kannst verschiedene Objekte mit gleichem Inhalt haben, dann liefert equals() true, während "==" false liefert.


```
public static void main(String[] args) {
    String a = "X";
    String b = a;
    System.out.println(a == b);
    System.out.println(a.equals(b));
 
    a = new String("X");
    b = new String("X");
    System.out.println(a == b);
    System.out.println(a.equals(b));
```


----------



## kneitzel (15. Jun 2020)

mihe7 hat gesagt.:


> @JennyL darum geht es nicht einmal:
> Den Objekten fehlt konzeptionell schlicht die Identität. Es ist schon ein Unterschied, ob ich nun der Bruder von jemandem bin, weil er die_selben_ Eltern hat oder seine Eltern nur zufällig genauso heißen, gleich alt sind und im gleichen Wohnblock wohnen



Also die fehlende Identität sehe ich ebenso. Daher kann es durchaus sein, dass die equals Implementation hier nicht gefordert ist da bei so Aufgaben typischer Weise alles im Speicher gehalten wird und nur einmal erzeugt wird. Es kommt also (hoffentlich) nicht dazu, dass zwei Instanzen einer Person existieren werden. Aber das ist hier generell problematisch, denn ich kann ja eine Instanz von Person haben. Diese Person bekommt nun ein Kind, also erstelle ich eine Instanz von Father und habe dann zwei Instanzen für einen Menschen. Einmal eine Instanz von Person und zum anderen die Instanz von Father.

Das ganze OO Design in dieser Aufgabe sehe ich also durchaus als kritisch an.

Daher stellt sich wirklich die Frage, was denn im Detail durch diese Aufgabe bezweckt werden soll. 

Aber Deine Problematik, die Du beschreibst, kann ich nicht nachvollziehen, denn dein Vergleich ist nicht vollständig. Denn bei dem Vergleich von Personen vergleichst Du:
- die Eltern
- Name
- Adresse
- Alter
-> Bei den Elternteilen finden ebenso eine Prüfung statt, also eben nicht "Eltern durch Zufall ebenso heißen". Eltern sind ja auch Personen! 



mihe7 hat gesagt.:


> Nochmal Achtung: hier muss man aufpassen, dass man nicht auch die child-Elemente vergleicht - sonst läuft man ggf. in eine Endlosschleife.



Ja, das ist auch ein wichtiger Punkt. Auf Grund dieses Punktes würde ich auch dazu tendieren, hier das equals nicht zu überschreiben. Denn ganz offensichtlich wurde es noch nicht so in der Tiefe behandelt, als das diese Problematik von den Schülern zu lösen wäre.


----------



## kneitzel (15. Jun 2020)

Sabine.Quast hat gesagt.:


> if(this.getFather().equals(p.getFather()) && this.getMother().equals(p.getMother())) {return true;}
> 
> if(this.getFather()== p.getFather() && this.getMother()==p.getMother()) {return true;}



Also meiner Meinung nach (auf Grund der Komplexität von equals speziell bei Father und Mother) glaube derzeit nicht, dass dies von euch zu implementieren ist. Daher würde ich an Deiner Stelle equals in den Klassen nicht überschreiben. (Aber das ist Deine Entscheidung. Wenn Du der Meinung bist, das die Aufgabe dies explizit fordert, dann ist es etwas Anderes.)

Und wenn Du equals nicht überschreibst, dann sind beide Zeilen von der Wirkung her gleich, denn das equals von Object macht dann nichts anders.

Da aber Instanzen per equals verglichen werden sollen, würde ich zu der ersten Variante neigen mit dem equals Aufruf. Aber das kann jeder so sehen, wie er will.


----------



## mihe7 (15. Jun 2020)

JustNobody hat gesagt.:


> -> Bei den Elternteilen finden ebenso eine Prüfung statt, also eben nicht "Eltern durch Zufall ebenso heißen". Eltern sind ja auch Personen!


Ich kann Dir nicht folgen - worauf willst Du hinaus? Dass es sehr unwahrscheinlich ist, vier Leute mit gleicher Adresse, gleichen Namen, gleichem Alter und gleicher Beziehung zueinander zu haben? Ja, das ist wohl wahr.


----------



## Sabine.Quast (15. Jun 2020)

JustNobody hat gesagt.:


> Also die fehlende Identität sehe ich ebenso. Daher kann es durchaus sein, dass die equals Implementation hier nicht gefordert ist da bei so Aufgaben typischer Weise alles im Speicher gehalten wird und nur einmal erzeugt wird. Es kommt also (hoffentlich) nicht dazu, dass zwei Instanzen einer Person existieren werden. Aber das ist hier generell problematisch, denn ich kann ja eine Instanz von Person haben. Diese Person bekommt nun ein Kind, also erstelle ich eine Instanz von Father und habe dann zwei Instanzen für einen Menschen. Einmal eine Instanz von Person und zum anderen die Instanz von Father.
> 
> Das ganze OO Design in dieser Aufgabe sehe ich also durchaus als kritisch an.
> 
> ...



Ich versteh nicht so ganz die Problematik. In der main werden ja Eltern erstellt mit Parametern und Kindern, dennen die Eltern zugewiesen werden. Also sind ja die Eltern nicht zufällig oder meinst du das father3 mit den selben Parametern wie father1, als father1  gehalten wird?

Die Eltern dürfen maximal 3 Kinder haben, dafür legt man ja die Attribute child1,child2,child3.  Wie setze ich ein limit ein das nur 3 Kinder erstellt werden können ?


----------



## mihe7 (15. Jun 2020)

Sabine.Quast hat gesagt.:


> Ich versteh nicht so ganz die Problematik.




```
Father v1 = new Father("Herr", "Max", "Müller", "Otto", "Straße", "13", 10555, "Berlin",
                "Deutschland");
        Father v2 = new Father("Herr", "Max", "Müller", "Otto", "Straße", "13", 10555, "Berlin",
                "Deutschland");
```
Das Modell ist über Inhaltsvergleiche nicht in der Lage, diese beiden Väter auseinander zu halten -> schlecht. Hier könnte man z. B. die Ausweisnummer mit einführen, dann wäre klar, ob es sich um den selben oder zwei verschiedene Väter handelt.


----------



## Sabine.Quast (15. Jun 2020)

mihe7 hat gesagt.:


> ```
> Father v1 = new Father("Herr", "Max", "Müller", "Otto", "Straße", "13", 10555, "Berlin",
> "Deutschland");
> Father v2 = new Father("Herr", "Max", "Müller", "Otto", "Straße", "13", 10555, "Berlin",
> ...




Danke, ich füg noch eine  Ausweisnummer hinzu. 

Ich hab der Person p3 einen Vater zugeordnet, jedoch weiß ich nicht wie p3 den platz für child 1 belegen soll, da die Eltern nur 3 Kinder haben dürfen.
So wie es aussieht kann ich p3  der Klasse Father in Child1 zuweisen aber das ist ja allgemein und nicht für bestimmte Eltern, was es ja sein sollte oder?
    p3.getFather().setChild1(p3);


----------



## mihe7 (15. Jun 2020)

Sabine.Quast hat gesagt.:


> Danke, ich füg noch eine Ausweisnummer hinzu.


Ach, das könnt Ihr Euch aussuchen?!? Na, dann


----------



## JennyL (15. Jun 2020)

JustNobody hat gesagt.:


> Daher: Wenn sie meint, dass es essentiell für die Aufgabe ist, dann darf man das durchaus erwähnen, wie dies zu implementieren wäre.


Ich denke mal, sie wollte nur freundlich sein und hat sich nicht getraut dir zu widersprechen. Ich hab damit allerdings keine Probleme...

Also es wäre schon sinnvoll eine Art ID zu definieren (sozusagen das Genom, wenn man so will) und damit zu vergleichen. Das Problem ist, dass über gleichem Namen + gleicher Adresse nur eine etwaige Gleichheit definiert ist (also mit hoher Wahrscheinlichkeit sind zwei Personen mit demselben Namen und derselben Adresse gleich, jedoch nicht ohnehin) - keine Identität. equals() ist per default bereits richtig implementiert. Wenn du nun anrätst, equals() speziell zu überschreiben, verwässerst du den Identitäts-/Gleichheits-Begriff.

Irgendwann soll eine Datenbank aufgebaut werden und beim anschließenden Wiederverwenden der Daten kracht es dann...

Hinsichtlich der Aufgabenstellung konnte ich auch keinen Hinweis erkennen, ob und wenn ja wie equals() überschrieben werden sollte oder nicht, bzw, wie denn die "Gleichheit" definiert ist. Daher nehme ich einfach die default Definition an: Zwei Personen sind gleich wenn es sich um dasselbe Objekt handelt... Dafür kann entweder "==" oder "equals()" aufgerufen werden...


----------



## kneitzel (15. Jun 2020)

JennyL hat gesagt.:


> Irgendwann soll eine Datenbank aufgebaut werden und beim anschließenden Wiederverwenden der Daten kracht es dann...



Und gerade dann knallt es, wenn equals nicht implementiert wurde, denn wenn eine Person zwei Mal aus der Datenbank geladen wurde, sind diese zwei Instanzen eben bei Deinem Vergleich nicht mehr gleich. Spätestens mit der Datenbank wird man dann aber eine ID eingeführt haben, so dass diese Diskussion so hoffentlich nicht zum tragen kommen wird.

Und die Wahrscheinlichkeit, dass zwei Personen:
- gleich heißen,
- die gleichen Eltern haben (Vergleichen mit Name, Adresse, Alter, Eltern, ...)
- das gleiche Alter
- die gleiche Adresse
ist extrem unwahrscheinlich bis unmöglich. Wie gesagt: Das setzt voraus, dass die Eltern in einem Jahr zwei Kinder bekommen haben und diese dann gleich benannt haben.

Die Wahrscheinlichkeit dürfte sogar noch deutlich geringer sein, als die Wahrscheinlichkeit, dass zwei generierte UUIDs gleich sind.... Nur um eine andere Sache ins Spiel zu bringen, die eben extrem unwahrscheinlich aber nicht ausgeschlossen ist und wo diese Wahrscheinlichkeit in der Praxis keine Rolle spielt.

Aber das müssen wir nicht weiter vertiefen. Auf Grund des schlechten Designs schließe ich aus, das hier equals Methoden implementiert werden sollen. Die Problematik ist halt
- zum einen die Children bei Father / Mother, die dann ja erneut die Parents prüfen.
- die Prüfung der Eltern, die so ja eine enorme Kette bilden bis halt mal keine Eltern gesetzt sind. (@mihe7 Das war wohl der Grund, warum du da direkt eine abgespeckte Prüfung haben wolltest nur auf Namen basierend oder so ... aber wie weit man Checks hier treibt ist ja erst einmal offen.)


----------



## mihe7 (15. Jun 2020)

Sorry, für die späten Antwort - bin beschäftigt. Nachdem wir ja alle so schön am Philosophieren sind, daher nur kurz: https://de.wikipedia.org/wiki/Schiff_des_Theseus


----------



## Meniskusschaden (20. Jun 2020)

JustNobody hat gesagt.:


> Und die Wahrscheinlichkeit, dass zwei Personen:
> - gleich heißen,
> - die gleichen Eltern haben (Vergleichen mit Name, Adresse, Alter, Eltern, ...)
> - das gleiche Alter
> ...


Na ja, sie müssen es nicht unbedingt selbst gewesen sein, die beide Kinder gleich benannt haben. Nehmen wir mal an, Antje und Andreas bekommen Zwillinge. Berta und Bernd werden am selben Tag ebenfalls Eltern. Nun wird kurz nach der Geburt noch vor der Namensvergabe ein Zwilling versehentlich mit Bertas und Bernds Sohn vertauscht. Antje und Andreas nennen ihr eigenes Kind Anton und ihr vermeintliches Kind Bastian. Berta und Bernd nennen ihren vermeintlichen Sohn auch Anton. Es musste so kommen, denn beide Zwillinge sahen einfach exakt so aus, wie man sich einen Anton vorstellt. Nach 10 Jahren fällt das ganze auf. Glücklicherweise verstehen sich alle Beteiligten gut und man beschließt eine pragmatische Lösung. Die Elternschaften werden gemäß dem biologischen Ursprung neu geordnet. Es ist Anton natürlich nicht zuzumuten, nach so langer Zeit einen neuen Namen anzunehmen, so dass er seinen Namen behalten darf. Beide Eltenpaare und die Kinder wollen sich aber nicht vom jeweils "falschen" Angehörigen trennen. Deshalb beschließen beide Familien, einfach gemeinsam in dasselbe Haus zu ziehen, womit sämtliche Probleme gelöst sind - mit Ausnahme der eindeutigen Identifikation der beiden Antons.


----------

