Frage zum Design der Vererbung (Kartendeck und Dupletten)

[spidermobile]

Hallo zusammen,

nach dem ich die ersten Grundlagen von Java gelernt habe, mache ich mich nun an das Thema der Vererbung ran. Da stosse ich auf folgendes Problem.

Ich habe eine Klasse CardDeck. Diese speichert die allgemeinen Informationen des Kartendecks. Nun habe ich eine Klasse Player und eine Klasse Computer, die von CardDeck erbt.

Sowohl für Computer, als auch für Player möchte ich nun ein Set von Karten, welches im CardDeck verfügbar ist, erzeugen. Dies ist auch nicht das Problem.

Mein Problem ist, dass beim Erzeugen des Sets für Player und Computer natürlich keine Dupletten erzeugt werden dürfen. So darf also eine Karte, die von Player gezogen wurde, nicht mehr von Computer gezogen werden können.

Ich könnte natürlich alles im CardDeck über verschiedene Arrays abbilden, glaube aber, dass dies nicht der richtige Ansatz ist, da die das ermittelte Set ja Computer bez. Player gehört.

Wie sollte ich optimalerweise dieses Problem lösen?

Grüße und Danke für einen kleinen Tipp.

 

[Wildcard]

Ich denke du soltest auch eine Card Klasse haben. Alle Instanzen dieser Klasse kannst du dann einmalig in deinem CardDeck, oder einer Factory erzeugen lassen und dann an Player und Computer verteilen lassen...

 

[spidermobile]

Hallo Wildcard,

hört sich gut an. Nur zum Verständnis.

Die Klasse Card kümmert sich um das Erzeugen der Sets für Computer und Player. Die Getter Methoden implementiere ich dann in mein CardDeck und kann dann in den Klassen Computer unds Person davon erben.

Hab ich das so richtig verstanden?

 

[Wildcard]

Nein, ich würde mir eine Klasse Card machen die auch wirklich nur eine Spielkarte ist.
Die hat dann getter Methoden um die Farbe, Augenzahl etc. zu bekommen.
Cards sollten dann am besten in einer FactoryKlasse erzeugt werden(und nur dort!) und von irgendeinem Controller verteilt werden.
Gibt natürlich auch noch viele andere Ansätze...
CardDeck soll dann vermutlich für x-Karten stehen und Player und Computer bekommen jeweils ein CardSet oder wie hast du dir das gedacht?

 

[spidermobile]

Mal konkret was ich vorhabe.

Ich habe mal ein Poker mit Flash realisiert. Da ich seit einiger Zeit mir mal die Grundlagen von Java angeeignet habe, dachte ich mir, das Poker-Spiel mal in Java umzusetzen . Die Ermittlungen der Ergebnisse hab ich ja schon in Flash gemacht und diese in Java umzusetzen ist dann nicht mein Problem.

Viel mehr möchte ich mich nun um ein sauberes Design kümmern.

Also was passiert mit den Karten. Computer und Person erhält zunächst 5 Karten. Diese dürfen natürlich nicht doppelt sein. Aus diesem Grund habe ich mir einen String Array mit 52 Karten angelegt. An den Elementen des Arrays sehe ich später auch die Wertigkeit. Die Farbe und Anzahl der Augen ist also nicht von Bedeutung.

Wie beim Poker üblich, werden später auch Karten getauscht. D.h. ich muss sowohl von Player, als auch von Computer auf das Initial erzeugte Set (wird wohl einfach ein Array sein, da es immer 5 Karten sind) später zugreifen und in dem Array Karten tauschen.

Am Ende muss ich dann natürlich die beiden Sets vergleichen um den Gewinner zu ermitteln.

Mein Gedanke war natürlich, wenn ich dies alles im CardDeck unterbringe, kann ich von Player und Computer aus darauf zugreifen.

Das Problem daran ist, dass ich dann auch in meiner Main Methode CardDeck instanzieren muss. Und das wäre natürlich dann nicht mehr im Sinne des Erfinders.

Vielleicht kannst Du mir noch ein paar Zeilen zu diesem Thema schreiben. Viellleicht kennst Du auch einen Link zu einem Tut, der dieses Problem behandelt.

Danke!

 

[Wildcard]

Da es dir um schönes Design geht verwende um Gottes willen kein String-Array mit dem du Karten assozierst!
Mach dir stattdessen wie oben geschrieben eine Card Klasse mit ein paar gettern.
Hier mal ein paar Vorschläge:
Eine Abstrakte Klasse Player die von MenschlicherPlayer und KiPlayer mit leben erfüllt wird.
Jeder dieser Klassen besitzt ein CardDeck das 5 Karten verwaltet und über Methoden zum Tauschen von
Karten und dem Berechnen der Punkte verfügt.
Eine Controller-Klasse die Karten instanziert, x-Player erzeugt, jedem ein CardDeck zuweist (die eigentliche Instanzierung am besten in Factorys auslagern) und die Kommunikation regelt.

 

