Vererbung in zwei Richtungen?

[ffghts]

Hallo, ich bin neu hier im Forum und habe folgende Frage an euch:

Wir haben in der Schule eine Aufgabe bekommen, dass wir eine Person modellieren sollen. Das habe ich gemacht, indem ich eine Person Klasse erstellt habe, mit diversen Attributen. Die nächste Aufgabe ist dann, dass eine Person verschiedene Verwandtschaftsbeziehungen hat. Nun soll ich eine Einfügelogik erstellen, die automatisch die Beziehung vom Elternteil zum Kind und vom Kind zum Elternteil erstellt.
Ich dachte, dass ich das mit einer Eltern Klasse und einer Kinder Klasse realisiere, die beide von der Klasse Person erben, aber irgendwie habe ich mich da festgefahren und komme einfach nicht weiter.
Hoffe, dass vielleicht jemand einen Tipp für mich hat.

Grüße

 

[Tobse]

Dein Ansatz hört sich erstmal nicht so falsch an. Wo hängts denn? Zeig mal ein wenig code, dann können wir mehr sagen

 

[ffghts]

Das ist meine Person Klasse.
Das Datum und die Adresse werden über Assoziation aus zwei anderen Klassen geholt.

public class Person {

    private int personalNummer;
    private String anrede;
    private String name;
    private String vorname;

    private Datum todesdatum = null;
    private Datum geburtsdatum = null;
    private Adresse adresse = null;

    public int getPersonalNummer() {
        return personalNummer;
    }

    public void setPersonalNummer(int personalNummer) {
        this.personalNummer = personalNummer;
    }

    public String getAnrede() {
        return anrede;
    }

    public void setAnrede(String anrede) {
        this.anrede = anrede;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getVorname() {
        return vorname;
    }

    public void setVorname(String vorname) {
        this.vorname = vorname;
    }

    public void setTodesdatum(Datum todesdatum) {
        this.todesdatum = todesdatum;
    }

    public Datum getTodesdatum() {
        return this.todesdatum;
    }

    public void setGeburtsdatum(Datum geburtsdatum) {
        this.geburtsdatum = geburtsdatum;
    }

    public Datum getGeburtsdatum() {
        return geburtsdatum;
    }

    public void setAdresse(final Adresse adresse) {
        this.adresse = adresse;
    }

    public Adresse getAdresse() {
        return adresse;
    }

    public Person(int personalNummer, String anrede,String vorname, String name) {
        this.setPersonalNummer(personalNummer);
        this.setAnrede(anrede);
        this.setVorname(vorname);
        this.setName(name);
    }

    public String printAll() {
        String person = "Perosnalnummer: " + String.valueOf(personalNummer) + "\n" +
                        "Anrede: " + anrede + "\n" +
                        "Vorname: " + vorname + "\n" +
                        "Nachname: " + name + "\n" +
                        "Adresse: " + adresse + "\n" +
                        "Geburtsdatum: " + geburtsdatum + "\n" +
                        "Todesdatum: " + todesdatum + "\n";
        return person;
    }
}

Nun habe ich eine Eltern Klasse erstellt, die folgendes beinhaltet:

public class Eltern extends Person {

    public Eltern(int personalNummer, String anrede, String vorname, String name) {
        super(personalNummer, anrede, vorname, name);
    }

    public void elternTeilVon() {

    }
}

Mein Problem ist, dass ich nicht genau weiss, wie ich eine Einfügelogik erstelle, die automatisch die Verwandtschaftsbeziehung erstellt. Wenn ich eine neue Person erstelle und die eine Tochter hat, die aber im meinem Programm gar nicht existiert, wie kann ich dann automatisch eine Beziehung erstellen?

Grüße

 

[Jardcore]

Falls du an die Stelle kommst in der du möchtest das ein Kind von Mutter und Vater erbt... das ist in Java nicht möglich. Mehrfachvererbung wird nicht unterstützt.
Folgende Vererbung ist rein Programmiertechnisch.
Kind extends Eltern
Eltern extends Person

Folgendes Beispiel zeigt eine Modellierung die eher an dein Beispiel dran ist. Die Frage ist aber wie genau ist die Aufgabe gestellt?

public class Mutter extends Person {
    @Override
    public void addKind(Person kind) {
        super.addKind(kind);
        kind.setMutter(this);
    }
}

public class Vater extends Person {
    @Override
    public void addKind(Person kind) {
        super.addKind(kind);
        kind.setVater(this);
    }
}

public class Person {
    private Vater vater;
    private Mutter mutter;
    private List<Person> kinder;

    public Person(Vater vater, Mutter mutter) {
        this.vater = vater;
        this.mutter = mutter;
        kinder = new ArrayList<>();
    }

