# has-a-/is-a-Beziehung in UML



## Sweetsister (9. Aug 2010)

Hallo 

ich schreibe in 2 Tagen meine prakt.Inf-Prüfung und ich bekomme einen Zusammenhang, bzw. Implementierung nicht hin.

Es geht um eine alte Prüfungsaufgabe:

Es gibt die angehängte Grafik als unvollständigen UML-Entwurf und dann folgenden Text:

Die Firma eCar AG baut elektr. KFZ. Es gibt zwei Modell, den Small2E(2-sitziges Modell) und den Lagre4E(4 Sitze). Das Unternehmen will diese Produktpalett objektorientiert in Java abbilden. Natürlich soll der objektor. Entwurf so sein, dass er sich erweitern und ergänzen lässt.
Ein Elektroauto besteht aus Standardbauteilen(StdBauteil) und natürlich einem Elektromotor und einer Batterie. Jeder Kunde soll sich ein Wunschfahrzeug individuell zusammenstellen können (ggf. mit Sonderausstattung).

a) Ist die Beziehung zwischen Lenkrad und KFZBauteil eine ist ein oder hat ein Beziehung? Bitte kurze Begründung.
    -> Meine Antwort ist die ist-ein-Beziehung, da Lenkrad eine Unterklasse von StdBauteil, was wiederum eine Unterklasse von KFZBauteil ist

b) Von welcher Art ist die Beziehung zwischen Klimaanlage(wenn die Klimaanlage eine Sonderausstattung ist) und Sonderausstattung? Bitte kurze Begründung.
   -> Ja und da hapert es. Ist das nicht eine ist-ein-Beziehung? Also würde nicht die Klasse KFZBauteil das Interface Sonderausstattung implementieren und dadurch wäre die Klimaanlage eine Unterklasse?

c) Man soll der Abb. eine Klasse Parksensoren(Sonderausstattung) hinzufügen und das Modell Large4E. Die obige Abb. soll mit allen nötigen Klassen und Pfeilen ergänzt werden und die Beziehung zwischen ElektroKFZ und KFZBauteil beachtet werden.
  -> KFZBauteil ist doch in einer hat-ein-Beziehung mit ElektroKFZ?! Wie stelle ich das in UML dar? Ansonsten wäre bei mir die KLasse Parksensoren als Unterklasse von KFZBauteil eingetragen und in Beziehung zum Interface(als implements)(siehe zweite Grafik)


Ich krieg das nicht geordnet???:L. Kann mir einer helfen?

Viele GRüße
Sandra


----------



## KrokoDiehl (9. Aug 2010)

Tja was soll ich sagen. Die Zusammenhänge scheinst du richtig erkannt zu haben. Wenn es nun nur um die UML-Notation geht, sollte das Internet doch genug Quellen bieten... z.B. Wikipedia - Klassendiagramm.

Die Fragen werde ich dir nicht beantworten, aber vllt kann ich allgmeiner um Frage b) herum etwas erklären...


			
				Sweetsister hat gesagt.:
			
		

> -> Ja und da hapert es. Ist das nicht eine ist-ein-Beziehung? Also würde nicht die Klasse KFZBauteil das Interface Sonderausstattung implementieren und dadurch wäre die Klimaanlage eine Unterklasse?


Der Satz verwirrt mich schon  
In der Aufgabenstellung steht doch sogar schon, dass die Klimaanlage eine Sonderausstattung ist, was prinzipiell nichts daran hindert, dass sie (die Klimaanlage) zusätzlich auch ein KfzBauteil sein kann. Man denkt hier in Kategorien (bzw. Abstraktionen). Der Herr Max Muster kann ja auch zugleich ein Angestellter und ein Mensch sein 

Vllt. kannst du deine Fragen konkretisieren, das erleichtert das Antworten. Sonst ist man geneigt auf Fragen wie 





			
				Sweetsister hat gesagt.:
			
		

> Ich krieg das nicht geordnet. Kann mir einer helfen?


