# erzeugen eines neuen Objekts mit aktuellen Daten



## Xeno1987 (29. Dez 2011)

Hallo hab ein problem bei einer Programmier-Übung, komme nicht weiter: Wir sollen eine Geschenkverpackungsmachine programmieren. Ich hab mal alle Klassen die Relevant sind hier unten angefügt:


```
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Die abstrakte Geschenkmaschine stellt einer ableitenden Klasse eine Liste mit
 * Kindern und eine Liste mit Jutesaecken bereit. Die Aufgabe der abgeleiteten
 * Klasse ist es, die einzelnen Schritte vom Einlesen der Wunschzettel bis zum
 * Beladen der Jutesaecke umzusetzen.
 * 
 * 
 * Die chronologische Verarbeitung lautet wie folgt (detaillierte Beschreibung
 * vgl. Kommentare oberhalb der Methodensignaturen):
 * 
 * - Einlesen der Wunschlisten
 * 
 * - Altersfreigaben pruefen und altersgerechte Wuensche in Geschenke ueberfuehren
 * 
 * - Geschenke verpacken
 * 
 * - Jutesaecke befuellen
 * 
 * - Inhalte der Jutesaecke ausgeben
 * 
 * 
 * Die abstrakte Klasse AbstrakteGeschenkmaschine enthaelt bereits eine Methode
 * start(), die den Verarbeitungsprozess in der richtigen Reihenfolge ausfuehrt.
 * In der abgeleiteten Klasse muessen deshalb nur noch die abstrakten Methoden
 * implementiert werden.
 * 
 */
public abstract class AbstrakteGeschenkmaschine
{
	/**
	 * Liste aller Kinder (die Kind-Instanzen enthalten die Wunschlisten). Dank
	 * protected kann in abgeleiteten Klassen auf diese Liste zugegriffen
	 * werden.
	 */
	protected List kinder = new ArrayList();
	
	/**
	 * Liste der Geschenke aller Kinder (vom Typ IGeschenk). Dank protected kann
	 * in abgeleiteten Klassen auf diese Liste zugegriffen werden.
	 */
	protected List geschenke = new ArrayList();
	
	/**
	 * Liste mit Jutesaecken, die es zu befuellen gilt. Es ist anzunehmen, dass
	 * ausreichend Jutesaecke existieren. Dank protected kann in abgeleiteten
	 * Klassen auf diese Liste zugegriffen werden.
	 */
	protected List jutesaecke = new ArrayList();
	
	/** Private Attribute sind fuer Sie nicht relevant. */
	private Random rand = new Random();
	
	/**
	 * Einlesen der Wunschlisten: der Weihnachtsmann stellt bereits eine Klasse
	 * zum Einlesen der Wunschlisten bereit. Die Aufgabe der Methode
	 * wunschlistenLesen() besteht darin, die Liste "kinder" zu befuellen. Die
	 * Methode erhaelt einen Parameter, der den Dateinamen mit den Wunschlisten
	 * enthaelt. Waehrend des Einlesevorgangs sollen die Kinder und deren
	 * Wunschzettel mit System.out.println() auf dem Bildschirm ausgegeben
	 * werden.
	 * 
	 * Die Klasse Wunschlisten kann generell wie folgt benutzt werden:
	 * 
	 * Wunschlisten wl = new Wunschlisten();
	 * wl.einlesen("wunschlisten.txt");
	 * 
	 * while (wl.existiertWeitereWunschliste())
	 * {
	 *     String name = wl.gibName();
	 *     byte alter = wl.gibAlter();
	 *     List wuensche = wl.gibWuensche();
	 * }
	 * 
	 * Im Schleifenrumpf muss folgender Code ausgefuehrt werden:
	 * 
	 * 1. Erzeuge Sie eine neue Instanz der Klasse Kind und befuelle Sie sie mit
	 * dem gelesenen Namen, dem Alter und der Wunschliste (wl.gibName(),
	 * wl.gibAlter(), wl.gibWuensche())
	 * 
	 * 2. Geben Sie Namen und Alter des Kindes aus
	 *
	 * 3. Fuegen Sie das Kind der Liste kinder hinzu
	 * 
	 * 4. Durchlaufen Sie alle Wuensche (wl.gibWuensche()) und geben Sie
	 * Bezeichnung, Altersfreigabe und Volumen des Wunsches aus
	 * 
	 * @param dateiname
	 *            Dateipfad zu den Wunschlisten
	 */
	protected abstract void wunschlistenLesen(String dateiname);
	
	/**
	 * Altersfreigaben pruefen: in altersfreigabenPruefen() sollen die Wuensche
	 * aller Kinder hinsichtlich der Altersfreigabe ueberprueft werden. Ist ein
	 * Kind zu jung, wird der entsprechende Wunsch aus seiner Wunschliste
	 * entfernt. Der Schritt des Entfernens ist ueber System.out.println() zu
	 * dokumentieren (von wem wurde welcher Wunsch entfernt).
	 * 
	 * Implementieren Sie folgenden Ablauf:
	 * 
	 * 1. Durchlaufen Sie die Liste kinder
	 * 
	 * 1.1 Lassen Sie sich die Wunschliste des aktuellen Kindes geben
	 * 
	 * 1.2 Durchlaufen Sie die Wunschliste RUECKWAERTS
	 * 
	 * 1.2.1 ueberpruefen Sie, ob der aktuell betrachtete Wunsch altersgerecht ist
	 * (Alter des Kindes >= Altersfreigabe des Wunsches)
	 * 
	 * 1.2.2 Wenn ja, dann gehen Sie zum naechsten Element ueber. Wenn nein, dann
	 * entfernen Sie den aktuellen Wunsch aus der Wunschliste via
	 * wuensche.remove(int i) und geben eine passende Information auf den
	 * Bildschirm aus.
	 */
	protected abstract void altersfreigabePruefen();
	
	/**
	 * In dieser Methode sollen anhand der Wunschlisten Geschenke konstruiert
	 * werden und gemaess des Volumens als normales Geschenk oder Sperrgut
	 * klassifiziert werden. Hierzu setzen Sie folgenden Ablauf um:
	 * 
	 * 1. Durchlaufen Sie die Liste kinder
	 * 
	 * 1.1. Lassen Sie sich die Wunschliste des aktuellen Kindes geben
	 * 
	 * 1.2. Durchlaufen Sie die Wunschliste des aktuellen Kindes
	 * 
	 * 1.2.1 Pruefen Sie bei jedem Wunsch, ob wunsch.gibVolumen() >= 80.0
	 * 
	 * 1.2.2. Wenn ja, dann wird ein neues Objekt der Klasse SperrgutGeschenk
	 * mit den Daten aus dem aktuellen Wunsch erstellt. Wenn nein, dann wird ein
	 * neues Objekt der Klasse NormalesGeschenk mit den Daten aus dem aktuellen
	 * Wunsch erstellt.
	 * 
	 * 1.2.3. Geben Sie auf den Bildschirm die Information aus, welcher Wunsch
	 * in welches Geschenk ueberfuehrt wurde.
	 *
	 * 1.2.4 Fuegen Sie das Geschenk der Liste geschenke hinzu.
	 */
	protected abstract void geschenkeErstellenUndKlassifizieren();
	
	/**
	 * Geschenke verpacken: in dieser Methode muessen die Geschenke eingepackt
	 * werden. Hierbei soll die Maschine zufaellige Verpackungsmaterialien
	 * waehlen, so dass nicht jedes Geschenk identisch verpackt ist. Ausserdem
	 * soll ein Geschenk auf zufaelliger Basis ein Geschenkband erhalten oder
	 * nicht. Nutzen Sie hierfuer die Methoden gibZufaelligesMaterial() und
	 * gibZufaelligenWahrheitswert() der Klasse AbstrakteGeschenkmaschine.
	 * 
	 * 1. Erzeugen Sie sich Instanzen der von Ihnen konstruierten Materialien
	 * und fuegen Sie sie einer neuen Liste hinzu
	 * 
	 * 2. Durchlaufen Sie die Liste geschenke
	 * 
	 * 2.1 Rufen Sie auf jedem Geschenk die Methode einpacken() mit zufaelligen
	 * Parameterwerten auf
	 * 
	 * Eine Ausgabe auf den Bildschirm wird in dieser Methode nicht benoetigt.
	 */
	protected abstract void geschenkeEinpacken();
	
	/**
	 * Der vorletzte Schritt bei der Geschenkmaschine addressiert die Befuellung
	 * der Jutesaecke. Es ist davon auszugehen, dass ausreichend Jutesaecke
	 * vorhanden sind (die Liste "jutesaecke" kann also beliebig viele Elemente
	 * aufnehmen).
	 * 
	 * Implementieren Sie folgenden Algorithmus zum Befuellen der Jutesaecke:
	 * 
	 * 1. Erzeugen Sie den ersten Jutesack (folgend mit js bezeichnet)
	 * 
	 * IJutesack js = new Jutesack();
	 * 
	 * 2. Durchlaufen Sie alle Geschenke
	 * 
	 * 2.1. Fuegen Sie das aktuelle Geschenk in den Jutesack ein mit der Methode
	 * js.hinzufuegen(IGeschenk g). Die Methode "hinzufuegen" gibt true zurueck,
	 * wenn das Geschenk in den Jutesack gepasst hat, sonst false.
	 * 
	 * 2.2. Wenn "hinzufuegen" false geliefert hat, dann machen Sie folgendes:
	 * 
	 * 2.2.1. ueberpruefen Sie, ob das Geschenk generell zu gross ist fuer einen
	 * Jutesack. Wenn ja, dann geben Sie eine Information aus, dass das Geschenk
	 * zu gross ist und gesondert geliefert wird - das Geschenk wird folglich fuer
	 * die Befuellung ausgelassen.
	 * 
	 * 2.2.2. Wenn nein, fuegen Sie js der Liste jutesaecke hinzu und erzeugen
	 * Sie anschliessend in js einen neuen Jutesack: "js = new Jutesack();". Mit
	 * js.hinzufuegen(IGeschenk g) fuegen Sie das aktuelle Geschenk in den neu
	 * erstellen Jutesack ein.
	 * 
	 * 3. Ist die Schleife durchgelaufen, ist der zuletzt erzeugte Jutesack noch
	 * nicht in der Liste jutesaecke. Fuegen Sie also den letzten Jutesack, der
	 * in js gespeichert ist, der jutesaecke-Liste hinzu.
	 * 
	 * Eine weitere Ausgabe auf den Bildschirm ist in dieser Methode nicht
	 * notwendig.
	 */
	protected abstract void jutesaeckeBefuellen();
	
	/**
	 * Inhalte der Jutesaecke ausgeben: am Ende soll die Methode
	 * jutesackinhalteAusgeben() die Inhalte aller Jutesaecke auflisten, damit
	 * der Weihnachtsmann einen ueberblick darueber bekommt, welche Geschenke sich
	 * in welchen Jutesaecken befinden.
	 * 
	 * Es sollten mindestens der Name des Beschenkten, die Bezeichnung des
	 * Geschenks, das Verpackungsmaterial und die Geschenkbandbestueckung
	 * ausgegeben werden.
	 */
	protected abstract void jutesackinhalteAusgeben();
	
	/**
	 * Fuehrt den Verpackungsprozess in der richtigen Reihenfolge durch. Rufen
	 * Sie diese Methode in Ihrer Main-Methode auf, nachdem Sie ein Objekt der
	 * Klasse Geschenkmaschine erstellt haben.
	 * 
	 * @param dateiname
	 *            Pfad zur Wunschlistendatei
	 */
	public void start(String dateiname)
	{
		wunschlistenLesen(dateiname);
		altersfreigabePruefen();
		geschenkeErstellenUndKlassifizieren();
		geschenkeEinpacken();
		jutesaeckeBefuellen();
		jutesackinhalteAusgeben();
	}
	
	/**
	 * uebergeben Sie dieser Methode verschiedene Verpackungsmaterialien und Sie
	 * erhalten ein zufaellig ausgewaehltes Material zurueck.
	 * 
	 * @param materialien
	 *            Liste mit Materalien vom Typ AbstraktesMaterial
	 * @return Ein zufaellig ausgewaehltes Objekt aus der Eingabe
	 */
	protected AbstraktesMaterial gibZufaelligesMaterial(List materialien)
	{
		return (AbstraktesMaterial) materialien.get(rand.nextInt(materialien
				.size()));
	}
	
	/**
	 * Gibt einen zufaelligen Wahrheitswert zurueck.
	 * 
	 * @return Ein Wahrheitswert.
	 */
	protected boolean gibZufaelligenWahrheitswert()
	{
		return rand.nextBoolean();
	}
}
```



```
import java.util.List;
import java.util.ArrayList;

public class Geschenkmaschine extends AbstrakteGeschenkmaschine{

	public Geschenkmaschine(List kinder, List geschenke, List jutesaecke)
	{
		this.kinder=kinder;
		this.geschenke=geschenke;
		this.jutesaecke=jutesaecke;
	}

	protected void wunschlistenLesen(String dateiname){
		Wunschlisten wl = new Wunschlisten();
		wl.einlesen(dateiname);
		
			while(wl.existiertWeitereWunschliste()){
				 
				 String name = wl.gibName();
			    byte alter = wl.gibAlter();
			    List wuensche = wl.gibWuensche();
				 Kind kind = new Kind(name,alter,wuensche);
			    System.out.println("Name: " + kind.gibName() + "alter: " + kind.gibAlter());
			    kinder.add(kind);
			    
			    for(int i=0;i<=wl.gibWuensche().size();i++){
			    	
			    	System.out.println(toString());
			    	
			}
		
		}
	}

	protected void altersfreigabePruefen(){
	
		for(int i=0;i<=kinder.size();i++){
			Kind aktKind= (Kind)kinder.get(i);
			
	
			for(int j=aktKind.gibWuensche().size()-1;j>=0;j--){
				Wunsch derwunsch= (Wunsch)aktKind.gibWuensche().get(i);
			if(aktKind.gibAlter()>=derwunsch.gibAltersfreigabe()){
				
			} else {
				System.out.println(derwunsch.gibBezeichnung() + "ist ab " + derwunsch.gibAltersfreigabe() + "freigegeben. " + aktKind.gibName() + " ist jedoch erst" + aktKind.gibAlter() + " Jahre alt. \n" + "Der Wunsch wurde entfernt!" );
				aktKind.gibWuensche().remove(derwunsch);
				
			  }
				
				
		    }
			
		}
			
	}	
			
			
	
	protected void geschenkeErstellenUndKlassifizieren(){
		String klassifikation;
		for(int i=0;i<=kinder.size();i++){
			Kind aktKind= (Kind)kinder.get(i);
			
	
			for(int j=aktKind.gibWuensche().size()-1;j>=0;j--){
				Wunsch derwunsch= (Wunsch)aktKind.gibWuensche().get(i);
				if(derwunsch.gibVolumen()>=80.0){
					SperrgutGeschenk g = new SperrgutGeschenk(empfaenger, bezeichnung, altersfreigabe, volumen);
					klassifikation = "Sperrgut";
				} else {
				
					NormalesGeschenk g = new NormalesGeschenk(empfaenger, bezeichnung, altersfreigabe, volumen);
					klassifikation = "Normales Geschenk";
				}
				System.out.println("Wunsch" + derwunsch.gibBezeichnung() + "von" + aktKind.gibName() + "wird als " + klassifikation + "erstellt!" );
				geschenke.add(geschenk);
		    }
			
		}
		
	}
	
	protected void geschenkeEinpacken(){
		
		List Verpackung = new ArrayList();
		Verpackung.add(new GoldenesPapier());
		Verpackung.add(new RotesPapier());
		Verpackung.add(new Folie());
		
		for(int i=0;i<=geschenke.size();i++){
			IGeschenk igeschenk = new IGeschenk();
			igeschenk.einpacken(gibZufaelligesMaterial(Verpackung),gibZufaelligenWahrheitswert());
		}
	}
	
	protected void jutesaeckeBefuellen(){
		Jutesack js = new Jutesack();
		for(int i=0;i<=geschenke.size();i++){
			IGeschenk geschenk;
			if(js.hinzufuegen(geschenk)==false){
				
					if(geschenk.jutesack.gibVolumen>=100.0){
						System.out.println("Eines der Geschenke fuer " + geschenk.gibEmpfaenger() + "ist zu gross fuer einen Jutesack" + geschenk.gibBezeichnung() + "Das Geschenk wird gesondert ausgeliefert!" );
					} else{
						jutesaecke.add(js);
						delete(js);
						js = new Jutesack();
						js.hinzufuegen(geschenk);
					}
				}
		}
		jutesaecke.add(js);
	}


protected void jutesackinhalteAusgeben(){
	
			System.out.println(jutesaecke);
		
			System.out.println("Name: "+ geschenk.gibEmpfaenger() + ": " + geschenk.gibBezeichnung() + " ,eingepackt in " + geschenk.gibVerpackung() + "und" + geschenk.hatGeschenkband());

}

}
```


```
public class SperrgutGeschenk implements IGeschenk{

private AbstraktesMaterial geschenkpapier;
private boolean geschenkband = false;
private IKind empfaenger;
private double volumen;
private byte altersfreigabe;
private String bezeichnung;	


	public SperrgutGeschenk(IKind empfaenger, String bezeichnung, byte altersfreigabe, double volumen){
		this.empfaenger=empfaenger;
		this.bezeichnung=bezeichnung;
		this.altersfreigabe=altersfreigabe;
		this.volumen=volumen;
		
	}
	

		public void einpacken(AbstraktesMaterial geschenkpapier, boolean geschenkband){
			
		}

		public AbstraktesMaterial gibVerpackung(){
			return null;
		}
		
		public boolean hatGeschenkband(){
			return geschenkband;
		}

		public IKind gibEmpfaenger(){
					
			return empfaenger;
		}

		public String gibBezeichnung(){
			return bezeichnung;
		}

		public double gibVolumen(){
			return volumen;
		}

		public byte gibAltersfreigabe(){
			return altersfreigabe;
		}




}
```


```
/**
 * Ein Geschenk enthaelt aehnliche Daten wie ein Wunsch. Neben der
 * Altersbegrenzung, des Volumens und der Bezeichnung stellt ein Geschenk
 * zusaetzlich Informationen zur Verpackung und zum Empfaenger bereit.
 * 
 * Ein Geschenk ist normal, wenn das Volumen kleiner als 80.0 ist, andernfalls
 * ist es als Sperrgut zu betrachten. Sperrgut kann nicht verpackt werden.
 * 
 * Erstellen Sie zwei Klassen NormalesGeschenk und SperrgutGeschenk, die beide
 * das Interface IGeschenk implementieren. Der wesentliche Unterschied soll
 * hierbei in der Methode einpacken(AbstraktesMaterial am, boolean geschenkband)
 * stattfinden. Waehrend Sie in NormalesGeschenk die Verpackung speichern muessen,
 * erfordert SperrgutGeschenk nichts (ein leerer Rumpf). Die Methode
 * gibVerpackung() liefert bei SperrgutGeschenk also immer null und bei
 * hatGeschenkband() immer false.
 * 
 * Hinweis: wenn Sie ein paar Code-Zeilen sparen wollen, dann leiten Sie die
 * Implementierung von IGeschenk von der Klasse Wunsch ab!
 * 
 */
public interface IGeschenk
{
	/**
	 * Packt ein Geschenk in das angegebene Material ein und fuegt ggf. ein
	 * Geschenkband hinzu.
	 * 
	 * @param geschenkpapier
	 *            Das Verpackungsmaterial
	 * @param geschenkband
	 *            <code>true</code> ein Geschenkband wird hinzugefuegt,
	 *            andernfalls nicht
	 */
	public void einpacken(AbstraktesMaterial geschenkpapier,
			boolean geschenkband);
	
	/**
	 * Gibt das Verpackungsmaterial zurueck
	 * 
	 * @return Das Verpackungsmaterial
	 */
	public AbstraktesMaterial gibVerpackung();
	
	/**
	 * Gibt zurueck, ob ein Geschenkband vorhanden ist, oder nicht.
	 * 
	 * @return <code>true</code> wenn ein Geschenkband vorhanden ist, ansonsten
	 *         <code>false</code>
	 */
	public boolean hatGeschenkband();
	
	/**
	 * Gibt den Empfaenger dieses Geschenks zurueck.
	 * 
	 * @return Der Empfaenger dieses Geschenks
	 */
	public IKind gibEmpfaenger();
	
	/**
	 * Gibt die Bezeichnung des Geschenks zurueck.
	 * 
	 * @return Die Bezeichnung des Geschenks
	 */
	public String gibBezeichnung();
	
	/**
	 * Gibt das Volumen des Geschenks zurueck.
	 * 
	 * @return Das Volumen des Geschenks
	 */
	public double gibVolumen();
	
	/**
	 * Gibt die Altersfreigabe des Geschenks zurueck.
	 * 
	 * @return Die Altersfreigabe des Geschenks
	 */
	public byte gibAltersfreigabe();
}
```

So und das ist die Fehlermeldung vom Compiler wenn ich Geschenkmachine compile: 


Geschenkmaschine.java:69: cannot find symbol
symbol  : variable empfaenger
location: class Geschenkmaschine
					SperrgutGeschenk g = new SperrgutGeschenk(empfaenger, bezeichnung, altersfreigabe, volumen);
Das blöde ich habe die genaue Wortfolge benutzt wie im Konstruktor der Klasse SperrgutGeschenk

Hoffe ihr könnt mir weiterhelfen!!


----------



## age (29. Dez 2011)

Der Compiler kennt den Datentyp deiner Variable empfaenger nicht.
Code nicht genau angeschaut.
Hast du empfaenger in Geschenkmaschine deklariert?


----------



## Xeno1987 (29. Dez 2011)

hi

ne empfaenger ist schon in SperrgutGeschenk schon als methode drin. Ich will dann mit new ein neues Objekt der Klasse Sperrgut erzeugen mit den aktuellen DAten des Kindes welche auch im Konstruktor von Sperrgut schon stehen. Das ganze wird später sowieso aus einer Datei gelsen.


----------



## age (29. Dez 2011)

Ja es ist ja schön und gut, dass empfaenger in SperrgutGeschenk implementiert ist.
Aber deswegen kennt sie Dein Geschenkmaschine Objekt doch noch lange nicht?

Der Konstruktor von SperrgutGeschenk erwartet ein IKind, deswegen kann sich deine Geschenkmaschine aber trotzdem kein entsprechendes Objekt herzaubern?


----------



## age (29. Dez 2011)

Kurz mal deine Klasse in Eclipse kopiert, Eclipse mängelt deine nicht vorhandene Variable empfaenger an...
ich hab mich also doch nicht nur verschaut.
Zu deinem empfaenger sagt Eclipse: empfaenger cannot be resolved to a variable

Das IKind, dass dein Konstruktor erwartet, wird innerhalb deines Konstruktors mit dem Namen empfaenger angesprochen...
außerhalb dieses Konstruktors existiert dieser Name aber nicht.

Du kannst nicht einfach bei Aufruf dieses Konstruktors empfaenger reinschreiben.
Denn wo kein Objekt existiert, kann auch keins übergeben werden


----------



## Xeno1987 (29. Dez 2011)

und was mach ich jetzt, soll ich in geschenkmachine einfach oben die variablen deklarieren?


----------



## age (29. Dez 2011)

Wenn Du sie oben deklarierst, dann weis Dein Compiler, dass empfaenger ein IKind ist.
Aber deswegen hast Du trotzdem noch kein Objekt, mit dem Du arbeiten kannst.
Du musst schon das entsprechende Objekt an die Methode übergeben.


----------



## Xeno1987 (29. Dez 2011)

ich hab jetzt das hier :


```
protected void geschenkeErstellenUndKlassifizieren(){
		String klassifikation;
		for(int i=0;i<=kinder.size();i++){
			IKind empfaenger;
			String bezeichnung;
			byte altersfreigabe;
			double volumen;

			Kind aktKind= (Kind)kinder.get(i);
			
	
			for(int j=aktKind.gibWuensche().size()-1;j>=0;j--){
				Wunsch derwunsch= (Wunsch)aktKind.gibWuensche().get(i);
				if(derwunsch.gibVolumen()>=80.0){
					SperrgutGeschenk g = new SperrgutGeschenk(empfaenger, bezeichnung, altersfreigabe, volumen);
					
					klassifikation = "Sperrgut";
					geschenke.add(g);
				} else {
				
					NormalesGeschenk g = new NormalesGeschenk(empfaenger, bezeichnung, altersfreigabe, volumen);
					klassifikation = "Normales Geschenk";
					geschenke.add(g);
				}
				System.out.println("Wunsch" + derwunsch.gibBezeichnung() + "von" + aktKind.gibName() + "wird als " + klassifikation + "erstellt!" );
				
		    }
			
		}
		
	}
```


----------



## Gast2 (29. Dez 2011)

Ist das Kind nicht der Empfänger des Geschenks? Wenn deine Klasse Kind IKind implementiert, dann kannst du einfach 
	
	
	
	





```
aktKind
```
 übergeben.


----------

