UML Diagramm

Luca H

Mitglied
Müsste nicht die private ArrayList in Person so lauten
Code:
private ArrayList<Kunstwerk> kunstwerke = new ArrayList<Person>();
public Person(ArrayList<Kunstwerk> kunstwerke)
{
    this.kunstwerke  = kunstwerke;
}

,weil das ja eine 1..* Multiplizität ist? Jedoch wenn ich das so mache bekomme ich einen Compiler Fehler.
 
X

Xyz1

Gast
Ich denke @mihe7 meint es so:
Java:
import java.util.LinkedList;
import java.util.List;

public class Atelier {
	public static void main(String[] args) {
		Person p1 = new Person("Hubert");
		Person p2 = new Person("Staller");
		p1.addArt("picasso");
		p1.addArt("lump");
		p2.addArt("rubens");

		System.out.println(p1);
		System.out.println(p2);
	}
}

/**
 * Hat Aggregation zu Kunstwerken.
 */
class Person {
	String v_name;
	List<Kunstwerk> v_arts = new LinkedList<>();

	public Person(String p_name) {
		if (p_name == null)
			throw new RuntimeException();
		v_name = p_name;
	}

	public void addArt(String p_name) {
		if (p_name == null)
			throw new RuntimeException();
		v_arts.add(new Kunstwerk(p_name, this));
	}

	@Override
	public String toString() {
		return String.format("Person [v_name=%s, v_arts=%s]", v_name, v_arts);
	}
}

/**
 * Hat Komposition zu Person.
 */
class Kunstwerk {
	String v_name;
	Person v_owner;

	public Kunstwerk(String p_name, Person p_owner) {
		if (p_name == null || p_owner == null)
			throw new RuntimeException();
		v_name = p_name;
		v_owner = p_owner;
	}
}
 

Luca H

Mitglied
Mein Code für Person sieht gerade so aus :
Code:
import java.util.ArrayList;

public class Person {
    public Person(Kunstwerk person) {
        person.setBesitzer(this);
    }

    private String name;

    private ArrayList<Kunstwerk> kunstwerke = new ArrayList<Kunstwerk>();

    public ArrayList<Kunstwerk> getKunstwerke() {
        return kunstwerke;
    }

    public void setkunstwerke(ArrayList<Kunstwerk> kunstwerke) {
        this.kunstwerke = kunstwerke;
    }

    public String getName() {
        return name;
    }

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

}

Wie weiter oben schon gesagt habe ich nun einen
Code:
java.lang.AssertionError: expected:<1> but was:<0>

Bei einer 1..* Multiplizität müsste die private ArrayList wie folgt aussehen oder

Code:
private ArrayList<Kunstwerk> kunstwerke = new ArrayList<Person>();
public Person(ArrayList<Kunstwerk> kunstwerke)
{
    this.kunstwerke  = kunstwerke;
}

Jedoch kommt da ein Compiler Fehler...
 
K

kneitzel

Gast
Also einmal stark gekürzt:
Mein Code für Person sieht gerade so aus :
Code:
import java.util.ArrayList;

public class Person {
    public Person(Kunstwerk person) {
        person.setBesitzer(this);
    }

    private ArrayList<Kunstwerk> kunstwerke = new ArrayList<Kunstwerk>();
}

a) Es wird ein Kunstwerk in einem Parameter "person" übergeben? Also da wundere ich mich wirklich nicht, dass man Probleme hat noch etwas zu verstehen! Da es ein Kunstwerk ist und keine Person nennen wir es doch einfach einmal "kunstwerk":

Code:
import java.util.ArrayList;

public class Person {
    public Person(Kunstwerk kunstwerk) {
        kunstwerk.setBesitzer(this);
    }

    private ArrayList<Kunstwerk> kunstwerke = new ArrayList<Kunstwerk>();
}

Nun ist die Person im Kunstwerk korrekt angelegt worden. Aber das Array "kunstwerke" ist noch immer eine Leere ArrayList.

Was könntest Du denn nun noch machen, damit das übergebene Kunstwerk auch in der Liste der Kunstwerke enthalten ist?
 

Luca H

