# Generics: Generischer Konstruktor-Aufruf?



## TSH (29. Okt 2008)

Ich möchte mit Generics arbeiten und den Code möglichst generisch halten. Dazu habe ich nun ein Interface Geschaeft und eine abstrakte Klasse AbstraktesGeschaeft, das wiederum Methoden für Baeckerei und Metzgerei kapselt:


```
interface Geschaeft<P extends Produkt> { 
  public P erstelleProdukt(); 
} 

interface Produkt { 
  ..
} 

class Backware implements Produkt { 
  ..
} 

class Schnitzel implements Produkt  { 
  ..
} 

class Baeckerei extends AbstraktesGeschaeft<Backware> { 
  // Methoden sollen vom abstrakten Geschäft geerbt werden, so dass
  // erstelleProdukt automatisch eine Backware erzeugt.  
} 

class Metzgerei extends AbstraktesGeschaeft<Schnitzel> { 
  // Methoden sollen vom abstrakten Geschäft geerbt werden, so dass
  // erstelleProdukt automatisch ein Schnitzel erzeugt.  
} 

abstract class AbstraktesGeschaeft<P extends Produkt> implements Geschaeft

 { 

  public P erstelleProdukt() { 
    return new P(); // !!! Fehler: Es kann keine Instanz von P erzeugt werden !!
  } 

}
```
Wie bereits oben beschrieben, scheitert der Ansatz im fehlenden generischen Konstruktor. Kann man das Problem irgendwie lösen?


----------



## maki (29. Okt 2008)

P ist ein Interface.


----------



## TSH (29. Okt 2008)

OK, stimmt. Danke. Ich hab jetzt als Zwischenschritt auch noch ein AbstraktesProdukt eingeführt, um Gemeinsamkeiten von Produkten vererben zu können. Aber da es eine abstrakte Klasse ist, kann (und will) ich deren Konstruktor ja auch nicht benutzen.

```
interface Geschaeft<P extends Produkt> { 
  public P erstelleProdukt(); 
} 

interface Produkt { 
  .. 
} 

abstract class AbstraktesProdukt implements Produkt {

}

class Backware extends AbstraktesProdukt { 
  .. 
} 

class Schnitzel extends AbstraktesProdukt  { 
  .. 
} 

class Baeckerei extends AbstraktesGeschaeft<Backware> { 
  // Methoden sollen vom abstrakten Geschäft geerbt werden, so dass 
  // erstelleProdukt automatisch eine Backware erzeugt.  
} 

class Metzgerei extends AbstraktesGeschaeft<Schnitzel> { 
  // Methoden sollen vom abstrakten Geschäft geerbt werden, so dass 
  // erstelleProdukt automatisch ein Schnitzel erzeugt.  
} 

abstract class AbstraktesGeschaeft<P extends Produkt> implements Geschaeft

 { 

  public P erstelleProdukt() { 
    return new P(); // !!! Fehler: Es kann keine Instanz von P erzeugt werden !! 
  } 

}
```

Was muss ich also statt *new P()* aufrufen, damit jede erbende Klasse seinen Typ erzeugt?


----------



## maki (29. Okt 2008)

Weiss nicht ob Generics da richtig sind, du willst eigentlich eine (abstrakte?) Factory.


----------



## TSH (29. Okt 2008)

Also Generics brauche ich (denke ich) auch noch aus anderen Gründen. Das oben ist ja nur ein Minimalbeispiel. Ich sollte nun also so etwas wie eine AbstrakteProduktfabrik erstellen?

Wie würde die dann aussehen bzw. müsste die dann nicht auch generisch sein, wenn sie mir je nach Fall Backwaren, Schnitzel o.ä. liefern soll?


----------



## HoaX (29. Okt 2008)

einfach nicht in der abstrakten klasse machen sondern direkt in metzgerei new BratwurstMitSenf()


----------



## tfa (29. Okt 2008)

HoaX hat gesagt.:
			
		

> einfach nicht in der abstrakten klasse machen sondern direkt in metzgerei new BratwurstMitSenf()


Das ist meiner Meinung nach die sinnvollste Lösung.

Man kann aber auch tricksen:

```
(Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]
```
Damit bekommst du Class<Schnitzel> und kannst über Reflection Objekte anlegen. Das ist aber aus verschiedenen Gründen hässlich.


----------



## maki (29. Okt 2008)

TSH hat gesagt.:
			
		

> Also Generics brauche ich (denke ich) auch noch aus anderen Gründen. Das oben ist ja nur ein Minimalbeispiel. Ich sollte nun also so etwas wie eine AbstrakteProduktfabrik erstellen?
> 
> Wie würde die dann aussehen bzw. müsste die dann nicht auch generisch sein, wenn sie mir je nach Fall Backwaren, Schnitzel o.ä. liefern soll?


Eine abtrakte Fabrik erzeugt abstrakte Produkte, sie  delegiert an konkrete Fabriken, welche konkrete Produkte erzeugen.


----------



## TSH (29. Okt 2008)

Die Klassen Backware und Schnitzel haben schon ihre eigenen Konstruktoren. Ich hab die o.g. Methode etwas vereinfacht. Jetzt schreib ich sie mal realisätsnaher. Es geht nicht darum, 1 Produkt herzustellen, sondern eine Liste von k Produkten des angestrebten Typs. Und da es für alle immer gleich ist, würd ich es gerne in das AbstrakteGeschäft verschieben:


```
abstract class AbstraktesGeschaeft<P extends Produkt> implements Geschaeft

 { 

  public List

 erstelleSortiment(int k) { 
    List

 liste = new ArrayList

();
    for ( int i = 1; i <= k; i++ ) {
      P produkt = ??? // Factory aufrufen? Konstruktor aufrufen? Wovon?
      liste.add(produkt);
    }
      return liste;
  } 

}
```
Dann erspar ich mir das Erstellen eines Sortiments in 25 Produktklassen. Ich kann auch gerne eine Abstrakte Fabrik machen, aber brauch ich dann nicht auch eine Fabrik pro Produkt-Typ?


----------



## maki (29. Okt 2008)

>> aber brauch ich dann nicht auch eine Fabrik pro Produkt-Typ?

Ja.


----------



## TSH (29. Okt 2008)

Das will ich ja gerade vermeiden. Dann bräuchte ich ja eher eine "Generische" Fabrik statt einer Abstrakten Fabrik.


----------



## schalentier (29. Okt 2008)

```
abstract class AbstraktesGeschaeft<P extends Produkt> implements Geschaeft

 { 

  public List

 erstelleSortiment(int k) { 
    List

 liste = new ArrayList

();
    for ( int i = 1; i <= k; i++ ) {
      P produkt = createProdukt();
      liste.add(produkt);
    }
      return liste;
  } 
  protected abstract P createProdukt();

}
```

createProdukt dann in den Konkreten Geschaeften implementieren.

Was wuerde eigentlich passieren, wenn du in diesem Beispiel komplett auf Generics verzichten wuerdest?


----------



## maki (29. Okt 2008)

TSH hat gesagt.:
			
		

> Das will ich ja gerade vermeiden. Dann bräuchte ich ja eher eine "Generische" Fabrik statt einer Abstrakten Fabrik.


Wenn sich alle deine Produkte gleich verhalten, wozu überhaupt Factories/Generics?


----------



## TSH (29. Okt 2008)

Erstmal zwischendurch: Danke Euch allen!



			
				schalentier hat gesagt.:
			
		

> createProdukt dann in den Konkreten Geschaeften implementieren.


Das will ich doch gerade vermeiden. Für 25 Produkte 25x den selben Code? Das tut doch irgendwie weh... ;-)



			
				schalentier hat gesagt.:
			
		

> Was wuerde eigentlich passieren, wenn du in diesem Beispiel komplett auf Generics verzichten wuerdest?


Wenn ich es so mache, wie von Dir vorgeschlagen, bräuchte ich sie glaub ich wirklich nicht. Aber ich dachte, genau für solche Fälle wären Generics da: Generische Methoden für sehr ähnliche Klassen, damit man nicht alles 100x schreiben muss. Und genau so ein Fall liegt doch vor, oder?


----------



## TSH (29. Okt 2008)

maki hat gesagt.:
			
		

> Wenn sich alle deine Produkte gleich verhalten, wozu überhaupt Factories/Generics?


Sie haben schon noch unterschiedliche Properties und Methoden, aber die haben nichts mit dem aktuellen Zusammenhang zu tun. Ich brauche sie an anderer Stelle.


----------



## schalentier (29. Okt 2008)

TSH hat gesagt.:
			
		

> Das will ich doch gerade vermeiden. Für 25 Produkte 25x den selben Code? Das tut doch irgendwie weh... ;-)



Wenn du 25 verschieden Unterklassen von Produkt hast, musst du irgendwo 25x Code schreiben, um diese zu erzeugen, egal welche Patterns du verwenden willst (ausser du machst alles per Reflektion, allerdings rate ich dir davon ab).



			
				TSH hat gesagt.:
			
		

> Aber ich dachte, genau für solche Fälle wären Generics da: Generische Methoden für sehr ähnliche Klassen, damit man nicht alles 100x schreiben muss. Und genau so ein Fall liegt doch vor, oder?



Ich verwende Generics nur, um typisierte Listen umzusetzen. Alles andere is IMHO nur zusaetzlicher und unnoetiger Overhead (siehe dein Beispiel).


----------



## maki (29. Okt 2008)

>> Das will ich doch gerade vermeiden. Für 25 Produkte 25x den selben Code? Das tut doch irgendwie weh... 

Dann nimm eine Factory, keine abstrakte Factory, wenn alle Produkte über den Standardkonstruktor erzeugt & initialisiert werden.

>> Sie haben schon noch unterschiedliche Properties und Methoden, aber die haben nichts mit dem aktuellen Zusammenhang zu tun. Ich brauche sie an anderer Stelle.

Nun, dann müssen trotzdem verschiedene Typen zurückgegeben werden, ob das mit einer Factory rein über Generics möglich ist.. 
denke da wird es "dreckig" mit Reflection.

Oder eben eine Factory Methode pro Produkttyp.


----------



## TSH (29. Okt 2008)

Hm, ok. Ich hab jetzt tatsächlich die createProdukt() Methode in das jeweilige Geschäft (Baeckerei, Metzgerei) verlagert und im Interface verlangt, dass jedes Geschäft das haben muss.

Macht wohl auch Sinn, da ich die einzelnen Produkte nach deren Erstellung sowieso noch leicht bearbeiten muss (je nach Typ). Das kann jetzt da drin geschehen. Danke Euch allen.

Ich habe gelernt, dass Generics nicht der Weisheit letzter Schluss sind ;-)


----------

