weggabel für classen

[H2SO3-]

hi,

habe mit sowas mal in c# gearbeitet. Allerdings auch dort nicht selber eingerichtet, weshalb ich nicht genau weis, wie ich das am besten in Java mache.

folgendes.

ich habe zb. eine funktion wie geschenkauswahl ( es ist ja xmas :lol: )
diese funtkion gibt es nun in zb. drei verschiedenen varianten.
1. mutterGeschenk
2. schwesterGeschenk
3. vaterGeschenk

je nachdem was ich nun auswähle soll eine weitere class jeweils das entsprechende geschenk holen.

In C# war es in etwa so.

es gibt jeweils die funktion

String hohleGeschenk()
{
    return "xxx";
}

wenn ich nun meine "entscheiderklasse" instantiziere sage ich ihr was ich haben will, also Schwester, Vater oder mutter.

In der entscheiderklasse gab es nun auch die funtkion String hohleGeschenk();
Die entscheiderklasse entscheidet nun je nach der anfänglichen auswahl was zurückkommt.

Also in etwa so

Entscheiderklasse entscheider = new Entscheiderklasse();
entscheider.auswahl("schwester");

String wasVerschenkeIch = entscheider.hohleGeschenk();

jemand ne idee?????

 

[Murray]

Evtl. hilft Dir da eine abstrakte Klasse Geschenk mit einer abstrakten Methode getGeschenk, von der es dann konkrete Ableitungen VaterGeschenk, MutterGeschenk, SchwesterGeschenk gibt. Die Ableitungen würden dann jeweils die Methode getGeschenk implementieren. Der Entscheider wäre dann quasi eine Factory; er würde abhängig von der Auswahl die konkrete Klasse instanziieren und dann daran die Methode getGeschenk aufrufen.

 

[H2SO3-]

hört sich soweit ganz gut an. Kannst du mir vielleicht ein beispiel zeigen bzw. was wo ich mir darüber was anlesen kann.

 

[0x7F800000]

schau dir (bei wikipedia oder wo auch immer) an was Strategy und Factory patterns sein sollen. Diese sind eigentlich universell, haben nichts konkret mit java zu tun. Wenn du sowas schon in C# gemacht hast, müsste es dir umso leichetr fallen.

 

[H2SO3-]

ok super. danke, häufig bringen einem ja 1 2 stichworte schon ziemlich weiter. Wusste zwar im generellen wie es geht aber hatte keine wirkliche ahnung wonach ich da suchen muss

 

[Murray]

Kannst du mir vielleicht ein beispiel zeigen

Dein Beispiel könnte so aussehen:

public abstract class Schenker {
  public String getGeschenk();
}


public class VaterSchenker extends Schenker {
  @Overrides
  public String getGeschenk() {
    return "Doppelkorn";
  }
}

public class MutterSchenker extends Schenker {
  @Overrides
  public String getGeschenk() {
    return "Eierlikör";
  }
}

public class SchwesterSchenker extends Schenker {
  @Overrides
  public String getGeschenk() {
    return "Prosecco";
  }
}

public class Entscheider {

  static String getGeschenk ( String empfaenger) {
    Schenker g = null;
    if ( "Vater".equalsIgnoreCase( empfaenger)) {
      g = new VaterSchenker();
    } else if ( "Mutter".equalsIgnoreCase( empfaenger)) {
    	g = new MutterSchenker();
    } else if ( "Schwester".equalsIgnoreCase( empfaenger)) {
    	g = new SchwesterSchenker();
    } else {
      throw new IllegalArgumentException( empfaenger);
    }
    
    return g.getGeschenk();
  }
}

Zum Wohl!

 

[0x7F800000]

Hmm, wenn schon, dann vielleicht lieber sowas:

public abstract class Schenker {
  public String getGeschenk();
  public boolean passtDieZielgruppe(String s);
}


public class VaterSchenker extends Schenker {
  @Overrides
  public String getGeschenk() {
    return "Doppelkorn";
  }
  public boolean passtDieZielgruppe(String s){
    return "Vater".equals(s);
  }
}

public class MutterSchenker extends Schenker {
  @Overrides
  public String getGeschenk() {
    return "Eierlikör";
  }
  public boolean passtDieZeilgruppe(String s){
    return "Mutter".equals(s);
  }
}

public class SchwesterSchenker extends Schenker {
  @Overrides
  public String getGeschenk() {
    return "Prosecco";
  }
  public boolean passtDieZeilgruppe(String s){
    return "Schwester".equals(s);
  }
}

public class Entscheider {
  
  private static Schenker schenker=new Schenker[]{
     new VaterSchenker(),
     new MutterSchenker(),
     new SchwesterSchenker(),
     new Schenker(){
         public void getGeschenk(){
            return "Socken";
         }
         public void passtDieZielgruppe(String s){ return true;} // hmm... außer jemand hat keine Beine ),;
     }
  }

  static String getGeschenk (String empfaenger) {
    for(Schenker s:schenker){
      if(g.passtDieZielgruppe(empfaenger)) return g.getGeschenk();
    }
    return null;
  }
}