Mitglied
Was könntest Du denn nun noch machen, damit das übergebene Kunstwerk auch in der Liste der Kunstwerke enthalten ist?
[/QUOTE]

Achsooo, ja okay dann kann ich per :

Code:
kunstwerke.add(kunstwerk);

das Kunstwerk in die Liste einfügen
 
X

Xyz1

Gast
Schockierend musste ich gerade feststellen dass ein Atelier eine Kunstwerkstatt beschreibt... :eek: Der richtige Klassenname oben wäre also zum Bleistift Museum oder Bildersammlung.
 

Rahza

Mitglied
Ich hänge auch ein wenig an dieser Aufgabe fest. Das Thema Aggregation ist ein wenig verwirrend.

Erstmal im Folgenden der Fehler, der angezeigt wird:
1) test(PublicTests)
java.lang.AssertionError
at org.junit.Assert.fail(Assert.java:86)
at org.junit.Assert.assertTrue(Assert.java:41)
at org.junit.Assert.assertNotNull(Assert.java:712)
at org.junit.Assert.assertNotNull(Assert.java:722)
at PublicTests.test(PublicTests.java:14)

Der Public-Test ist wie folgt:
Code:
import static org.junit.Assert.*;

import java.util.Date;

import org.junit.Test;

public class PublicTests {

    @Test
    public void test() {
        Kunstmuseum kunstmuseum = new Kunstmuseum();
        kunstmuseum.setName("Koblenzer Kunstmuseum");
        assertEquals("Koblenzer Kunstmuseum", kunstmuseum.getName());
        assertNotNull(kunstmuseum.getWerke());
        assertEquals(0, kunstmuseum.getWerke().size());
       
        Kunstwerk kunstwerk1 = new Statue(kunstmuseum);
        Kunstwerk kunstwerk2 = new Gemaelde(kunstmuseum);
        assertEquals(kunstmuseum, kunstwerk1.getMuseum());
        assertEquals(kunstmuseum, kunstwerk2.getMuseum());
       
        assertEquals(2, kunstmuseum.getWerke().size());
       
        kunstwerk1.setName("Werk1");
        kunstwerk1.setPreis(499.99);
        kunstwerk2.setName("Werk2");
        kunstwerk2.setPreis(349.99);
        assertEquals("Werk1", kunstwerk1.getName());
        assertEquals(499.99, kunstwerk1.getPreis(),1E-4);
       
        ((Statue)kunstwerk1).setHoehe(300);
        assertEquals(300,((Statue)kunstwerk1).getHoehe());
       
        Date date = new Date();
        ((Gemaelde)kunstwerk2).setZuletztRestauriertAm(date);
        assertEquals(date, ((Gemaelde)kunstwerk2).getZuletztRestauriertAm());
        assertTrue(kunstwerk2 instanceof Restaurierbar);
        ((Restaurierbar)kunstwerk2).restaurieren();
       
        Person person1 = new Person(kunstwerk1);
        assertEquals(person1, kunstwerk1.getBesitzer());
        person1.setName("Person1");
        assertEquals("Person1",person1.getName());
        assertEquals(1,person1.getKunstwerke().size());
        assertTrue(person1.getKunstwerke().contains(kunstwerk1));
    }

}

Ich sehe gerade, dass im Test die Zeilennummer nicht gezeigt wird. Der Fehler müsste laut Test bei assertNotNull(kunstmuseum.getWerke());
sein
 

mihe7

Top Contributor
Das Thema Aggregation ist ein wenig verwirrend.
Aggregation bedeutet nur, dass es sich um eine Ganzes-Teile-Beziehung handelt. Das Ganze setzt sich aus Teilen zusammen, wobei die Teile auch ohne das Ganze existieren könn(t)en.

Eine Gruppe ist zum Beispiel eine Aggregation. Die Mitglieder der Gruppe bilden diese. Die Gruppe kann sich jedoch auflösen und die Mitglieder leben trotzdem weiter :)

Anders ist das bei einer Komposition. Auch das ist eine Ganzes-Teile-Beziehung, allerdings können die Teile nicht ohne das Ganze (sinnvoll) existieren. Beispiel: Rechnung und Rechnungsposition.