mit einem äußerst hilfreichen "Ja höchstwahrscheinlich" zu antworten


----------



## Sweetsister (10. Aug 2010)

ich bin inzwischen auf den begriff der aggregation und komposition gestoßen und da ging schon mal ein licht auf, wie das mit dem has-a gemeint ist

mein problem ist bei dem kfz-bsp. das handling mit dem interface. wenn die klima ein KFZBauteil ist, wer implementiert dann das interface? doch eigentlich nur die klasse klimaanlage? das war mein gedankenproblem und ich hatte gehofft, dass mir das einer vllt erklären kann

ich habe nochmal so eine aufgabe. da geht es um kuscheltiere. es gibt zwei abstrakte klassen(_kuscheltier_ und _zusatzfunktion_ (kannBrummen, kannSingen)) und ein interface "waschbar". nun gibt es die klasse "affe", die singen können soll und waschbar sein soll. der affe implementiert das interface für "waschbar", aber wie kommt er an kannSingen ran? ich weiß, dass zwischen _kuscheltier _und _zusatzfunktion_ ebenfalls die has-a-beziehung gilt, also hat _kuscheltier_ ein Objekt von _zusatzfunktion_ als instanzvariable. und affe kann dann drauf zugreifen. aber wie ich das bei UML darstellen soll, das ist mir rätselhaft.

wenn mein gedankensalat bisher auch stimmt


----------



## XHelp (10. Aug 2010)

Stell doch deine UML-Sachen rein, dann können wir uns ja an die richtige (sofern du es nicht von Anfang an richtig hast) Lösung rantasten.


----------



## Sweetsister (10. Aug 2010)

@ Xhelp:

meinst du bezogen auf das kuscheltier-problem? also das UML?


----------



## Sweetsister (10. Aug 2010)

also das UML sieht für das Kuscheltier-Problem so aus (siehe Anhang). Alles, was rot ist, habe ich hinzugefügt und auch der has-a-Pfeil zwischen den abstrakten Klassen sollte rot sein 

Der Aufgabentext lautet: Die Firma Kuscheltier GmbH will ihre Produktpalette objektorientiert in Java abbilden. Der Entwurf soll natürlich so sein, dass er erweiterbar ist und sich ergänzen lässt.
Es ist zu beachten, dass die Firma nicht nur verschiedene Kuscheltiere in verschiedenen Größen produziert, sondern auch einige mit Zusatzfunktionen ausgestattet sind. Ein Kuscheltier soll mehrere Zusatzfunktionen haben können.

Dann waren a) und b) in Bezug auf die Beziehung zwischen Kuscheltier und Brummbaer (a) und zwischen Kuscheltier und Zusatzfunktion(b) gestellt. Da hab ich bei a) eine is-a-Beziehung, da Brummbaer eine UNterklasse von Kuscheltier ist und bei b) ist es eine has-a-Beziehung, da Zusatzfunktion eine Instanzvariable in Kuscheltier ist.

und c) war dann:

Der Affe soll singen können und waschbar sein. Ein weiteres Kuscheltier Hoppelhase soll singen und hüpfen können. Ergänzen Sie die Abb. mit Pfeilen und Klassen.

Da hab ich dann die roten Pfeile und Kästen hinzugefügt.

Nur wie bekomme ich die Beziehung zwischen Affe und Zusatzfunktion hin? Also in UML? Einfach einen Pfeil ziehen?


----------



## XHelp (10. Aug 2010)

Öhm, war die grauen Sachen und schwarze Pfeile vorgegeben? Für mich sehen die nicht wirklich richtig aus (keine Sichtbarkeitsangaben, falsche Pfeile bei der Vererbung, falsche Darstellung von abstrakten Klassen, ganz zuschweigen vom großgeschriebenen Int)


----------



## Sweetsister (10. Aug 2010)

