Beziehungen erstellen?

[Tyler**]

Hi,

hab ein Problem für Anfänger (bin einer :wink: )

Also ich möchte Beziehungen zwischen verschiedenen Objekten herstellen. Diese Objekte sind dabei Menge einer Klasse unterschiedlicher Hierarchie.

Bsp. Besitztümer von Gruppen o.ä.

Ich habe eine Oberklasse mit zwei Unterklassen. Die Unterklassen haben jeweils nochmals Unterklassen usw.

also:

class Oberklasse ...

class Unterklasse1 extends Oberklasse ...

class Unterklasse2 extends Oberklasse ...

class Unter1UnterKlasse1 extends Unterklasse1 ...

class Unter2UnterKlasse1 extends Unterklasse1 ...

class Unter1UnterKlasse2 extends Unterklasse2 ...

class Unter2UnterKlasse2 extends Unterklasse2 ...

Nun habe ich ein Objekt z.B. von der Unter1Unterklasse1. Ich möchte irgendwie eine Verbindung herstellen zwischen diesem Objekt und einem Objekt einer anderen Klasse, z.B. soll der Unter1Unterklasse1 ein Objekt aus Unter1Unterklasse2 gehören, in ihrem Besitz sein.

Unter1Unterklasse1 m = new Unter1Unterklasse1();

m.besitzt.neu(var); //mit var ein Objekt aus einer beliebigen Unterklasse
// diese zweite Anweisung neu() soll var zum Besitz von m erklären.

Wie mache ich das? Wo muss die Methode neu() definiert werden? Und wie ist .besitzt zu handhaben?

Danke für eure Hilfe :toll:

 

[Wildcard]

Ohne mich jetzt darüber äussern zu wollen ob ich das was ich von deiner Erklärung verstanden habe als sinnvoll erachte oder nicht:
Was soll .besitzt denn bitte sein?

 

[Roar]

ähh wenn ich dich richtig verstehe willst du nur dass Unter1UnterKlasse1 eine referenz auf ein opbjekt von Unter1UnterKlasse2 hat oder was?

 

[Tyler**]

ähh wenn ich dich richtig verstehe willst du nur dass Unter1UnterKlasse1 eine referenz auf ein opbjekt von Unter1UnterKlasse2 hat oder was?

ja, so in etwa!

m.besitzt.neu(var);

das besitzt zeigt an, was sich gerade im Besitz von m befindet! Und neu() soll einfach etwas hinzufügen.

 

[Wildcard]

du willst mit neu also eine Referenz auf ein Object hinzufügen?
dann braucht m eine Collection (z.B. ArrayList) und eine neu(Object o) (nenn sie besser add(Object o)) Methode um etwas hinzuzufügen.

 

[Tyler**]

du willst mit neu also eine Referenz auf ein Object hinzufügen?
dann braucht m eine Collection (z.B. ArrayList) und eine neu(Object o) (nenn sie besser add(Object o)) Methode um etwas hinzuzufügen.

richtig. referenz auf ein objekt (wenn man das so nennt :wink: ) das macht Sinn. An ein Array hatte ich gar nicht gedacht. Mir schwebte eher ein String vor, den ich dann einfach immer um ein neues Objekt ergänze.

wo definiere ich nun dieses Array, im Konstruktor?

Eine gegenseitige Beziehung wäre auch nicht schlecht, Objekt A besitzt Objekt B und umgekehrt wird B von A besessen

 

[Illuvatar]

*g Das klingt nach Horrorfilm *Hilfe ich bin besessen*

...Nun gut, zum Topic
Statt einem Array wäre eine ArrayList sinnvoller, da diese beliebig erweiter-/schrumpfbar ist, ein Array hat eine feste Größe. Eine ArrayList ist eine Klasse und hat Methoden wie add remove size usw, schau in der API. Diese (ArrayList) initialisierst du am besten im Konstruktor, aber speichern musst du sie als Membervariable, also innerhalb der Klassendefinition.

 

[KSG9|sebastian]

Mir schwebte eher ein String vor, den ich dann einfach immer um ein neues Objekt ergänze.

/me macht die Augen zu und rennt weg ;D

Einen String dem du ein neues Objekt hinzufügst *wuah*
Das was Illuvatar gesagt hat ist die korrekte Lösung.
Die andere Möglichkeit(bei einer 1:1-Beziehung) wäre eben ein Objekt vom Typ oberklasse oder was auch immer..


aber mal was anderes: Kannst du mir ein einziges Beispiel nennen bei dem es auch nur annähernd sinnvoll ist so ne Vererbungsstruktur zu benutzen ?

 

[Tyler**]

Nicht lachen! :wink:

bei dem String war natürlich jedes Objekt mit einem Namen versehen!

also Ausgabe "m gehört: nameobj1, nameobj2..."

und die Methode add(var) fügt dann dem String(?) besitzt var hinzu ( besitzt += var; ... oder so)

btw, ArrayList haben wir noch nicht gehabt, muss also noch eine andere Lösung geben! edith sagt: haben wir doch gehabt bzw. nebenbei erwähnt!

