Zwei Klassen die sich gegenseitig referenzieren - Bad practice?

[JuriW]

Ich hoffe meine Frage / Unklarheit Thema ist schon verständlich genug ... Ein Beispiel hierfür:

// HUMAN CLASS ===================================

import java.util.ArrayList;

public class Human {

    private String name;
    private ArrayList<Cat> cats = new ArrayList<>();

    public Human(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void buyCat(Cat c){
        cats.add(c);
        c.setMaster(this);
    }

    public ArrayList<Cat> getCats() {
        return cats;
    }

    @Override
    public String toString() {
        return name;
    }  
}


// CAT CLASS ===================================

public class Cat {

    private String name;
    private Human master;

    public Cat(String name) {
        this.name = name;
    }

    public Human getMaster() {
        return master;
    }

    public void setMaster(Human master) {
        this.master = master;
    }

    @Override
    public String toString() {
        return name;
    }
}

// MAIN CLASS ===================================

public class Home {

    public static void main(String[] args) {
        Human h1 = new Human("Mike");
        Cat c1 = new Cat("Triny");
        Cat c2 = new Cat("Neo");

        h1.buyCat(c1);
        h1.buyCat(c2);

        for (Cat c : h1.getCats()) {
            System.out.println(c + "'s master is " + h1.getName());
        }

        System.out.println(h1 + " has " + h1.getCats());
    }
}

// ===================================

public class Main {

    public static void main(String[] args) {
        Human h1 = new Human("Mike");
        Cat c1 = new Cat("Triny");
        Cat c2 = new Cat("Neo");

        h1.buyCat(c1);
        h1.buyCat(c2);

        for (Cat c : h1.getCats()) {
            System.out.println(c + "'s master is " + h1.getName());
        }

        System.out.println(h1 + " has " + h1.getCats());
    }
}

Können sich Probleme dadurch ergeben, dass Human und Cat sich gegenseitig referenzieren? Falls ja, wie umgehe ich das?

 

[AndiE]

An sich ist das so OK. Ich würde das für eine "one-to-many"-Beziehung halten, die bidirektional ist. Man würde wahrscheinlich "onetomany" und "onetoone" als Annotationen festlegen.

 

[mrBrown]

Auf lange Sicht kann das zu Problemen führen, je nachdem wie sich das Programm weiter entwickelt. Sowohl auf technischer Seite (zB lassen die sich damit nicht mehr auf verschwinde Module aufteilen), als auch von Seiten des Programmierers, weil meist dazu führt, dass das ganze deutlich schwieriger zu überblicken ist.


In so einem kleinen Beispiel klappt das aber üblicherweise Problemlos.



Die statischen zirkulären Abhängigkeiten kann man durch Nutzung von Interfaces vermeiden.
Aktuell hätte man Cat->Human und Human->Cat, wenn man zB eine Animal-Interface einführt, hätte man Cat->Animal, Cat->Human und Human->Animal, also nur noch Abhängigkeiten in eine Richtung.

Meist macht es aber auch Sinn, das ganze ohne bidirektionale Beziehungen zu designen.
Um das Katzen-Menschen-Beispiel etwas abzuwandeln: angenommen, man braucht für einen Menschen alle seine Katzen und muss für eine Katze deren Besitzer finden. Lässt sich einerseits über eine bidirektionale Beziehung realisieren, man kann es aber auch auf die Beziehung Mensch->Katze beschränken, und um für eine Katze deren Besitzer braucht, führt man etwas wie „Tasso“ ein, wo man dann nachfragen kann.

 

[JuriW]

Super, vielen Dank für die Antworten soweit!

// HUMAN CLASS ===================================
import java.util.ArrayList;

public class Human {

    private String name;
    private ArrayList<Animal> animals = new ArrayList<>();

    public Human(String name) {
        this.name = name;
    }

    public void buyAnimal(Animal a) {
        animals.add(a);
        a.setMaster(this);
    }

    public ArrayList<Animal> getAnimals() {
        return animals;
    }

    @Override
    public String toString() {
        return name;
    }
}


// CAT CLASS ===================================
public class Cat implements Animal {

    private String name;
    private Human master;

    public Cat(String name) {
        this.name = name;
    }

    public Human getMaster() {
        return master;
    }

    public void setMaster(Human master) {
        this.master = master;
    }

    @Override
    public String toString() {
        return name;
    }
}

// ANIMAL INTERFACE ===================================
public interface Animal {
    void setMaster(Human h);
    Human getMaster();
}

// MAIN CLASS ===================================
public class Main {

    public static void main(String[] args) {
        Human h1 = new Human("Mike");
        Animal c1 = new Cat("Triny");
        Animal c2 = new Cat("Neo");

        h1.buyAnimal(c1);
        h1.buyAnimal(c2);

        for (Animal a : h1.getAnimals()) {
            System.out.println(a + "'s master is " + a.getMaster());
        }

        System.out.println(h1 + " has " + h1.getAnimals());
    }
}

@mrBrown meinst du das so? Falls ja, kannst du mir erklären inwiefern mir das Interface hilft?

Wenn ich sowas wie eine Tasso Klasse hätte, hätte ich ja wieder die gleiche Abhängigkeit wie vorher, oder nicht? Oder hättest du dann den "Master" bei der Katze als Attribut weggelassen und in der Tasso Klasse eine Map mit einem Tier als Key und einem Besitzer als Value erstellt?

 

[mrBrown]

Falls ja, kannst du mir erklären inwiefern mir das Interface hilft?

In dem Fall löst es zwar nicht gänzlich die zirkuläre Abhängigkeit, aber Human muss nicht mehr einzelne Tiere kennen. Die einzelnen Tiere können dann zB in einem anderen Modul als Human liegen, was vorher nicht möglich war (wobei Animal in dem gleichen Package liegen muss).

Wenn ich sowas wie eine Tasso Klasse hätte, hätte ich ja wieder die gleiche Abhängigkeit wie vorher, oder nicht? Oder hättest du dann den "Master" bei der Katze als Attribut weggelassen und in der Tasso Klasse eine Map mit einem Tier als Key und einem Besitzer als Value erstellt?

Ja, das wäre ein Weg. Die Klasse könnte auch einfach alle Besitzer fragen, ob ihnen die Katze gehört, oder irgendwas anderes.