ich hab es nochmal korrigiert (also genauso abgetippt, wie es kopiert war) das was alles rot ist, das ist von mir, der rest war genau so auf dem aufgabenblatt kopiert (int war autokorrektur von MS Office und ich hatte die kursive schreibweise vergessen bei den klassen). und ich hatte, glaub ich, den rautenpfeil falsch rum.


----------



## XHelp (10. Aug 2010)

"extends" ist ein Pfeil mit leerer, geschlossener Spitze


----------



## Sweetsister (10. Aug 2010)

ah, okay, das merk ich mir gleich mal. Ich glaube, das nehmen die gar nicht so genau......ich hab schonmal wegen der notation in UML gegoogelt und das dann wieder verworfen, weil da nicht explizit drauf wert gelegt wird, also ob der pfeil gefüllt ist oder nicht...

ich programmier gerade das kuscheltier-bsp. und versuch das mal so nachzuvollziehen...


----------



## XHelp (10. Aug 2010)

Wozu dann die Aufgabe? Ich meine wenn "da nicht explizit wert drauf gelegt wird", dann kannst du lauter Vierecke malen und die mit irgendwelchen Pfeilen verbinden wie du lustig bist.
Im Internet gibt es ein Haufen Erklärungen und Beispiele zu UML.
1. Link von google wäre z.B. http://www.st.informatik.tu-darmstadt.de/pages/lectures/inf1/ws01-02/uebungen/umlkr.pdf (ob es wissenschaftlich haltbar ist, ist natürlich fraglich)


----------



## Sweetsister (10. Aug 2010)

es wird nicht explizit drauf geachtet, ob der pfeil gefüllt ist oder nicht, aber auf gestrichelte linie beim interface und auf die raute beim has-a wird geachtet, sowie auf die richtung der pfeile. also vierecke malen ist dann nicht....vllt irre ich mich auch, aber in der übung wurde bisher nicht korrigiert oder explizit erwähnt, ob der pfeil nun gefüllt ist oder nicht.
dann ist das eine prüdungsaufgabe und ich denke, man sieht, was gemeint ist. das ist auch nicht mein problem, sondern eher, wie ich den pfeil vom affen ziehen muss, bzw. ob ich da überhaupt einen pfeil ziehen muss, wenn zusatzfunktion eine instanzvariable von kuscheltier ist...

ich kau gerade an der methode zusatzfunktionen in der klasse kuscheltier rum, ich weiß nicht, wie ich die beschreibungen in den vector bekommen soll.......


----------



## XHelp (10. Aug 2010)

Ja, aber ein offener pfeil ist wie du es nennst "has-a" pfeil, und ein geschlossener leerer Pfeil ist ein "is-a"
Wenn es egal ist welcher Pfeil das ist, dann verliert das ganze ziemlich schnell an Sinn.
Der Pfeil muss meiner Meinung nach hin und zwar zum "kannSingen".

Beschreibung in den Vector? oO


----------



## Sweetsister (10. Aug 2010)

jetzt weiß ich, worauf du hinauswillst....ich müsste mal im skript schauen, ob es eine für uns gültige notation gibt, denn der has-a-pfeil war der raute-pfeil und der normale pfeil war der is-a-pfeil.

wenn der pfeil zum kannSingen hin muss, wie implementiert man das? also wie greife ich auf die zusatzfunktion zu? habe ich dann eine instanzvariable in der klasse affe?

die aufgabe d) lautet: bei der Klasse Kuscheltier ist nur die Methode Zusatzfunktionen() nicht abstrakt. Diese Methode soll die Beschreibungen aller Zusatzfunktionen als String zurückgeben.
Entscheiden Sie sich für eine passende Java Collections für die Zusatzfunktionen(als Attribut von Kuscheltier) und deklarieren Sie das Attribut einschließlich des Modifizierers für die Sichtbarkeit.

--> da hab ich halt die Klasse Vector genommen. Wobei ich nicht weiß, worauf der genau hinaus will. Wenn ich die Zusatzfunktionen als Attribut speichere, dann wäre das ja einfach
	
	
	
	