Bsp: Allgemeine Dinge --> Unterteilung in Mensch und Gegenstände, Gegenstände unterteilt in z.B. Auto, Haus etc. Und nun soll der Mensch ein Auto besitzen, er mit der Eigenschaft des Besitzens ausgestattet sein, und das Auto soll im Besitz des Menschen sein, das heißt, die Eigenschaft des Bessesenseins besitzen etc.

Dies soll durch Abfragen dann ausgegeben werden (anfangs wird es initialisiert, ob vom Benutzer eingegeben oder direkt im Quellcode angegeben, ist dabei egal)

 

[Gast]

da es mir anscheinend heute seeehr langweilig zu sein scheint, habe ich dir mal was zusammengeschustert. wenn du dir den quelltext genau anschaust, siehst du eine (aber sicherlich nicht die schönste..) möglichkeit beziehungen zwischen verschiedenen klassen herzustellen. du hast eine klasse 'welt' mit den daraus abgeleiteten klassen 'mensch' und 'gegenstand'. aus 'mensch' ist 'mann' und 'frau' abgeleitet und die klasse 'gegenstand' vererbt ihrerseits ihre eigenschaften und methoden an 'schiff' und 'auto'. vielleicht hilft es dir ja bei der umsetzung deiner eigenen ideen?
gruß,
reinhold

public class DeineWelt {
    public static void main(String args[]) {
        
        // erschaffe die Welt...
        Welt myWorld = new Welt("Erde");
        
        // kreiere ein paar Menschen
        Mann mann1 = new Mann();
        Frau frau1 = new Frau();
        Frau frau2 = new Frau();
        
        // gib ihnen ihre Namen
        mann1.setNameMensch("Fritz");
        frau1.setNameMensch("Ute");
        frau2.setNameMensch("Jutta");
        
        // kleiner Spass..
        frau2.setWeltName("Sonne");
        
        // produziere zwei Autos
        Auto auto1 = new Auto();
        Auto auto2 = new Auto();
        
        // vergib die Marken
        auto1.setGegenstandBezeichnung("Porsche");
        auto2.setGegenstandBezeichnung("Ferrari");
        
        // Ferrari kommt vom Mond..
        auto2.setWeltName("Mond");
        
        // produziere zwei Schiffe
        Schiff schiff1 = new Schiff();
        Schiff schiff2 = new Schiff();
        
        // gäähn, und wieder dasselbe
        schiff1.setGegenstandBezeichnung("U-Boot");
        schiff2.setGegenstandBezeichnung("Dampfer");
        
        // jetzt gehen wir einkaufen..
        mann1.nimmtInBesitz(auto1);
        auto1.setBesitzer(mann1);
        
        mann1.nimmtInBesitz(schiff2);
        schiff2.setBesitzer(mann1);
        
        frau1.nimmtInBesitz(schiff1);
        schiff1.setBesitzer(frau1);
        
        frau2.nimmtInBesitz(auto2);
        auto2.setBesitzer(frau2);
        frau2.nimmtInBesitz(schiff1);
        schiff1.setBesitzer(frau2);
        frau2.nimmtInBesitz(auto1);
        auto1.setBesitzer(frau2);
        
        // nun checken, wer was besitzt..
        System.out.println(mann1.getNameMensch() + " besitzt " +
                           mann1.hatInBesitz());
        System.out.println(frau1.getNameMensch() + " besitzt " +
                           frau1.hatInBesitz());
        System.out.println(frau2.getNameMensch() + " besitzt " + 
                           frau2.hatInBesitz());
        System.out.println("\n");
        
        // nun checken welche Besitzer jeder einzelne Gegenstand hat..
        System.out.println(auto1.getGegenstandBezeichnung() + " gehört " + 
                           auto1.getBesitzer());
        System.out.println(auto2.getGegenstandBezeichnung() + " gehört " + 
                           auto2.getBesitzer());
        System.out.println(schiff1.getGegenstandBezeichnung() + " gehört " + 
                           schiff1.getBesitzer());
        System.out.println(schiff2.getGegenstandBezeichnung() + " gehört " + 
                           schiff2.getBesitzer()); 
        System.out.println("\n");
        
        // sind alle Menschen und Gegenstände von dieser Welt??
        System.out.println(mann1.getNameMensch() + " lebt auf der " + 
                           mann1.getWeltName());
        System.out.println(frau1.getNameMensch() + " lebt auf der " + 
                           frau1.getWeltName());
        System.out.println(frau2.getNameMensch() + " lebt auf der " + 
                           frau2.getWeltName());
        System.out.println("\n");
        System.out.println(auto1.getGegenstandBezeichnung() + " kommt von " + 
                           auto1.getWeltName());
        System.out.println(auto2.getGegenstandBezeichnung() + " kommt von " + 
                           auto2.getWeltName());
        System.out.println(schiff1.getGegenstandBezeichnung() + " kommt von " + 
                           schiff1.getWeltName());
        System.out.println(schiff2.getGegenstandBezeichnung() + " kommt von " + 
                           schiff2.getWeltName());        
    }
}
class Welt {
    private String planetName = "Erde";
    public Welt() {}
    public Welt(String planetName) {
        this.planetName = planetName;
    }
    