Die Assoziation ist einfach eine allgemeine Beziehung. Eine Person wurde z. B. bei einer Firma ausgebildet. Hier gibt es keine Ganzes-Teile-Beziehung.

Die verschiedenen Beziehungsarten sind im Java-Code in der Regel nicht (zumindest nicht direkt) voneinander zu unterscheiden.

Der Fehler müsste laut Test bei assertNotNull(kunstmuseum.getWerke());
sein
Dann muss kunstmuseum.getWerke() null liefern.
 

Rahza

Mitglied
Danke für die ausführliche Antwort.
Das Problem ist eben die Implementation. In der Theorie habe ich mir viel Material durchgeschaut, um die Unterschiede zwischen Komposition, Aggregation etc. zu verstehen, aber habe wenig Beispiele gefunden, wo man konkret erkennen kann, was die Unterschiede in der Implementation sind.

Auch das Thema Multiplizitäten habe ich im Groben verstanden, aber es gibt noch einige offene Fragen, z.B. wenn ich eine gerichtete Beziehung habe, dann muss ich doch trotzdem entsprechend der Multiplizitäten Attribute bei beiden, in Beziehung stehenden Klassen, hinterlegen. Wie in unserem Beispiel: Die Beziehung zwischen Kunstwerk und Kunstmuseum ist gerichtet, jedoch muss ich in den Attributen sowohl werke als auch museum hinterlegen. Wodran am Code sehe ich also bzw. kann ich sichtbar machen, in welche Richtung es gerichtet ist?

Nun zu meinem konkreten Fehler:
Im Folgenden erstmal mein Code zu Kunstmuseum:
Code:
import java.util.ArrayList;


public class Kunstmuseum {
    
    private String name;
    private ArrayList<Kunstwerk> werke;
 
    public Kunstmuseum() {
        
    }
    public Kunstmuseum(String name) {
        this.werke= new ArrayList<Kunstwerk>();
        this.name=name;
    }

    public void addWerk (Kunstwerk werk) {
        this.werke.add(werk);
    }
    public void removeWerk(Kunstwerk werk) {
        this.werke.remove(werk);
    }

    public ArrayList<Kunstwerk> getWerke(){
        return this.werke;
    }