```
Zusatzfunktion item;
```
Als Collection-Dingens wäre das dann
	
	
	
	





```
Vector<Zusatzfunktion> item;
```

Aber weiter unten soll ich die Methode Zusatzfunktionen ausprogrammieren. Und da häng ich grad rum. 
1.) Weiß ich nicht, wie ich an die jeweiligen Beschreibungen kommen soll. Ich komme an die Methode in KannBrummen nicht ran.
2.) Wie ich das als String zurückgeben soll? Wobei ich glaube, dass es auch die Collections String gibt, die da vllt was hergibt?! Vllt geht da Vector gar net....

 Ich geb gern mal den Code und geh dann nochmal googlen.


```
//Klasse Zusatzfunktion

public abstract class Zusatzfunktion {
	private String beschreibung;
	
	abstract String getBeschreibung();

}
```


```
public class KannBrummen extends Zusatzfunktion{
	public String getBeschreibung(){
		return "Brummen";
	}

}
```


```
public abstract class Kuscheltier {
	private String beschreibung;
	private int groesse;
	public Zusatzfunktion fktn ;
	
	
	abstract String getBeschreibung();
	
	abstract int getGroesse();
	
	abstract int getGewicht();
	
	abstract int getVerkaufspreis();
	
	public String zusatzfunktionen(){
		//erstmal noch weiterwurschteln
		return;
	}

}
```


----------



## XHelp (10. Aug 2010)

Es ist eigentlich eine Frage, die mit dem Thema überhaupt nichts zu tun hat 
Du musst bei den Kuscheltieren 
	
	
	
	





```
Vector<Zusatzfunktion>
```
 haben. Und die Ausgabe könnte sein

```
List<Zusatzfunktion> funcs = new Vector<Zusatzfunktion>();
....
public String zusatzfunktionen(){
  String s="";
  for (Zusatzfunktion curFunc:funcs) {
    s+=funcs.getBeschreibung+", ";
  }
  return s;
}
```
(ohne jetzt eine Diskussion über StringBuffer etc anzufangen)


----------



## Sweetsister (10. Aug 2010)

ja ich mach grad mal weiter, deshalb kam ich auf diese andere frage (also im moment war ich weg vom UML).

und ich hab das so ähnlich wie du, schau:

oben folgendes:

```
public Vector <Zusatzfunktion> fktn ;
```
 (wobei der bestimmt private sein soll, wg dem zugriffsschutz


```
public String zusatzfunktionen(){
		StringBuffer hilf = new StringBuffer();
		for(int i=0;i<fktn.size();i++){
			hilf.append(elementAt(fktn(i)));
		}
		String hilf2 = hilf.toString();
		return hilf2;
	}
```

nur hab ich das stringBuffer benutzen wollen, aber das tut nicht. es scheitert am zugriff beim zusammenpappen...


----------



## Sweetsister (10. Aug 2010)

ach so und mein problem ist, dass ich die methode getBeschreibung in der klasse zusatzfunktion abstrakt gemacht habe und die unterklassen KannBrummen und KannHuepfen haben die jeweils implementiert. Nur wie komm ich da ran?


----------



## XHelp (10. Aug 2010)

Wenn du 
	
	
	
	





```
getBeschreibung
```
 aufrufst wird die Methode der jeweiligen Klasse ausgeführt. Ich verstehe nicht so ganz was du mit "rankommen" meinst.


----------



## Sweetsister (10. Aug 2010)

wenn ich einen vector erstelle mit objekten der klasse zusatzfunktion, dann werden alle objekte dieser klasse darin gespeichert, stimmt´s? Also kommt er so an die beschreibungen der jeweiligen objekte ran. Mein problem ist, wie komm ich denn von der klasse Affe an die Beschreibung der Klasse KannHuepfen ran? muss ich das überhaupt? wie erklär ich das? ich hab die klasse affe und will die zusatzfunktion KannHuepfen nutzen. Dann erstell ich eine instanzvariable in der klasse affe (hoff ich). wenn ich nun in einem testprogramm die zusatzfunktionen vom affen abrufen will, wie bekomme ich die beschreibungen? ich hab das so:


```
public class Affe extends Kuscheltier{
	KannHuepfen kannEs;
.
.
.
//Testprogramm-Code....
.
.
.
System.out.println(affe.kannEs.getBeschreibung());
```

So und dann kommt als Ausgabe "null", obwohl ich die Methode in der Klasse KannHuepfen nutze und den Namen "kannhuepfen" zuweise. Beim Affen klappt das gut mit dem namen, aber hier nicht.


nochmal zum anderen Thema mit dem Vector:
wenn ich obigen code eingebe, dann tut er nicht. Es kommt die Fehlermeldung: The method getBeschreibung() is undefined for the type Vector<Zusatzfunktion>

???:L


----------



## XHelp (10. Aug 2010)

Sweetsister hat gesagt.:


> wenn ich einen vector erstelle mit objekten der klasse zusatzfunktion, dann werden alle objekte dieser klasse darin gespeichert, stimmt´s?


Nö. Wenn du einen vector vom Typ Zusatzfunktion erstellst, dann erstellst du einen Vector vom Typ Zusatzfunktion. Da kannst du alles speichern, was von Zusatzfunktion erbt. Und da es vom Typ Zusatzfunktion ist, kannst du auch auf die Methoden der Klasse zugreifen... wozu eben getBeschreibung gehört.



Sweetsister hat gesagt.:


> Mein problem ist, wie komm ich denn von der klasse Affe an die Beschreibung der Klasse KannHuepfen ran? muss ich das überhaupt? wie erklär ich das? ich hab die klasse affe und will die zusatzfunktion KannHuepfen nutzen. Dann erstell ich eine instanzvariable in der klasse affe (hoff ich).


Du hast doch oben geschrieben, dass du eine Liste von Zusatzfunktionen erstellst. Wie kommst du jetzt an die einzelne Instanzvariable? Bleib also beim Vector.



Sweetsister hat gesagt.:


> ich hab das so:
> 
> ```
> ...
> ...


----------



## Sweetsister (10. Aug 2010)

Du, ja, die prüfung ist morgen und ich steh seit tagen bei dem thema total auf dem schlauch....jetzt hab ich halt den tag heute noch, genau das ding wenigstens einigermaßen zu verstehen. Wobei ich auch sagen muss, dass das kuscheltier-dingens noch nicht mal vergleichsweise irgendwann mal in anderer form dran war. das ärgert mich so an der uni. in der übung wird das alles sehr relaxt gehalten und dann in der prüfung hauts gerade mich vom sockel, wenn das so ein kuddelmuddel gibt wie jetzt im moment.

und das initialisieren hab ich natürlich prompt unterschlagen

und falsch ausdrücken tu ich mich auch....., klar muss der vector erst gefüllt werden.....

so, nun hab ich dann mal den fehler auch gefunden....


```
StringBuffer hilf = new StringBuffer();
	        for(int i=0;i<fktn.size();i++){
	          hilf.append(fktn.elementAt(i));
	        }
	        String hilf2 = hilf.toString();
	        return hilf2;
```

Man sollt halt au die Vektorenmethoden nutzen.....

mit dem affen klappt das auch, also das hinzufügen der zusatzfunktion und das ausgeben auch. Also die methode klappt.

Und da ich heut saumäßig "schlaue" fragen stelle *heul*, noch mal eine hinterher:

wie bekomme ich denn alle beschreibungen da rein? klar, ich kann den affen erstellen und dann darüber gehen. 
Aber ich hab einen leeren vector und den möchte ich füllen, mit allen möglichen beschreibungen. 

Ich glaub, ich brauch ne pause, weil ich jetzt gar nix mehr seh...........ich bin total durcheinander mit den vielen klassen


----------



## Zacherl (10. Aug 2010)

Naja, wenn die Zusatzfunktionen für das jeweilige Kuscheltier (also zum Beispiel den Hasen) festgelegt sind, dann fügst du die optimalerweise im Konstruktor zu. Wenn ich die Frage richtig verstanden hab, also bspw. so:


```
public Hase() {
     fktn.add(new KannHüpfen());
     fktn.add(new KannSingen());
}
```

Das bewirkt dann, dass jeder Hase die zwei Zusatzfunktionen automatisch angepappt kriegt, wenn er erstellt wird.


----------



## KrokoDiehl (10. Aug 2010)

*EDIT*
Bäh _Zacherl _  nur weil mich wer abgelenkt hat...
*/EDIT*

Im (zuletzt gepostetem) Klassendiagramm der Kuscheltiere hat die abstrakte Klasse "Kuscheltier" nur eine Methode "String Zusatzfunktionen()".
Da das Diagramm selbst keine Kardinalitäten hat (Verhältnisangaben wie 1:n-Beziehungen), kann man nur anhand des Methodennamens erahnen, dass ein Kuscheltier mehrere Zusatzfunktionen haben kann. Wenn man diese holen will, dann gibts nur einen String zurück, indem offenbar alle stehen.
Also laut Diagramm gibt es keine (direkte) Möglichkeit bei einem Affen nachzufragen, ob er er singen kann.

Meine Java-Umsetzung des Diagramms würde wie folgt aussehen:

```
public abstract class Zusatzfunktion
{
    public abstract String getBeschreibung();
}

public class KannBrummen extends Zusatzfunktion
{
    @Override
    public String getBeschreibung()
    {
        return "Kann brummen";
    }
}
// analog für KannSingen und KannHuepfen

// Tiere...
public abstract class Kuscheltier
{
    public abstract String getBeschreibung();
    public abstract int getGewicht();
    ...
    public abstract String getZusatzfunktionen();
}

public class Affe extends Kuscheltier implements Waschbar
{
    // Attribute
    private String beschreibung = "Das ist ein kuscheliger Affe";
    private int gewicht = 20;
    ...
    private Vector<Zusatzfunktion> zusatzfunktionen = new Vector<Zusatzfunktion>();
       // ...auch wenn ich List bevorzugen würde :)

    // Konstruktor
    public Affe()
    {
        // Zusatzfunktionen belegen
        zusatzfunktionen.add( new KannSingen() );
        zusatzfunktionen.add( new KannHuepfen() );
        // ...ggfs weitere Zus.funktionen
    }

    // ... weitere Methoden vom Kuscheltier

    // Methode vom Interface
    @Override
    public int getWaschtemperatur()
    {
        return 30;
    }

    @Override
    public String Zusatzfunktionen()
    {
        // intern haben wir einen Vektor (Liste) von Zusatzfunktionen, diese
        // Methode gibt aber einen String zurück. Also schreiben wir eine
        // komma-separierte Liste (sofern nichts anderes vorgegeben ist)
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < zusatzfunktionen.size(); i++)
        {
            str.append( zusatzfunktionen.get(i).getBeschreibung() );

            // ok, bisschen blöd, dass man das Komma nicht einfach immer hinterdran 
            // hängen sollte :)
            if (i < zusatzfunktionen.size()-1)
                str.append(", ");
        }

        return str.toString();
    }
}
```

Zu deiner Frage also: Das Befüllen der Zusatzfunktionen habe ich im Konstruktor des Affen gemacht. Setter-Methoden sieht das Diagramm nicht vor.


----------



## Suinos (10. Aug 2010)

KrokoDiehl hat gesagt.:
			
		

> [...]


Ganz gut, nur muss die Methode bereits in 
	
	
	
	





```
Kuscheltier
```
 konkret sein. 
Ich würde es gleich machen wie *Zacherl* und damit das auch funktioniert muss die Liste dann 
	
	
	
	





```
protected
```
 sein.


----------



## Sweetsister (10. Aug 2010)

@KrokoDiehl:



Hab ich das richtig verstanden? Ich hab den Vector in der Kuscheltier-Klasse und befüll den eben in der jeweiligen abgeleiteten Klasse mittels Konstruktoren? Dann hab ich am Ende ja den Vector als "globalen" Vector und wenn ich den ausgeben will, ruf ich die Methode auf....

Danke

Dann mache ich mal das Ganze bei der KFZ-Klasse und schau, ob ich es jetzt wirklich verstanden hab...


----------



## KrokoDiehl (10. Aug 2010)

Ah, da muss ich _Suinos_ Recht geben und mir diesen Fehler vorwerfen lassen ;(

Der _Vector_ für die Zusatzfunktionen ist in der Klasse Kuscheltier als _protected_ (nicht globale @ _SweetSister_)  besser aufgehoben.
Hier muss man das Prinzip der Abstraktion verstehen. Man kann sogar schon für die abstrakte Klasse der Kuscheltiere Zusatzfunktionen definieren, wenn sie denn Sinn macht.
Wenn es z.B. eine Zusatzfunktion "IstKuschelig" gäbe, so wäre dies ein Kandidat dafür, es direkt in der Kuscheltier-Klasse zu setzen. In den konkreten Klassen (Affe, Hase, ...) kommen dann jewils noch weitere Zus.funktionen hinzu.

In Java-Code:

```
public abstract class Kuscheltier
{
    protected Vector<Zusatzfunktion> zusatzfunktionen = null;
    
    public Kuscheltier()
    {
        zusatzfunktionen = new Vector<Zusatzfunktion>();
        zusatzfunktionen.add( new IstKuschelig() );
    }
    ...
}

public class Affe extends Kuscheltier
{
    // hier braucht man keinen Vector mehr, weil wir von Kuscheltier erben
    
    public Affe()
    {
        super(); //<-- nicht nötig aber für das Verständis: hier wird der Konstruktor vom Kuscheltier aufgerufen

        zusatzfunktionen.add( new KannHuepfen() );
        zusatzfunktionen.add( new KlautGegenstaendeAusDenTaschenUndWirftSieDannWeg() );
    }
}
```

...ich finde das Kuscheltier-Beispiel zum Erlernen von Objektierung irgendwie schräg  ...


----------



## Sweetsister (10. Aug 2010)

und ich finde das kuscheltier-dingens recht demotivierend, wenn ich ehrlich bin

schau mal, jetzt kau ich an der KFZ-Sache rum und bekomme die doofe addSonderausstattung nicht hin. Ich finde den verdammten fehler nicht:bahnhof:

.
.
.
.
.
und während ich hier rumkaue, hab ich dann den fehler vllt doch gefunden.

Doch mal kurz euch fragen: mein erstes bsp ist ja oben zu ersehen. wenn ich ein neues bauteil einfügen will als sonderausstattung, ist es dann nicht immer auch ein KFZBauteil? Ich meine, kann ich davon ausgehen, dass es keine unabhängige klasse gibt als Sonderausstattung? Und das neue Teil muss Sonderausstattung implementieren, sonst geht´s auch nicht.


```
import java.util.*;
public abstract class ElektroKFZ {
	
