Meiner Meinung ist die Klasse Laenderkarte überflüssig und bietet keinen Mehrwert, für Deinen kannst doch direkt Land Objekte nehmen. Für den Tisch würde ich ohnehin direkt das enum Land nehmen, da Du damit ja immer vergleichen musst, wenn sich ein Gast setzen will.
Jeder Tisch hat eine Liste von Stühlen.
private List<Stuhl> stuehle = new ArrayList<Stuhl>();
public void addStuhl(Stuhl stuhl){
if(stuehle.size() == 4){
System.err.println("Kein Platz mehr fuer weitere Stuehle");
} else {
stuehle.add(stuhl);
}
}
}
Jeder Stuhl kennt den Tisch an den er gesetzt wird.
private Gast gast;
private Tisch tisch;
public void addToTisch(Tisch tisch){
this.tisch = tisch;
}
public void addGast(Gast gast){
if(gast == null){
this.gast = gast;
} else {
System.err.println("Stuhl schon besetzt");
}
}
}```[quote=timbeau]public void addGast(Gast gast){ if(gast == null){ this.gast = gast; } else { System.err.println("Stuhl schon besetzt"); } }[/quote]
der Teufel liegt im Detail, Vorsicht 
Ohman , shame on me.
Die Zeile mit der Abfrage ob der Stuhl schon von einem Gast belegt ist, muss natürlich „if(this.gast == null)“ heißen.
Ich bin einfach zu lange raus aus der Programmierung 
Naiver weise könnte man jetzt noch meckern, dass man mit der Methode den Gast nicht mehr auf null setzten kann.
Ich sage aber, dass man dazu sowieso besser eine Methode removeGast() schreiben sollte.
bye
TT
[QUOTE=timbeau]Jeder Tisch hat eine Liste von Stühlen.
private List<Stuhl> stuehle = new ArrayList<Stuhl>();
public void addStuhl(Stuhl stuhl){
if(stuehle.size() == 4){
System.err.println("Kein Platz mehr fuer weitere Stuehle");
} else {
stuehle.add(stuhl);
}
}
}
Jeder Stuhl kennt den Tisch an den er gesetzt wird.
private Gast gast;
private Tisch tisch;
public void addToTisch(Tisch tisch){
this.tisch = tisch;
}
public void addGast(Gast gast){
if(gast == null){
this.gast = gast;
} else {
System.err.println("Stuhl schon besetzt");
}
}
}```[/QUOTE]
Dem Namen nach würde ich von der `Stuhl#addToTisch()` Methode intuitiv erwarten, dass sie `Tisch#addStuhl()` aufruft.@Crian : Das sehe ICH etwas anders. Hier würde ich in einer übergeordneten Klasse eher etwas in der Art “setzeStuhlUndTisch” oder “composeChairToTable” und dort beides aufrufen.
was ich vielleicht zuvor schon erstmals ins Spiel gebracht habe kann auch wirklich gefährlich sein, etwa wenn
Tisch#addStuhl() bereits manuell aufgerufen wurde,
dann kommt Stuhl#addToTisch() mit zweitem Mal Tisch#addStuhl(), doppelten Hinzufügen…
allerdings auch bisschen irrsinnig wie viele hier zu diesem Programm mit überschaubarer Weltbedeutung schreiben
Bei den Tischen hast du die toString() auch noch nicht überschrieben.
Ansonsten die Ausgabe sollte ganz flott über Arrays.toString(list.toArray()) funktionieren.
[QUOTE=BinaryLogic]Bei den Tischen hast du die toString() auch noch nicht überschrieben.
Ansonsten die Ausgabe sollte ganz flott über Arrays.toString(list.toArray()) funktionieren.[/QUOTE]
Oh ja, okay, danke schön, woran man hier nicht alles denken muss.
return land + "";
}```
Klappt alles knorke.
Edit: Sodele, habe nun auch die Stühle generieren können.
So sieht meine Stuhlklasse aus:
```package spiel;
public class Stuhl {
private Gastkarte gast;
private Tisch tisch;
public Stuhl(Gastkarte gast) {
this.gast = gast;
}
public void addToTisch(Tisch tisch){
this.tisch = tisch;
}
public String toString(){
return gast + "";
}
public void addGast(Gastkarte gast){
if(this.gast == null){
this.gast = gast;
} else {
System.err.println("Der Stuhl ist bereits belegt!");
}
}
}```
Ich hab nun ne Methode spielfeldgenerieren, welche sich dem Fall der Generierung der Tische und Stühle schon mal annimmt:
```public static void spielfeldgenerieren() {
for(int n=0;n<12;n++) {
tische.add(new Tisch(laenderkarten.get(n)));
}
for(int n=0;n<24;n++) {
stuehle.add(new Stuhl(null));
}
System.out.println(stuehle);
System.out.println(tische);
}```
Die Tischliste gibt dann schön die 12 Tischwerte aus, also die Länder, welche darauf liegen.
Und die Stuhlliste sind 24 Nullwerte. Wie gewollt, sitzt ja auch noch nichts drauf. ;)Aus meiner Sicht wichtig: in der Klasse Tisch ist das Feld Laenderkarte final, dass heist, dass man dort später keine neue Laenderkarte zuweisen kann.
bye
TT
Das liegt wohl daran, dass es hier im Forum zur Zeit sehr wenige Threads zu beantworten gibt. Außerdem ist das Spiel recht interessant.
*** Edit ***
@FranzFerdinand
Ich finde es etwas gewagt, wenn es schon die beiden Klassen Laenderkarte und Land gibt (Laenderkarte scheint mir generell überflüssig zu sein, aber egal), dann später eine Variable vom Typ Laenderkarte land zu nennen.
[QUOTE=FranzFerdinand;106999]
import spiel.Gastkarte.Land;
public class Laenderkarte {
public final Land land;
public Laenderkarte(Land land){
this.land = land;
}
public String toString(){
return land + "";
}
}
[…]
import java.util.ArrayList;
import java.util.List;
import spiel.Gastkarte.Land;
public class Tisch {
private List<Stuhl> stuehle = new ArrayList<Stuhl>();
public final Laenderkarte land;
public Tisch(Laenderkarte land){
this.land = land;
}
}```[/QUOTE]
*** Edit ***
[QUOTE=FranzFerdinand;107006]
```public String toString(){
return land + "";
}```
[/QUOTE]
Generell ist es etwas hässlich, mit einem `+ ""` den Typ zu verbiegen. Verwende dafür besser `land.toString()`, falls `land` eine sinnvolle Methode `toString()` hat.
Bei Integerzahlen kann man sich etwa mit `Integer.toString(index)` behelfen.
*** Edit ***
[QUOTE=timbeau;106985]@Crian : Das sehe ICH etwas anders. Hier würde ich in einer übergeordneten Klasse eher etwas in der Art "setzeStuhlUndTisch" oder "composeChairToTable" und dort beides aufrufen.[/QUOTE]
Naja, aber
``` private Tisch tisch;
public void addToTisch(Tisch tisch){
this.tisch = tisch;
}
ist einfach nur ein Setter. Dann sollte man das Ding imho auch so nennen:
public void setTisch(Tisch tisch){
this.tisch = tisch;
}
[quote=Crian]Naja, aber``` private Tisch tisch;
public void addToTisch(Tisch tisch){
this.tisch = tisch;
}```ist einfach nur ein Setter. Dann sollte man das Ding imho auch so nennen:[/quote]Rein technisch gesehen hast Du recht.
Aber ich denke, dass Setter als solche erstmal schlecht sind und in Fachklassen vermieden werden sollten.
Dieser hier ist aber eine fachliche Notwendigkeit was auch über den Namen transportiert wird. Dieser Name erhöht die Hemmschwelle ein null zu übergeben. Das allein ist für mich schon den anderen Namen wert.
bye
TT
[QUOTE=FranzFerdinand]```package spiel;
public class Stuhl {
private Gastkarte gast;
private Tisch tisch;
...
public void addToTisch(Tisch tisch){
this.tisch = tisch;
}
}```[/QUOTE]
So kann einem Stuhl nur ein Tisch zugeordnet werden. In dem Spiel kann bei der Anordnung ein Stuhl an bis zu drei Tischen stehen.
[quote=_Michael;107037]So kann einem Stuhl nur ein Tisch zugeordnet werden. In dem Spiel kann bei der Anordnung ein Stuhl an bis zu drei Tischen stehen.[/quote]Deswegen war meine Idee, einem Stuhl “seine” Tische als Varars im Konstruktor zu übergeben. Der Stuhl würde sich dann selbst an die übergebenen Tische “stellen”, womöglich mittels “package private” Methode in der Tisch-Klasse.
bye
TT
Stimmt, das wäre sicherlich eine gute Sache. Mir ging es auch in dem Prototyp nicht darum eine fertige Klasse zu entwickeln sondern die Verbindung von Tisch und Stuhl aufzuzeigen.
Kann ich nachvollziehen. Ich habe die Spiellogik auch mal spaßeshalber durchimplementiert und im ersten Ansatz hatte ich auch eine Klasse „Laenderkarte“, die nur eine einzige Eigenschaft, nämlich „Land“ hatte. Das habe ich dann aber abgeändert, sodass „Land“ direkt benutzt wurde, weil eine überflüssige Abstraktionsebene entfallen konnte.
An der toString()-Variante ist besser, dass der Methodenaufruf explizit gemacht wird. Bei der + ""-Variante wird er auch gemacht, aber implizit zum konvertieren der Variablen in einen String, weil durch das + "" ein String-Kontext erzwungen wird. In der ersten Variante sieht man sofort was passiert, in der zweiten Variante ist der Schritt zur toString()-Methode nicht so offensichtlich.
Wohl nicht direkt ActionListener, da dies ein existierendes Interface ist, das für GUI Kompontenten genutzt wird.
Aber Prinzipiell ist die Nutzung eines Listeners/Observers möglich aber nicht notwendig, wenn der Tisch ohnehin die Stühle kennt, kann auch direkt in der Klasse Stuhl eine Methode angeboten werden, mit der sich der Tisch am Stuhl bekannt macht.
Hallöle,
@cmrudolph
Vielen Dank für die Erklärung. 
[QUOTE=_Michael;107089]Wohl nicht direkt ActionListener, da dies ein existierendes Interface ist, das für GUI Kompontenten genutzt wird.
Aber Prinzipiell ist die Nutzung eines Listeners/Observers möglich aber nicht notwendig, wenn der Tisch ohnehin die Stühle kennt, kann auch direkt in der Klasse Stuhl eine Methode angeboten werden, mit der sich der Tisch am Stuhl bekannt macht.[/QUOTE]
Okay okay. Ich arbeite leider ein wenig Anti-GUI, ich bin eher der theoretische Mensch, der alles mit println versucht zu regeln, ohne groß was graphisch zu erzeugen.
Wenn ich irgendwann mit dem Zeuchs fertig bin und das Spiel läuft, werde ich mich mal nach einer seriösen Spielebibliothek umsehen und mal schauen, was sich machen lässt mit ner graphischen Oberfläche.
Habe gerade auch nicht viel Zeit dafür. Nachdem ich gestern noch meine Methode Arbeit.putzen(schuhe); aufrufen musste, ist das Wochenende nun auch erst einmal arbeitsam.
Ich schaue mich nächste Woche einmal um, wie ich, nachdem nun die Stühle und Tische generiert habe das ganze zusammenbauen und Relationen dazwischen herstellen kann.
Bzw. wie ich sowas wie addStuhl da jetzt aufrufe.
Ich wünsche allen einen Fabulösen Nikolaus und ein fesches Wochenende.
Gruß
Lukas
PS: Ich habe meinen aktuellen Entwicklungsstand, ich nenne ihn gemäß meiner Durchnummerierung einfach 1.6.3 auf GitHub hochgeladen, falls sich jemand den aktuellen Stand ansehen möchte.
Hallöle Leute,
ich habe mal weiter daran gearbeitet.
Meine Methide spielfeldgenerieren sah bis dato so aus:
for(int n=0;n<12;n++) {
tische.add(new Tisch(laenderkarten.get(n)));
}
for(int n=0;n<24;n++) {
stuehle.add(new Stuhl(null));
}
System.out.println(stuehle);
System.out.println(tische);
}```
Nun möchte ich den Tischen Stühle hinzufügen.
Beispielsweise füge ich Tisch 0 die Stühle 1, 2, 3 und 4 hinzu.
```tische.get(0).addStuhl(new Stuhl(null));```
Ich gette mir den ersten Tisch aus der Liste und führe addStuhl mit einem neuen Stuhl hinzu. Als Attribut steht jetzt einfach mal 0 drin, der Stuhl ist doch auch leer. (Oder sollte ich das anders machen)
Das müsste ich jetzt für alle Tische machen, ein mathematisches Modell, wie man das kürzestmöglich generiert ist mir nicht bekannt, was kürzer ist als 12 Einfügezeilen für jeden Tisch.
Nun würde ich aber gerne einmal von euch wissen, wie ich das automatatisch auch andersherum zuweise.
Habe im letzten Beitrag mein Projekt auf GitHub gepostet.
Aber nochmal, so sieht meine Stuhlklasse aus:
```package spiel;
public class Stuhl {
private Gastkarte gast;
public Tisch tisch;
public Stuhl(Gastkarte gast) {
this.gast = gast;
}
public void addToTisch(Tisch tisch){
this.tisch = tisch;
}
public String toString(){
return gast + "";
}
public void addGast(Gastkarte gast){
if(this.gast == null){
this.gast = gast;
} else {
System.err.println("Der Stuhl ist bereits belegt!");
}
}
}```
Mit `addGast` füge ich später den Gast hinzu. Mich interessiert nun `addToTisch`.
Ich würde das jetzt so machen:
```stuehle.get(3).addToTisch(tische.get(5));```
Einfaches Beispiel, ich nehme mir Stuhl drei und füge ihn an Tisch 5 an. Ist das so korrekt, wie ich das gemacht habe?
Und hat jemand einen Ansatz, wie ich dem Programm letzteres nicht auch automatisch bei addStuhl mitteilen könnte?
Schöne Grüße
Lukas