[spidermobile]

Danke, das werd ich mir wohl erst mal aufmalen müssen :roll: .
Für das Factory kann ich doch bestimmt das Singleton anwenden (ist wohl auch eine Art Factory), das was ich sonst hier im Forum über Factory gelesen habe, übersteigt im Moment noch meine Kenntnisse.

Ach so, das String Array habe ich gemacht, da ich ja auch den Namen der Karten brauche, ich werde das ganze natürlich grafsich aufbereiten und habe hierfür jpg's. Ohne String Array wüßte ich doch sonst gar nicht, wie die Karte heisst.

 

[Wildcard]

Ich denke jede Karte sollte ihr Bild selbst besitzen und evtl. auch in der Lage sein sich selbst zu zeichnen.
Welche Karte das nun im einzelnen ist, ist für dein Programm daher uninteressant. Erst wenn's darum geht die Punkte auszurechnen etc fragen die CardDecks bei den Cards nach. Augenzahl als ints, Farbe als Konstanten zurückgeben usw....

 

[spidermobile]

Ich weiss, dass ich nun meinem Ansatz (sauberes Design) widerspreche, aber wenn ich mir das Array erstellt habe, dann mit Random Zahlen zwischen 0-51 ermittle um damit die Karten zu ermitteln ist das einfach.

Der Vorschlag von Dir klingt plausibel, ist für diesen Fall aber dann wohl für die Klasse Card sehr umständlich, int zwischen 0-13, 4 Farben und dies dann in Kombination per Random ermitteln um dann anschliessend noch zu prüfen, ob dieser Wert schon einmal ermittelt wurde.

Klar geht es, aber wäre eine Konstante, eben das String Array (52 Karten) in diesem Fall nicht sinnvoll. Die Karten werden sich bestimmt die nächsten paar hundert Jahre nicht ändern :wink: .

Sorry, ich möchte Dir auf gar keinen Fall widersprechen, nur für diesen Fall leuchtet mir noch nicht ein, warum ich für jede Karte ein Object brauche.

Ich weiss, ich bin noch nichtin der objektorientierten Denke drin, deshalb auch die Fragen.

 

[Wildcard]

Niemand sagt das du Zufallskarten erzeugen sollst.
Mit OOP versucht man meistens nah an der Realität zu bleiben. Karten entstehen nicht zufällig, sonder es sind immer die Gleichen. Daher erstellst du 52 Card Objekte und verteilst diese dann zufällig. Der große Vorteil dieser Variante liegt erstens in der besseren Übersicht und zweitens lässt es sich sehr viel einfacher auf andere Kartenspiele übertragen, da sich an der Implementierung der Karten nichts ändert...
[edit] wenn die Karten selbst sich zusätzlich im groben an das MVC Prinzip halten lässt es sich leicht realisieren das das User selbst das Aussehen der Karten bestimmen kann etc...[/edit]

 

[spidermobile]

Langsam fängt es an, mir Spass zu machen (ich verstehe langsam).

Wenn Die die Fragerei zu viel wird, sag es, dann höre ich auf.

O.K. verstanden und überzeugt.

Ich erstelle 52 Card Objekte. Bein erstellen übergebe ich dann die Farbe ind die Wertigkeit. Die Objekte speichere ich dann in einer ArrayList ab.

Per Zufall verteile ich nun die Objekte aus dieser List in eine HashMap. HashMap um zu vermeinden, das es Dupletten gibt. Geht das überhaupt (Objektreferenzen in HashMap)?

Wenn ich dann später auswerte, lese ich die HashMap aus, caste und erhalte aus den Getter-Methoden die Werte zum Vergleich.

Ist das so richtig?

 

[Wildcard]

Warum die Hashmap? Mach dir eine Klasse Kartenstapel die alle 52 Karten in einer ArrayList speicher (doppelte können ja gar nicht vorkommen). Kartenstapel hat eine nextCard() Methode bei der zufällig eine Karte aus dem Stapel zurückgegeben wird und diese aus dem Stapel gelöscht wird. Wie gesagt, bleib nahe an der Realität. Deine Controller-Klasse 'gibt' jetzt Karten in dem sie eine Karte vom Stapel nimmt und an die Spieler verteilt.

 

[spidermobile]

Hallo Wildcard,

ich bin begeistert. Vielen lieben Dank.

Nun werde ich mich mal ans Werk machen und Deine Ratschläge beherzigen!!!

Schönen Sonntag noch !!