?

 

[Murray]

Hmm, wenn schon, dann vielleicht lieber sowas:

public abstract class Schenker {
  public String getGeschenk();
  public boolean passtDieZielgruppe(String s);
}
/* ... */

Klar, das geht auch - ich hatte den TO nur so verstanden, dass er explizit eine "Entscheider"-Einheit haben wollte, die die Auswahl trifft. Wenn die Logik schon in den einzelnen Ausprägungen steckt, dann bleibt dafür kein Raum mehr.

 

[SirGecco]

Eine Möglichkeit mit Interfaces.

Interface

public interface Schenken {
	public void holeGeschenk();
}

public class Vater implements Schenken {

	@Override
	public void holeGeschenk() {
		System.out.println("Geschenk aus Klasse Vater");
	}
}

public class Mutter implements Schenken {

	@Override
	public void holeGeschenk() {
		System.out.println("Geschenk aus Klasse Mutter");
	}
}

Anwendung

public class Geschenke {
	
	public static void main(String[] args) {
		Geschenke geschenke = new Geschenke();
		geschenke.ausgeben();
	}

	private void ausgeben() {
		Schenken papa = new Vater();
		Schenken mama = new Mutter();
		papa.holeGeschenk();
		mama.holeGeschenk();
	}

}

Ausgabe:
Geschenk aus Klasse Vater
Geschenk aus Klasse Mutter

 

[0x7F800000]

ich hatte den TO nur so verstanden, dass er explizit eine "Entscheider"-Einheit haben wollte, die die Auswahl trifft. Wenn die Logik schon in den einzelnen Ausprägungen steckt, dann bleibt dafür kein Raum mehr.

jo, das stimmt auch wieder. Okay, egal, sorry. Das Beispiel ist irgendwie so extrem minimalistisch, dass mir grad nicht einfällt, was da "sinnvoll" oder "unsinnig" ist.

@SirGecco:
klein Bisschen zu spät warst du^^

 

[mahe]

Je nach Anforderung kann man sowas mehr oder weniger komplex mit Enums lösen.
Im ersten Fall die Direkt-Schenk-Variante und im zweiten eine mit Prototypen einer Schenker-Klasse.

/*
 * Einfache Variante
 */
enum SchenkerEinfach {
	VATER("Doppelkorn"),
	MUTTER("Eierlikör"),
	SCHWESTER("Prosecco");
	
	private String geschenk;
	
	SchenkerEinfach(String geschenk) {
		this.geschenk = geschenk;
	}
	
	public String schenke() {
		return geschenk;
	}
}


/*
 * Variante mit Schenker-Klasse
 */
class Schenker {
	private String geschenk;
	
	public Schenker(String geschenk) {
		this.geschenk = geschenk;
	}
	
	public String schenke() {
		return this.geschenk;
	}
	
	public Schenker clone() {
		return new Schenker(this.geschenk);
	}
}

enum SchenkerMitKlassen {
	VATER(new Schenker("Doppelkorn")),
	MUTTER(new Schenker("Eierlikör")),
	SCHWESTER(new Schenker("Prosecco"));
	
	private Schenker schenker;
	
	SchenkerMitKlassen(Schenker schenker) {
		this.schenker = schenker;
	}
	
	public Schenker schenker() {
		return schenker.clone();
	}
}


/*
 * Testen der Varianten
 */
public class Main {

	public static void main(String[] args) {
		
		System.out.println(SchenkerEinfach.valueOf("SCHWESTER").schenke());
		
		Schenker s = SchenkerMitKlassen.valueOf("SCHWESTER").schenker();
		System.out.println(s.schenke());
	}
}

 

[SirGecco]

Du hast ja schon Lösungen erhalten, der Beitrag ist eine (weitere) Möglichkeit und Anregung (viele Wege führen nach ...)

 

[0x7F800000]

Du hast ja schon Lösungen erhalten, der Beitrag ist eine (weitere) Möglichkeit und Anregung (viele Wege führen nach ...)

weiß zwar nicht, wer mit "Du" gemeint war, der zweite Teilsatz nach dem komma bezog sich aber anscheinend irgendwie auf meine Bemerkung.
Klar führen mehrere Wege zur Lösung. Aber drei mal dasselbe Vorzuschlagen ist schon fast zuviel des Guten (drei mal: ich hab ja auch nur Murray's vorschlag anders hingeschrieben, um den OP auf die möglichkeit anonymer Klassen hinzuweisen).

@mahe:
Ist das eigentlich gut erweiterbar? Hab irgendwie im Leben nie was von enums abgeleitet, stelle ich grad fest

 

[H2SO3-]

hey, da ist ja noch richtig viel gekommen vielen dank dafür erstmal.
klar ist mein beispiel sehr einfach, war ja auch dafür gedacht etwas einfaches schnell präzentierbares zu schreiben. Ich denke komplizierter kann man es immer noch machen, wenn man das Prinzip verstanden hatt.

Vielen dank an alle und euch noch ein schönes fest und was man da sonnst noch so alles wünscht *gg* :applaus: