# Klassen parametrisieren



## Tosso (28. Jul 2012)

Ich habe mir die Hefte vom SGD-Kurs für Java Programmierer gekauft. Bisher konnte ich halbwegs nachvollziehen, ob meine Lösungen richtig sind. Aber bei dieser Aufgabe bin ich mir absolut nicht sicher, wie die Lösung aussehen soll.

*Aufgabenstellung:*
Gegeben sei folgende Klassenstruktur:

```
interface IAusgebildet {}
```


```
class Person {}
```


```
class Angestellter extends Person implements IAusgebildet{}
```


```
class Auszubildender extends Person {}
```

Wie muss eine weitere Klasse


```
public class Gesucht extends Person
```

parametrisiert werden, damit einer Gesucht-Instanz ausschließlich ausgebildete Angestellte zugewiesen werden können? Geben Sie auch an, wie Sie eine Gesucht-Instanz erzeugen, auf einem Angestellten festlegen (set-Methode) und diesen Angestellten auf Konsole wieder ausgeben (get-Methode).

*Meine Lösung wäre:*

```
interface IAusgebildet {}
class Person {}
class Angestellter extends Person implements IAusgebildet{}
class Auszubildender extends Person {}

public class Gesucht <IAusgebildet> extends Person {

    private IAusgebildet gesucht;

    public static void main(String[] args) {
        Gesucht <Angestellter> angestellter = new Gesucht <Angestellter>();
        angestellter.setGesucht(new Angestellter());
        System.out.println(angestellter.getGesucht());
    }

    private void setGesucht(IAusgebildet gesucht) {
        this.gesucht = gesucht;      
    }

    public IAusgebildet getGesucht() {
        return gesucht;
    }

}
```


----------



## tagedieb (28. Jul 2012)

Du solltest noch erwähnen was das Ziel/Thema dieser Übung ist um das Problem besser zu verstehen.

Ich nehme an es geht um Generics. Dann würde meine Lösung so aussehen:


```
interface IAusgebildet {
}

class Person {
}

class Angestellter extends Person implements IAusgebildet {
}

class Auszubildender extends Person {
}

public class Gesucht<T> extends Person {

	private T gesucht;

	public static void main(String[] args) {
		Gesucht<IAusgebildet> angestellter = new Gesucht<IAusgebildet>();
		// Gesucht<Angestellter> angestellter = new Gesucht<Angestellter>();
		angestellter.setGesucht(new Angestellter());
		System.out.println(angestellter.getGesucht());
	}

	private void setGesucht(T gesucht) {
		this.gesucht = gesucht;
	}

	public T getGesucht() {
		return gesucht;
	}

}
```


----------



## Tosso (28. Jul 2012)

Danke für die schnelle Antwort!

Mehr als die angegebene Aufgabenstellung steht da nicht, aber im Heft wird auch ganz kurz der Begriff Generics erwähnt. Von daher denke ich, dass das gemeint ist.

Zu Beginn hatte ich auch 

```
Gesucht<IAusgebildet> angestellter = new Gesucht<IAusgebildet>();
```
stehen. Aber ich bekam immer die Fehlermeldung: "Cannot make a static reference to the non-static type IAusgebildet".

Vermutlich wegen dem 
	
	
	
	





```
private IAusgebildet gesucht;
```


----------



## tagedieb (28. Jul 2012)

Schwierig zu sagen ohne den ganzen Code wie er war zu sehen.

Ich vermute es lag an deiner definition der Klasse


```
public class Gesucht <IAusgebildet> extends Person { ...
```

In diesem Kontext wird 
	
	
	
	





```
<IAusgebildet>
```
 nicht das Interface referenziert, sondern es deklariert einen generischen Typ mit Namen 'IAusgebildet'. Dies wird wohl Konflikte mit dem Interface bewirkt haben!


----------



## Tosso (29. Jul 2012)

Stimmt, es lag an der definition der Klasse. Danke für die zusätzliche Information


----------