	abstract String getModell();
	
	protected Vector<KFZBauteil> bauteile = new Vector<KFZBauteil>();
	protected Vector <Sonderausstattung> sonderteile = new Vector<Sonderausstattung>();
	
	public void printBauteilListe(){
		for(int i=0;i<bauteile.size();i++){
			System.out.println(bauteile.get(i).getBeschreibung());
		}
	}
	
	public void addSonderausstattung(KFZBauteil x){
		if(bauteile.contains(x)){
			sonderteile.add((Sonderausstattung) x);
		}
		else{
			bauteile.add(x);
			sonderteile.add((Sonderausstattung) x);
		}
		System.out.println("Sonderausstattungsliste: ");
			for(int i = 0; i<sonderteile.size();i++){
				System.out.println(sonderteile.get(i));
			}
```

mein auto:

```
public class Small2E extends ElektroKFZ {
	
	public Small2E(){
		bauteile.add(new Klimaanlage());
		bauteile.add(new Parksensoren());
	}
	public String getModell(){
		return "Small2E";
	}


}
```

mein lenkrad:

```
public class Lenkrad extends StdBauteil implements Sonderausstattung{
	
	public int getAufpreis(){
		return 100;
	}
	
	public String getBeschreibung(){
		return "Lenkrad";
	}
	
	public int getGewicht(){
		return 100;
	}

}
```

mein testprogramm:

```
public class test2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Small2E klein = new Small2E();
		klein.printBauteilListe();
		klein.addSonderausstattung(new Lenkrad());
		//klein.printBauteilListe();
		
		
		

	}

}
```

aber die ausgabe ist komisch:

Klima
Parksensoren
Sonderausstattungsliste: 
Lenkrad@c17164

warum die nummer??


----------



## Schumi (10. Aug 2010)

[Java]System.out.println(sonderteile.get(i));
[/code]
druckt halt die toString() Methode des Objektes aus, wenn es diese nicht gibt wird die von Object genutzt und die gibt das obige aus. Also einfach für das Lenkrad toString() implementieren.


----------



## KrokoDiehl (10. Aug 2010)

```
public class Lenkrad extends StdBauteil implements Sonderausstattung
```
Diese Zeile sagt aus, dass ein Lenkrad ein Standardbauteil und eine Sonderausstattung ist. Klingt etwas widersprüchlich nicht wahr? 
Was haben dann wohl die Autos ohne jegliche Sonderausstattung für ein Lenk-Instrument 

Ansonsten hat _Schumi_ recht. Aber in der Klasse _ElektroKfz_ hast du schon einmal etwas anderes zur Ausgabe benutzt:
[JAVA=11]
System.out.println(bauteile.get(i).getBeschreibung());
[/code]
Du willst sicher eher die Beschreibung haben


----------



## Sweetsister (10. Aug 2010)

darauf zielte meine frage ab: kann etwas eine sonderausstattung, aber kein bauteil sein? nach meinem verständnis ist alles ein bauteil, auch felgen etc.

okay, weniger widersprüchlich wäre es als Instanz von KFZBauteil

klar möchte ich die beschreibung, dann muss ich aber casten, oder?


nachtrag: gecastet tut´s....


----------



## Zacherl (10. Aug 2010)

Wenn du bei KFZBauteil eine abstrakte Methode 


```
public abstract String getBeschreibung();
```

deklarierst, kannst du dir den Cast sparen - vorausgesetzt, alle deine Bauteile sind KFZBauteile.

Nachtrag: Andererseits - quatsch, du müsstest die Methode ins Interface Sonderbauteil reinpacken. Vergiss einfach was ich geschrieben hab, ich verwirre mich gerade selber :X


----------



## Sweetsister (10. Aug 2010)

> Zacherl:
> 
> ....ich verwirre mich gerade selber :X



kenn ich, kenn ich

es beruhigt mich, dass ich auch schon so weit war, aber aus dem gleichen grund davon abgekommen bin und dann doch das casten etwas einfacher fand


----------



## KrokoDiehl (10. Aug 2010)

Sweetsister hat gesagt.:
			
		

> [...] etwas einfacher fand


Meine Erfahrung hat mir gezeigt, dass aus diesem Grund viele Fehler gemacht werden (... meistens von mir selbst  ).


----------



## Sweetsister (10. Aug 2010)

@KrokoDiehl:

reden wir nicht drüber:noe:

seit ich den versuch wage zu studieren, gehört teilweise eine blutige nase zum geschäft......und das ich praktisch erst gestern genau zu diesem thema in java kam, das ist eine private geschichte gewesen. normalerweise lern ich gute 3 wochen vorher und besuch VL wie Ü. ohne internet lernen geht kaum, ich hatte 4 bücher und ich kau seit guten 2 wochen an der UML-sache rum. Dafür hab ich andere dinge gut gelernt....

ich hoffe, das reicht......


----------