    public void setWerke(ArrayList<Kunstwerk> werke) {
        this.werke=werke;
    }
    public String getName() {
        return name;
    }

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

Da im Test ein leeres Kunstmuseum erzeugt wird, müsste die Abfrage doch auch "null" ergeben.
 

mihe7

Top Contributor
Wie in unserem Beispiel: Die Beziehung zwischen Kunstwerk und Kunstmuseum ist gerichtet,
Dann hättest Du im Diagramm üblicherweise Pfeilspitzen, die die Navigationsrichtung angeben. Eine Beziehung ohne Pfeilspitzen wird üblicherweise für bidirektionale Beziehungen verwendet. Alternative: an jedem Ende eine Pfeilspitze.

D. h. statt A <---> B wird oft nur A ----- B gezeichnet. Das ergibt Sinn, denn bei Aggregation und Komposition kannst Du ja auf der Seite der Raute keinen Pfeil einzeichnen. Daher ist: A <>----- B eine bidirektional navigierbare Beziehung (Aggregation) zwischen A und B, während A <>----> B unidirektional von A nach B ist.

Wodran am Code sehe ich also bzw. kann ich sichtbar machen, in welche Richtung es gerichtet ist?
Naja, um zu einem Objekt navigieren zu können, brauchst Du eine Referenz.

Zum Beispiel A ---- B bedeutet eine bidirektionale Beziehung zwischen A und B, d. h. es gilt A ---> B und A <---- B. Dem entsprechend muss in Klasse A eine Instanzvariable für B und in Klasse B eine Instanzvariable für A existieren.

Bei einer unidirektionalen Beziehung A ---> B würde nur in Klasse A eine Instanzvariable für B existieren.

Da im Test ein leeres Kunstmuseum erzeugt wird, müsste die Abfrage doch auch "null" ergeben.
Wenn der Test den parameterlosen Konstruktor verwendet und setWerke nicht aufgerufen wird, wird getWerke() null liefern.
 

Rahza

Mitglied
Ok, damit hättest du schon ein großes Missverständnis aufgeklärt.
Ich bin die ganze Zeit davon ausgegangen, dass Raute für Aggregation zeitgleich auch eine Richtung angibt.

Dann kann man im Grunde schon an Hand der Attribute die "Gerichtetheit" ablesen.
Nun zur Aufgabe:
Ich hatte ursprünglich den Default-Konstruktor nicht drin gehabt, was einen Compiler-Fehler lieferte.
Nun habe ich den hinzugefügt, aber es wird der oben genannte Fehler gezeigt.
Zur Klarstellung: Der Fehler gibt doch an, dass wie temi angegeben hat, eine leere Liste zurückgegeben werden soll. Stattdessen wird aber "null" zurückgegeben. Ist das richtig?
Da schließt sich dann eine weitere Frage an. Muss ich den Default-Konstruktor grundsätzlich drin haben oder ist das jetzt nur weil die das im Test so haben wollen?
 

temi

Top Contributor
Muss ich den Default-Konstruktor grundsätzlich drin haben oder ist das jetzt nur weil die das im Test so haben wollen?

In deinem Fall: Weil sie es so haben wollen!

Generell sollte man ein Objekt so erzeugen, dass es nach der Erzeugung gültig und "benutzbar" ist, d.h. der Konstruktor sollte mit seinen Parametern ein sinnvolles Objekt erzeugen. Wenn ein parameterloser Konstruktor nicht benötigt wird, dann sollte es ihn auch nicht geben.
 

temi

Top Contributor
Stattdessen wird aber "null" zurückgegeben. Ist das richtig?

Wir kennen ja deinen Code nicht, aber vermutlich ist das so richtig.

Evtl. sieht es ungefähr so aus:
Java:
class Foo {
    List<Integer> list; // list ist null
 
    List<Integer> getList() {
        return list; // damit wird hier auch null zurückgegeben
    }
}

Abhilfe:
Java:
class Foo {
    List<Integer> list = new ArrayList<>(); // 1. Möglichkeit
 
    Foo() {
        list = new ArrayList<>(); // 2. Möglichkeit
    }

    List<Integer> getList() {
        return list;
    }
}
 

mihe7

Top Contributor
Der Fehler gibt doch an, dass wie temi angegeben hat, eine leere Liste zurückgegeben werden soll. Stattdessen wird aber "null" zurückgegeben. Ist das richtig?
assertNotNull sagt nur, dass die Referenz nicht null sein darf (was bei Dir aber der Fall ist), ob die Liste an der Stelle leer ist oder nicht, spielt keine Rolle.
 

Rahza

Mitglied
Wir kennen ja deinen Code nicht, aber vermutlich ist das so richtig.

Evtl. sieht es ungefähr so aus:
Java:
class Foo {
    List<Integer> list; // list ist null

    List<Integer> getList() {
        return list; // damit wird hier auch null zurückgegeben
    }
}

Abhilfe:
Java:
class Foo {
    List<Integer> list = new ArrayList<>(); // 1. Möglichkeit

    Foo() {
        list = new ArrayList<>(); // 2. Möglichkeit
    }

