Geht so was? public void verkaufe (<X implements Produkt&

[TSH]

Der Titel ist etwas schräg. Ich weiss leider nicht den Namen für mein Problem. Ich schildere es einmal an einem Beispiel:

Ich habe ein Interface "Geschaeft" und mehrere Klassen

Baeckerei implements Geschaeft
Metzgerei implements Geschaeft
...

Zusätzlich ein Interface "Produkt":

Backware implements Produkt
Schnitzel implements Produkt

Jetzt möchte ich im Interface Geschaeft festlegen, dass die implementierenden Klassen bitteschön eine Methode anbieten müssen, um ihre Produkte zu verkaufen.

Erster Versuch:

Im Interface Geschaeft:
public void verkaufe(Produkt p);

In der Klasse Baeckerei:
public void verkaufe(Produkt p) {
...
}

Will ich nicht. Die Bäckerei soll sich schon auf Backwaren (und nicht Schnitzel) spezialisieren dürfen, also

Zweiter Versuch:

Im Interface Geschaeft:
public void verkaufe(Produkt p);

In der Klasse Baeckerei:
public void verkaufe(Backware b) {
...
}

Backware implementiert zwar Produkt, aber mein Compiler sieht das Interface Geschaeft nun nicht mehr als von der Baeckerei erfüllt an. Gibt es ein Konstrukt a la

Im Interface Geschaeft:
public void verkaufe(<X implementiert Produkt> p);

??? Würde mich über Antworten freuen!

 

[SlaterB]

interface Geschaeft<P implements Produkt> { // oder P extends Produkt, ausprobieren

public void verkaufe(P p);

}

class Baeckerei implements Geschaeft<Backware> {

..

}

 

[TSH]

Hm, danke aber:

implements ergibt einen Syntax error und extends führt immer noch dazu, dass

Baeckerei.verkaufe(Backware b)

nicht als Implementierung von

Geschaeft.verkaufe(Produkt p)

anerkannt wird. :-(

Hab's so:

public interface Geschaeft<p extends Produkt> {
  public void verkaufe(Produkt p);
}

public class Baeckerei implements Geschaeft<Backware> {
  public void verkaufe(Backware b) {
    ... // Compiler meckert, da ich keine Produkte verkaufe
  }
}

public class Metzgerei implements Geschaeft<Schnitzel> {
  public void verkaufe(Schnitzel s) {
    ...
  }
}

 

[SlaterB]

wie sieht denn die Backware-Klasse aus?
im Zweifel muss es aber jemand anders beantworten, habe gerade kein Programm zur Verfügung

edit:

public interface Geschaeft<p extends Produkt> {
public void verkaufe(Produkt p);
}

ist aber auch nicht das was ich geschrieben habe!, da hast du ja als Parametertyp in verkaufe Produkt, nicht den generischen Klassenparameter p,

public void verkaufe(p p);

was zeigt, wie schlecht ein Kleinbuchstabe als generischer Parameter ist

 

[TSH]

Ah danke! Mit

 Geschaeft<P implements Product> und
verkaufe(P produkt);

Klappt es! Vielen Dank.

 

[TSH]

[ Problem hat sich erledigt ]

 

[TSH]

Jetzt habe ich doch noch eine Frage: Viele Methoden sind ja bei Metzgerei, Baeckerei usw. ähnlich. Meine Idee ist jetzt eine gemeinsame abstrakte Oberklasse AbstraktesGeschaeft, welche Methoden kapselt. Beispiel: Produkte haben immer einen Preis. Also kann ich die Methode printPreis() ja eigentlich kapseln, oder?

Aber wie krieg ich es so generisch hin, dass Baeckereien ihre Backwaren und Metzgereien ihre Schnitzel auszeichnen? Es sieht jetzt so aus:

public interface Geschaeft<P extends Produkt> { 
  public void verkaufe(P p); 
  public void printPreis();  
} 

public interface Produkt {
  public double getPreis();
}

public abstract class AbstraktesGeschaeft implements Geschaeft<???> { 

  public void verkaufe(???) { 
    // Was soll hier getan werden? 
    // Produkte verkaufen und nachher überschreiben?
    // Kann man überschreiben hier erzwingen?
  } 

  public void zeichneAus();  
    // Ich würde die Methode gerne so generisch schreiben, dass 
    // System.out.println("Preis: " + ???.getPreis());
    // mit dem jeweiligen Typ funktioniert.
} 


public class Baeckerei extends AbstraktesGeschaeft implements Geschaeft<Backware> { 
  public void verkaufe(Backware b) { 
    ...
  } 
} 

public class Metzgerei extends AbstraktesGeschaeft  implements Geschaeft<Schnitzel> { 
  public void verkaufe(Schnitzel s) { 
    ... 
  } 
}

Ich hoffe, ich konnte das einigermaßen rüberbringen. Mir fehlen halt die ???

 

[Marco13]

Du kannst dem AbstraktenGeschäft schon einen Typ geben.

Meintest du sowas wie ....

class GeschaeftTest
{
    public static void main(String args[])
    {
        Geschaeft<Backware> g0 = new Baeckerei();
        g0.verkaufe(new Backware());
        g0.zeichneAus(new Backware());

        Geschaeft<Schnitzel> g1 = new Metzgerei();
        g1.verkaufe(new Schnitzel());
        g1.zeichneAus(new Schnitzel());

    }

}


interface Geschaeft<P extends Produkt> {
  public void verkaufe(P p);
  //public void printPreis();
  public void zeichneAus(P p);
}

interface Produkt {
  public double getPreis();
}

class Backware implements Produkt
{
    public double getPreis() { return 123; }
}
class Schnitzel implements Produkt
{
    public double getPreis() { return 456; }
}


abstract class AbstraktesGeschaeft<P extends Produkt> implements Geschaeft

 {

  public void verkaufe(P p) {
      System.out.println("Verkaufe "+p);
    // Was soll hier getan werden?
    // Produkte verkaufen und nachher überschreiben?
    // Kann man überschreiben hier erzwingen?
  }

  public void zeichneAus(P p)
  {
      System.out.println("ZeichneAus "+p.getPreis());
    // Ich würde die Methode gerne so generisch schreiben, dass
    // System.out.println("Preis: " + ???.getPreis());
    // mit dem jeweiligen Typ funktioniert.
  }
}


class Baeckerei extends AbstraktesGeschaeft<Backware> implements Geschaeft<Backware> {
  public void verkaufe(Backware b) {
    //...
  }
}

class Metzgerei extends AbstraktesGeschaeft<Schnitzel>  implements Geschaeft<Schnitzel> {
  public void verkaufe(Schnitzel s) {
    //...
  }
}

!?


im Prinzip braucht man dann nicht mehr
class Baeckerei extends AbstraktesGeschaeft<Backware> implements Geschaeft<Backware> {
zu schreiben - es würde auch
class Baeckerei extends AbstraktesGeschaeft<Backware> {
reichen. Aber das ist wohl nicht sooo wichtig.

 

[TSH]

Vielen Dank.