    public void setWeltName(String planetName) {
        this.planetName = planetName;
    }
    
    public String getWeltName() {
        return this.planetName;
    }
    
}
class Mensch extends Welt {
    private String name = "";    
    private String eigentum = "";
    public Mensch() {}       
        
    public void setNameMensch(String name) {
        this.name = name;
    }
    
    public String getNameMensch() {
        return this.name;
    }
    
    public void nimmtInBesitz(Gegenstand gegenstand) {
        eigentum += gegenstand.getGegenstandBezeichnung() + " "; 
    }
    
    public String hatInBesitz() {
        return eigentum;
    }
}

class Mann extends Mensch {    
    public Mann() {
        super();     
    }      
}

class Frau extends Mensch {
    public Frau() {
        super();
    }
}

class Gegenstand extends Welt {
    private String bezeichnung = "";
    private String besitzer = "";
    public Gegenstand() {}
    
    public void setGegenstandBezeichnung(String bezeichnung) {
        this.bezeichnung = bezeichnung;
    }
    
    public String getGegenstandBezeichnung() {
        return bezeichnung;
    }
    
    public void setBesitzer(Mensch mensch) {
        besitzer += mensch.getNameMensch() + " ";
    }
    
    public String getBesitzer() {
        return besitzer;
    }            
}

class Auto extends Gegenstand {   
    public Auto() {
        super();
    }             
}

class Schiff extends Gegenstand { 
    public Schiff() {
        super();
    } 
}

 

[Tyler**]

:toll:

danke für deine Mühe! Ich werd das Programm mal durchforsten.

Übrigens haben wir eine andere Methode gefunden, Beziehungen herzustellen, und zwar mit TreeSort (java.util.TreeSort). Das ging irgendwie mit UML-Diagrammen. Somit war meine Vorbereitung des Programms völlig sinnlos, denn man konnte das Diagramm in einen Java-Code übersetzen lassen :roll:

Also damit dürfte meine Frage (und damit der Thread) erledigt sein.

Bevor ich ihn abhake:
Kann ich ein paar Fragen stellen zu dem Quelltext?

1.

class Frau extends Mensch { 
    public Frau() { 
        super(); 
    } 
}

Welche Funtktion hat das super() hier? ich dachte, man greift damit entweder auf die/Methoden der Superklasse zurück oder ergänzt Variablen aus Methoden der Superklasse, die nicht aufgerufen werden?

2. Ich habe jede SubKlasse in einer neuen *.java-Datei gespeichert. Welche Methode ist besser?

3. Was ich bis jetzt nicht verstehe: die Programme funktionieren doch auch alle ohne diese ganzen private-Attribute. Ich finde die überflüssig! Damit schränkt man die Variablen doch nur auf die jeweilige Klasse ein. Kann man diese in den Subklassen wenigstens noch lesen? Warum liege ich mit meiner negativen private-Einstellung (wahrscheinlich) falsch?

 

[Wildcard]

Generell werden Member private deklariert.
Zugriff gewährst du nur über getter und setter. Eigne dir dieses System in jedem Fall an!
Alles was private sein kann hat auch private zu sein. Diese Kapselung ist eine der Hauptregeln für OOP um unnötige Fehler zu vermeiden.

 

[Gast]

zu 1.) ich habe dich mit dem super(); etwas verwirrt! es ist in diesem beispiel auch überflüssig, d.h. es würde ein

class Frau extends Mensch {
    public Frau() {}
}

auch reichen. das ist deswegen so, weil frau ja aus mensch abgeleitet wurde und natürlich aber trotzdem einen konstruktor braucht, um überhaupt mal erzeugt werden zu können. wenn nun dieser leere konstruktor aufgerufen wird, so wird automatisch der konstruktor der vaterklasse -also mensch- aufgerufen und somit ist die frau ein mensch -mit all seinen eigenschaften und methoden, ..... gottogott, wie hört sich denn das an..

schau dir doch mal folgendes an:
[url]http://www.uni-klu.ac.at/~thaichho/java/k100049.html#konstruktoren
[/URL]
auch die kapitel davor und danach sind sehr hilfreich!!

gruß,
reinhold

 

[Wildcard]

Da der Konstruktor eh leer ist würde ich ihn ganz weglassen...

 

[Tyler**]

danke! :toll:

 

[Gast]

du hast natürlich recht, aber wie erklären wir das ??

 

[Tyler**]

du hast natürlich recht, aber wie erklären wir das ??

dass man dann den konstruktor weglassen kann, wusste ich auch. nur hat mich das mit dem super verwirrt. kann man aber anscheinend auch weglassen (in solchen fällen)

 

[Gast]

sorry, wollte dich nicht zu sehr verwirren, lies das und es sollte klar werden
http://www.uni-klu.ac.at/~thaichho/java/k100052.html#vererbungvonkonstruktoren