    List<Integer> getList() {
        return list;
    }
}

Den Code habe ich unter #63 reingestellt, aber ich hab anhand dem Beispiel verstanden was du meinst.
Folgende Fragen tuen sich noch auf:
1. Du hast in dem Beispiel auf der linken Seite eine List genommen und rechts ArrayList; hat das Vorteile bzw. Unterschiede und kann ich auf beiden Seiten ArrayList nehmen?
2. Du hast als Abhilfe zwei Möglichkeiten genannt. Das ist eine Sache, die ich mich ohnehin gefragt habe, da ich das an diversen Stellen jetzt gesehen habe, dass in manchen Klassen in der Attribut-Deklaration direkt eine neue Liste erstellt wird und manchmal erst im Konstruktor. Welchen Unterschied macht das? Auch unabhängig von der Liste ganz allgemein gefragt, wenn ich ein Attribut von irgendeinem Typ entweder direkt in der Attribut-Auflistung erstelle oder aber erst im Konstruktor; macht das einen Unterschied?
 

Rahza

Mitglied
Und eine grundsätzliche Frage zur Nutzung dieses Forums:
Bei dem Public-Test von der Uni werden jetzt keine Fehler angezeigt, aber bei der letzten Aufgabe war es auch schon, dass nach der Abgabe ein Extra-Test mit Randfällen hochgeladen wird und obwohl meine Abgabe den Public-Test bestanden hatte, ist der Extra-Test durchgefallen. Frage: Darf ich meine komplette Abgabe hier reinstellen, damit ihr grob drüberguckt oder verstößt das gegen die Richtlinien?
 

temi

Top Contributor
1. Du hast in dem Beispiel auf der linken Seite eine List genommen und rechts ArrayList; hat das Vorteile bzw. Unterschiede und kann ich auf beiden Seiten ArrayList nehmen?

List<> ist ein Interface und ArrayList<> ist eine konkrete Implementation dieses Interfaces. Der Vorteil ist, das du die Implementation einfach austauschen kannst, wenn du vielleicht andere Anforderungen hast. Da der Rest des Codes gegen das Interface programmiert ist, wird das ohne Probleme funktionieren.
Java:
class Foo {
    List<Integer> list;

    Foo(List<Integer> list) {
        this.list = list;
    }
   
    void add(int i) {
        list.add(i);
    }
}

Foo foo1 = new Foo(new ArrayList<Integer>());
Foo foo2 = new Foo(new LinkedList<Integer>());

Du kannst natürlich als Typ auch ArrayList nehmen, das funktioniert auch.

Welchen Unterschied macht das? Auch unabhängig von der Liste ganz allgemein gefragt, wenn ich ein Attribut von irgendeinem Typ entweder direkt in der Attribut-Auflistung erstelle oder aber erst im Konstruktor; macht das einen Unterschied?

In dem Beispiel von #71 macht das keinen Unterschied.

Wenn du es im Konstruktor erstellst, dann hast du z.B. über den Konstruktorparameter noch Einflussmöglichkeiten auf die erstellte Liste, z.B. bietet ArrayList<> auch einen überladenen Konstruktor an. Oder halt wie im Beispiel hier, wo eine komplette Liste als Parameter übergeben wird.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
W UML Diagramm implementieren Java Basics - Anfänger-Themen 2
X MainClass im UML Diagramm Java Basics - Anfänger-Themen 2
lilrack UML Diagramm für Parkplatzverwaltung Java Basics - Anfänger-Themen 8
B UML Klassen Diagramm zu Java Code Programmieren und ausführen Java Basics - Anfänger-Themen 21
M Erste Schritte von UML Diagramm zum Code Java Basics - Anfänger-Themen 29
C UML Diagramm in Java implementieren-Korrektur Java Basics - Anfänger-Themen 8
J OOP Probleme mit UML-Diagramm Java Basics - Anfänger-Themen 6
T X-Y-Diagramm Analyse Java Basics - Anfänger-Themen 2
E OOP UML Diagramm Java Basics - Anfänger-Themen 4
V SVG Diagramm erstellen Java Basics - Anfänger-Themen 2
B Erste Schritte Brauche Hilfe für ein UML Diagramm Java Basics - Anfänger-Themen 7
D Werte aus Excel in Diagramm einfügen Java Basics - Anfänger-Themen 6
D Array in Diagramm ausgeben Java Basics - Anfänger-Themen 7
M Uml Diagramm->Java Java Basics - Anfänger-Themen 1
F Aus UML Diagramm Quelltext Java Basics - Anfänger-Themen 7
F uml diagramm! Java Basics - Anfänger-Themen 4
S UML Diagramm in Eclipse Java Basics - Anfänger-Themen 1
M CSV in Diagramm Java Basics - Anfänger-Themen 3
S UML-Diagramm und Java Java Basics - Anfänger-Themen 5
D Diagramm in der Konsole erstellen Java Basics - Anfänger-Themen 13

Ähnliche Java Themen

Neue Themen


Oben