    public void addKind(Person kind) {
        kinder.add(kind);
    }
    // setter, getter
}

 

[ffghts]

Danke für deine Antwort Jardcore,

da in Java die Mehrfachvererbung nicht möglich ist, habe ich versucht, es neutral zu halten. Indem ich statt Mutter, oder Vater einfach nur Elternteil sage.
Da meine Beschreibung vielleicht Verwirrung stiftet, hier die genaue Aufgabenstellung:

Eine Person hat div. Verwandschaftsverhältnisse.
1. Bilden sie die Verwandschaft an der Person ab. Bedenken sie, dass die
Verwandschaftsbeziehungen in beide Richtungen darzustellen sind (z.B.
von der Mutter zu Tochter UND von der Tochter zur Mutter).
2. Erstellen sie eine entsprechende Einfügelogik, um die Verknüpfungen
automatisch in beide Richtungen zu erstellen.

Grüße

 

[Jardcore]

Hab mein Beispiel noch etwas erweitert. Schau mal ob deine Logik jetzt abgebildet wird.
Ich bin dabei davon ausgegangen das eine Person immer Mutter und Vater hat und eine Person kann eine noch nicht definierte Anzahl von Kindern haben (Liste).

 

[Tobse]

Ich denke hier ist so etwas gemeint:

class Person {
  // ...
  private Person mutter;
  private Person vater;
  private List<Person> kinder;

  public void addKind(Person kind) {
     kinder.add(kind);
     if (geschlecht == MAENNLICH) {
        kind.setVater(this);
     } else {
        kind.setMutter(this);
     }
  }

  public void setMutter(Person mutter) { this.mutter = mutter; }
  public void setVater(Person vater) { this.vater= vater; }
}

P.S.: und kommt mir hier blos nicht mit gender-korrekten varianten hiervon...

 

[Tobse]

Hab mein Beispiel noch etwas erweitert. Schau mal ob deine Logik jetzt abgebildet wird.
Ich bin dabei davon ausgegangen das eine Person immer Mutter und Vater hat und eine Person kann eine noch nicht definierte Anzahl von Kindern haben (Liste).

Da haben wir beide gleichzeitig das selbe gepostet...

 

[Jardcore]

Um dich gänzlich zu verwirren hier noch mit Interface

public interface KannKinderHaben {
    public void addKind(Person kind);
}

public class Mutter extends Person implements KannKinderHaben {
    @Override
    public void addKind(Person kind) {
        kinder.add(kind);
        kind.setMutter(this);
    }
}

public class Vater extends Person implements KannKinderHaben {
    @Override
    public void addKind(Person kind) {
        kinder.add(kind);
        kind.setVater(this);
    }
}

public class Person {
    protected Vater vater;
    protected Mutter mutter;
    protected List<Person> kinder;

    public Person(Vater vater, Mutter mutter) {
        this.vater = vater;
        this.mutter = mutter;
        kinder = new ArrayList<>();
    }
    // setter, getter
}

Finde man könnte Kind noch besser modellieren Aber für den Anfang reichts erstmal ^^

 

[ffghts]

Interfaces dürfen wir noch nicht verwenden, aber trotzdem danke.
Ich denke ich werde mit euren Ansätzen erstmal weiter kommen, wenn nicht, melde ich mich nochmal.
Vielen dank euch beiden.

Grüße

 

[mrBrown]

public class Mutter extends Person implements KannKinderHaben {
    @Override
    public void addKind(Person kind) {
        kinder.add(kind);
        kind.setMutter(this);
    }
}

Man kann kind.setX(this) weglassen, das ist ja dadurch schon gesetzt:

public class Person {
    protected Vater vater;
    protected Mutter mutter;
    protected List<Person> kinder;

    public Person(Vater vater, Mutter mutter) {
        this.vater = vater;
        this.mutter = mutter;
        kinder = new ArrayList<>();
    }
    // setter, getter
}

Finde man könnte Kind noch besser modellieren Aber für den Anfang reichts erstmal ^^

Und dann muss man hier im Konstruktor nur noch addKind aufrufen. Dann sieht man die Codeduplizierung und lässt Mutter und Vater als zusätzliche Klassen noch weg

 

[Jardcore]

Stimmt du hast recht. Das würde dann einfach so aussehen.

public class Person {
   private Person vater;
   private Person mutter;
   private List<Person> kinder;

   public Person(Person vater, Person mutter){
       this.vater = vater;
       this.mutter = mutter;
       this.vater.addKind(this);
       this.mutter.addKind(this);
       kinder = new ArrayList<>();
   }

   public void addKind(Person kind){
        kinder.add(kind);
   }
}

public class BiblischeGeschichte {
    public static void main(String[] args) {
        Person adam = new Person(null, null);
        Person eva = new Person(null, null);
        Person kain = new Person(adam, eva);
        Person abel = new Person(adam, eva);
        Person set = new Person(adam, eva);

        Person gott = new Person(null, null);
        gott.addKind(adam);
        gott.addKind(eva);
        // jetzt hat Gott zwar Kinder aber die Kinder keine Eltern... traurig

        kain.werfeSteinAuf(abel);
    }
}

 

[mrBrown]

Und wirft direkt 'ne NPE

 

[Jardcore]

public class Person {
   private Person vater;
   private Person mutter;
   private List<Person> kinder = new ArrayList<>();

   public Person(Person vater, Person mutter){
       this.vater = vater;
       this.mutter = mutter;

       if(vater != null) {
           this.vater.addKind(this);
       }
     
       if(mutter != null) {
           this.mutter.addKind(this);
       }
   }

   public void addKind(Person kind) {
       if(kind != null) {
           kinder.add(kind);
       }
   }
}

so jetzt siehts aber nicht mehr so schön aus ^^

 

[ffghts]

Habe das Problem nun dank euch lösen können.
Ich danke euch vielmals.

Grüße