Café International Theoriensammlung

[QUOTE=FranzFerdinand]Und Stuhl:


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!");
        }
    }
 
}```[/QUOTE]
Ich hatte ja im Post [#52](http://forum.byte-welt.net/sonstiges/hausaufgaben/13445-caf%C3%A9-international-theoriensammlung-3.html#post107037) schon mal darauf hingewiesen, dass wenn ein Stuhl  "seine" Tische kennen soll, die Klasse eine Liste für Tische ( wie die Klasse Tisch eine Liste für Stühle ) benötigt. Eine Instanzvariable `private Tisch tisch` nutzt hier gar nichts.
[QUOTE=FranzFerdinand;107515]
Was den Rest von cmrudolphs Idee angeht:
```for (int i = 0; i < 12; i++) {
        Tisch tisch = tische.get(i);
        Tisch naechsterTisch = tische.get((i + 1) % 12);
        Tisch letzterTisch = tische.get((i + 11) % 12);
        ...
    }```

Ich verstehe Deine Idee mit den Ecktischen und sowas, gefällt mir sehr gut! :) 

Aber mein Javaquelltext ...[/QUOTE]
Die Idee ist ganz nett, übersteigt aber aktuell scheinbar Dein Verständnis. Ich an Deiner Stelle würde darauf verzichten und jeden Stuhl bewusst seinen Tischen zuordnen.
1. da diese Lösung nur für diese Art von Layout gilt ( die Brettspielvariante hat ein ganz anderes Layout)
2. Du für die spätere User Interaktion ohnehin etwas benötigst damit Du Mausklicks bzw. die Mausposition einem Stuhl zuordnen kannst 
Letzteres könnte man sicher auch noch in den Algorithmus integrieren, allerdings müsstest Du das dann blind und ohne es zu verstehen übernehmen. Könntest es im worst case Deinem Lehrer nicht erklären.

Die Idee dahinter (wurde ja schon ein paarmal vorgeschlagen) ist, dass ein Stuhl, sobald er „aufgestellt“ wird, also im Code mit new Stuhl erzeugt wird, gleich an die zugehörigen Tische gestellt wird. Das passiert im Konstruktor, weil sich die Zuordnung im Verlauf des Spiels nicht ändert. Außerdem ist es erforderlich für die Spiellogik, dass der Stuhl an einer bestimmten Anzahl Tische steht. Deshalb ist es sinnvoll, dass der ungültige Zustand, dass der Stuhl an keinem oder zu vielen Tischen steht, gar nicht erst entstehen kann, weil der Konstruktor Stuhl nur 1-3 Tische annimmt, an die der Stuhl gestellt wird.
Dem Konstruktor eine Gastkarte zu geben macht auch nicht so viel Sinn, weil es niemals vorkommt, dass „wenn der Stuhl aufgestellt wird“ bereits ein Gast auf ihm sitzt. Dasselbe gilt für die Tische, dort ist sinnvoller Weise auch noch keine Länderkarte zugewiesen, da diese sich noch auf dem „Stapel“ befinden.
Dass die Stühle schon den Tischen bei deren Erzeugung zugewiesen werden ist leider nicht gleichzeitig damit möglich, dass die Tische den Stühlen bei deren Erzeugung zugewiesen werden, weil für den Konstruktoraufruf das jeweils andere Objekt schon bestehen muss. Deshalb muss das Hilfskonstrukt tisch.addStuhl(stuhl); angewandt werden.

Hallöle,

ich habe einmal daran weitergearbeitet und das ganze mal primitiv erzeugt. Die Stühle und Tische ordnen sich nun zu. Beides einzeln und nicht das eine aus dem anderen folgend, aber es ist ein Anfang.

So sieht bei mir Tisch aus:

import java.util.ArrayList;
import java.util.List;

import spiel.Laenderkarte;

public class Tisch {
	   
   private List<Stuhl> stuehle = new ArrayList<Stuhl>();
	
    public Laenderkarte land;
	
	public Tisch(){
	}

    
    public void addStuhl(Stuhl stuhl){
        if(stuehle.size() == 4){
            System.err.println("Kein Platz mehr fuer weitere Stuehle");
        } else {
            stuehle.add(stuhl);
        }
    }
 
}```

Und der Stuhl:
```package spiel;

public class Stuhl {
	   
    private Gastkarte gast;
    public Tisch tisch;
   
    public Stuhl() {
    }
    
    public void addToTisch(Tisch tisch){
        this.tisch = tisch;
    }
    
   
    public void addGast(Gastkarte gast){
        if(this.gast == null){
            this.gast = gast;
        } else {
            System.err.println("Der Stuhl ist bereits belegt!");
        }
    }
 
}```

So sieht Spielfeld generieren aus:
```public static void spielfeldgenerieren() {
		 for(int n=0;n<12;n++) {
			 tische.add(new Tisch());
		 }
		 for(int n=0;n<24;n++) {
			 stuehle.add(new Stuhl());
		 }
		 tische.get(0).addStuhl(stuehle.get(0));
		 tische.get(0).addStuhl(stuehle.get(11));
		 tische.get(0).addStuhl(stuehle.get(12));
		 tische.get(0).addStuhl(stuehle.get(13));
		 tische.get(1).addStuhl(stuehle.get(1));
		 tische.get(1).addStuhl(stuehle.get(2));
		 tische.get(1).addStuhl(stuehle.get(12));
		 tische.get(1).addStuhl(stuehle.get(13));
		 tische.get(2).addStuhl(stuehle.get(2));
		 tische.get(2).addStuhl(stuehle.get(3));
		 tische.get(2).addStuhl(stuehle.get(13));
		 tische.get(2).addStuhl(stuehle.get(14));
		 tische.get(3).addStuhl(stuehle.get(3));
		 tische.get(3).addStuhl(stuehle.get(4));
		 tische.get(3).addStuhl(stuehle.get(5));
		 tische.get(3).addStuhl(stuehle.get(14));
		 //weitere Tische 4 bis 11
		 stuehle.get(0).addToTisch(tische.get(0));
		 stuehle.get(1).addToTisch(tische.get(1));
		 //weitere Stuhlzuordnungen
	 }```

Alle Objekte werden erst alle Generieren und werden dann zugeordnet. :)

Eine kleine Sache die mich ärgert ist, dass das alles neue Codezeilen sind und ich mit den Methoden `addStuhl` & `addTisch` immer nur ein Element zuordnen kann.
Also sowas hier ist nicht möglich:
```tische.get(3).addStuhl(stuehle.get(3),stuehle.get(4),stuehle.get(5),stuehle.get(14));```
Ich kann zwar die jeweilige Methode ändern, aber leider sind das ja immer 1, 2 oder 3 Stühle, das variabel einzustellen, mal gucken, demnächst.

Meine nächsten Schritte werden die Umsetzung von `tische.get(x).addLand` und `stuehle.get(x).addGast` sein, ich poste meine Fortschritte die Tage.

Wäre nur erst mal nett, wenn jemand den aktuellen Code da oben einmal absegnen oder bemängeln könnte. Etwaige Verbesserungsvorschläge, insofern ich sie verstehe sind immer Willkommen. :)

Danke und Gruß
Lukas

Doch, das geht, und das meint T_T auch mit Vargs (denke ich)

Java Tips - Using the VarArgs Language Feature

der Fachbegriff dazu, Varargs, Beispielimplementationen wurden schon genannt,
ja, mal gucken ob gucken weiterhilft…


die Probleme bei der Einzelzuordnung sind ja schon lang genug besprochen,
anderseits auch schon so geölt dass einmal mehr nicht schadet:

         tische.get(0).addStuhl(stuehle.get(0));
         tische.get(0).addStuhl(stuehle.get(11));
[..]
         stuehle.get(0).addToTisch(tische.get(0));
         stuehle.get(1).addToTisch(tische.get(1));

diese Verdopplung der Aufzählung ist so unnötig und fehleranfällig,
selbst wenn jede der 50 Beziehungen einzeln, dann reicht doch offensichtlich jeweils

mit einer Untermethode die sowohl dem Stuhl dem Tisch hinzufügt als auch den Tisch dem Stuhl,

dass dir eine solche Methode, trotz offensichtlicher Trivialität nicht sofort gelingen sollte ist ja kein Problem,
viel wichtiger wäre die Erkenntnis/ Einstellung dazu, wieviel das sparen würde, und dann der Ehrgeiz das zu lernen,

eine solche Methode zu können, ein Problem derart simpel zu verkleinern, ist eine der wichtigsten Programmierfähigkeiten


die 50 bzw. 2x 50 Aufrufe hast du dir in der Gesamtheit gespart, ich glaube ich würde sogar widerstehen sie anzuschauen,
aber unter den vorhandenen fällt doch schon auf, dass Tische 0-3 je 4 Stühle bekommen, darunter sind drei die Stuhl 13 bekommen,
Stuhl 13 steht also zwischen 3 Tischen die je 4 Stühle haben? das dürfte es kaum geben
(edit: upps, kann ja doch sein, jeder Tisch hat 4 Stühle, zu sehr „Stuhl-Sicht“ in diesem Thread :wink: da haben nur wenige Stühle 3 Tische usw. )

den Algorithmus aus #66 zu nehmen ist eine Spur verwegener als nur eine Methode wie verknuepfe(), aber angesichts der Fehler vielleicht doch zu empfehlen,
deine einzigen Probleme schienen die gleichen Fragen wie hier zu sein, add-Methoden usw., sind die unlösbar?
sind doch einfache technische Aufgaben

wobei deine Stuhl-Klasse bisher immer noch nur einen Tisch kennt, was hat das zu bedeuten?
wenn etwa Stuhl 13 zu Tisch 0, 1, und 2 dazu kommt, welcher einzelne Tisch wird dann in Stuhl gespeichert, wieso nicht alle drei Tische oder gar keine?

[quote=FranzFerdinand]Eine kleine Sache die mich ärgert ist, dass das alles neue Codezeilen sind und ich mit den Methoden addStuhl & addTisch immer nur ein Element zuordnen kann.[/quote][quote=timbeau;107603]Doch, das geht, und das meint T_T auch mit Vargs (denke ich)[/quote]Das eigentliche Problem ist ja, dass das Property, in dem der Stuhl seinen Tisch-Beziehung speichert keine Collection ist. Und dass der TO das nicht erkennt hat rein gar nicht mit Java zu tun, denn dazu ist die korrekte Implementierung schon zu oft hier in diesem Thead vor gemacht worden.

bye
TT

die Voll-Prüfung macht etwas weniger Sinn: bei vorhandener Size 3 wird nicht gemeckert, selbst wenn 95 neue dazukommen,

überhaupt dürfte mit Liste nur einmal aufgerufen werden, vorhandene Size immer 0,
eher könntest du length des Parameter-Arrays prüfen

Ich verstehe nicht, was das generelle Problem dabei ist, außer des unnötig viel Codes. Ich habe meine 12 Tische und 24 Stühle von Anfang an und ordne die nun einzeln zu, passt doch?

falls es richtig ist, dann passt es,
du fragtest ja aber explizit nach Anmerkungen

[QUOTE=SlaterB]die Voll-Prüfung macht etwas weniger Sinn: bei vorhandener Size 3 wird nicht gemeckert, selbst wenn 95 neue dazukommen,
[/QUOTE]

Huch und ich muss auch sagen, nach einem nochmaligen Ausführen gibts auch Fehlermeldungen dazu:

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 3, Size: 0
	at java.util.ArrayList.rangeCheckForAdd(ArrayList.java:661)
	at java.util.ArrayList.addAll(ArrayList.java:601)
	at spiel.Tisch.addStuhl(Tisch.java:39)
	at spiel.Spielstart.spielfeldgenerieren(Spielstart.java:232)
	at spiel.CafeRoot.<init>(CafeRoot.java:122)
	at spiel.CafeRoot.main(CafeRoot.java:147)

Beim ersten Testen vorhin gabs diesen Error nicht, das war jedoch mein Verschulden, ich hab die Datei nicht gespeichert und dem Compiler mit altem Code ausgeführt…

In dem Fall ist diese Exception auch völlig logisch, ich verstehe, die Größe ist zu dem Zeitpunkt ja noch 0…

Herrgott, ich versteh das nicht mehr. Ich belasse es bei der alten Ordnung, die funktioniert wahrlich auch.

diese Fehlermeldung sollte absolut zu verstehen sein,
wie bei so vielen gilt: wegducken und irgendwo anders weiterarbeiten gilt nicht,

stattdessen jedes solches Vorkommnis auch immer als Chance nutzen! sowas musst du klären können, ansonsten nicht bereit fürs Programmierleben,
“ich verstehe, die Größe ist zu dem Zeitpunkt ja noch 0…” ist schon ein Punkt, noch paar andere und alles ist klar wenn nicht eh schon,
ansonsten zumindest soweit mitdenken um klare Fragen zu stellen
(“ich habe x und y und will z, wieso ist dabei Fehler a, wobei ich doch noch b, c und d bedacht habe?”)

generell brauchst du bei Anfügen ans Ende einer Liste, ob für ein oder mehrere Elemente, gar keinen Index mitgeben, das ist ja die Standard-Variante

Das ist auch immer eine gute Gelegenheit, sich mit der Arbeitsweise eines Debuggers vertraut zu machen. Dann bis kurz vor der Fehler-Stelle “durchsteppen”, sich anschauen, ob in den Variablen auch das drin ist, was drin sein sollte, und sich dann vor die Stirn patschen.

[QUOTE=SlaterB]diese Fehlermeldung sollte absolut zu verstehen sein,
wie bei so vielen gilt: wegducken und irgendwo anders weiterarbeiten gilt nicht,

stattdessen jedes solches Vorkommnis auch immer als Chance nutzen! sowas musst du klären können, ansonsten nicht bereit fürs Programmierleben,
„ich verstehe, die Größe ist zu dem Zeitpunkt ja noch 0…“ ist schon ein Punkt, noch paar andere und alles ist klar wenn nicht eh schon,
ansonsten zumindest soweit mitdenken um klare Fragen zu stellen
(„ich habe x und y und will z, wieso ist dabei Fehler a, wobei ich doch noch b, c und d bedacht habe?“)

generell brauchst du bei Anfügen ans Ende einer Liste, ob für ein oder mehrere Elemente, gar keinen Index mitgeben, das ist ja die Standard-Variante[/QUOTE]

Hallöle,

da muss ich jetzt mal selbstkritisch einfach revidieren. Ich bin ja nicht hier, um mir immer von irgendwem Code zu geben. Sieht oft so aus, aber das will ich nicht, ich möchte das ganze ja auch einen Schritt weit verstehen.

Wie ich die varargs bei den Objekten einbaue hab ich über 5 Millionen Fehlerbehebungen in Eclipse zusammengewürfelt, ohne es zu verstehen. Sowas will ich nicht. Deshalb lasse ich das so, wie es vorher war, das kann ich nachvollziehen und es funktioniert.

Ich baue so weiter, wie ich es nachvollziehen kann. :wink:

Mir fehlt im Übrigen zumeist der Denkanstoß, wie man das umsetzt, wenn ich den fertigen Code sehe, dann schleicht sich immer so ein leichtes Gefühl von „Mist, das ist ja einfach, hättest Du auch hingekriegt“ ein. :wink:

In dem Fall bietet es sich an, ein kleines, unabhängiges Programm zu schreiben, in dem du dich erstmal mit Varargs vertraut machst. Dann wirst du die Fehler in deinem komplexeren Programm leichter verstehen. So ist im Laufe der Zeit ein recht großes Projekt mit lauter Übungsklassen zu diesem und jenem Aspekt bei mir entstanden, da kann man später nämlich dann auch nochmal nachschauen und mir fällt zu selbst geschriebenem Code meinst schneller ein, wie das alles so war, als zu im Internet gefundenem.

Ich finde übrigens nicht, dass du (@FranzFerdinand) dir irgendetwas erschleichen möchtest. Insgesamt ist das doch ein Projekt bei dem man viel lernen kann. Den Denkanstoß erhält man eben auch nur durch Erfahrung und/oder viel Testen und vor allem machen. Das Gefühl, dass man fertigen Code den man sieht, ja genauso auch hätte schreiben können, hat bestimmt schon einige Klausuren verbockt.

Als Beispielprogramm zum varargs-Thema könnte z.B. sowas dienen:


public class VarargTest {

    public void run() {
        int a = 5;
        int b = 7;
        int c = 8;
        int d = 17;
        int e = 21;
        noVararg(a);
        noVararg(a, b);
        noVararg(a, b, c);
        noVararg(a, b, c, d);
        noVararg(a, b, c, d, e);
        vararg(a);
        vararg(a, b);
        vararg(a, b, c);
        vararg(a, b, c, d);
        vararg(a, b, c, d, e);
    }

    private void noVararg(int p1) {
        System.out.println("ohne vararg mit einem Parameter:"
                + "
	p1 = " + p1);
    }

    private void noVararg(int p1, int p2) {
        System.out.println("ohne vararg mit zwei Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2);
    }

    private void noVararg(int p1, int p2, int p3) {
        System.out.println("ohne vararg mit drei Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2
                + "
	p3 = " + p3);
    }

    private void noVararg(int p1, int p2, int p3, int p4) {
        System.out.println("ohne vararg mit vier Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2
                + "
	p3 = " + p3
                + "
	p4 = " + p4);
    }

    private void noVararg(int p1, int p2, int p3, int p4, int p5) {
        System.out.println("ohne vararg mit fünf Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2
                + "
	p3 = " + p3
                + "
	p4 = " + p4
                + "
	p5 = " + p5);
    }

    private void vararg(int... px) {
        System.out.println("mit vararg mit " + px.length + " Parameter" 
                + (1<px.length?"n":"") + ":");
        int index = 0;
        for (int p : px) {
            System.out.println("	p" + ++index + " = " + p);
        }
    }

    public static void main(String[] args) {
        new VarargTest().run();
    }

}

Mir so viele… :slight_smile: Nur nicht in Info, weil da macht man ja komplexe Sachen, die mir was bringen würden nicht mal…

@Crian
So mach ich das eigentlich auch. Ich bin gerade dabei mir Swift und Python zu erlesen, da macht man eben auch ganz viele kleine lustige Programme, die dann als ganzes eine ganze Menge weiterhelfen.
An Java bin ich wegen der Schule gebunden. Steinigt mich, startet den Shitstorm, aber ich persönlich hasse Java. :stuck_out_tongue: Mein aktuelles Projekt, dieses Café International woran ich arbeite ist im Übrigen zwar mein Informatikprojekt, was ich im Oktober 2015 abgeben muss. Aber so, wie es ist, möchte ich das auch nicht abgeben. Die Zeit, die ich hier im Forum verbringe, ist für mich eher Zeit der Übung. Ich baue das ganze ja mit Eingabe und Ausgabe auf der Konsole zusammen. Ohne ein gescheites Graphisches Userinterface, wie es später sein soll.

Ich möchte einfach erstmal daran üben und lernen und das Projekt in diesem Konsolenzustand fertig Spielbar machen. Wenn ich das geschafft habe, schmeiße ich alles über den Haufen und mache das ganze mit meinen Gewonnenen Kenntnissen mit GUI nochmal. :wink:

Deshalb ist es mir wichtig diesen Thread aufgemacht zu haben und auch noch weiterhin so ein paar 5, 10, 20, for(int n=0;n<∞;n++) :wink: Beiträge mit euch verschiedene Ansätze zu bequatschten. Ich würd das jetzt ungern abbrechen, sondern am Ende das Gewissen haben, dass diese Tisch-Stuhl-Zuordnung endlich klappt und ich sie verstehe. :slight_smile:

Ich mache mich weiter ran und probiere mal ein wenig umherzuschrauben, ich poste weiterhin meinen aktuellen Code, falls es weiterhin Menschen hier gibt, die mich geistig unterstützen würden. :slight_smile:

Schönes Wochenende!
Lukas

[quote=FranzFerdinand;107689]aber ich persönlich hasse Java.[/quote]Na dann gib doch mal Butter bei die Fische: Wie würdest Du dieses Problem in einer anderen Programmiersprache lösen?
Wenn Du ehrlich bist liegt dein Problem mit der Tisch/Stuhl-Zupordnung nämlich nicht an Java…

bye
TT

[QUOTE=Timothy_Truckle;107692]Na dann gib doch mal Butter bei die Fische: Wie würdest Du dieses Problem in einer anderen Programmiersprache lösen?
Wenn Du ehrlich bist liegt dein Problem mit der Tisch/Stuhl-Zupordnung nämlich nicht an Java…

bye
TT[/QUOTE]

Alles objektorientiert und viel fortschrittlicher als prozedural, ich weiß doch. :wink: Funktioniert im Prinzip alles gleich. Ich wollte es nur nebenbei bemerkt haben.

[quote=FranzFerdinand]Alles objektorientiert und viel fortschrittlicher als prozedural[/quote]Das siehst Du falsch.
Ich finde nicht, dass OO fortschrittlicher ist als prozedural. Mein Standpunkt ist nur, dass ich in einer OO-Sprache auch OO-Lösungen finden sollte. Wenn mein Problem prozedural besser lösbar ist nehme ich halt eine prozedurale Sprache: C oder Basic oder sowas…

bye
TT

[QUOTE=Crian]Als Beispielprogramm zum varargs-Thema könnte z.B. sowas dienen:


public class VarargTest {

    public void run() {
        int a = 5;
        int b = 7;
        int c = 8;
        int d = 17;
        int e = 21;
        noVararg(a);
        noVararg(a, b);
        noVararg(a, b, c);
        noVararg(a, b, c, d);
        noVararg(a, b, c, d, e);
        vararg(a);
        vararg(a, b);
        vararg(a, b, c);
        vararg(a, b, c, d);
        vararg(a, b, c, d, e);
    }

    private void noVararg(int p1) {
        System.out.println("ohne vararg mit einem Parameter:"
                + "
	p1 = " + p1);
    }

    private void noVararg(int p1, int p2) {
        System.out.println("ohne vararg mit zwei Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2);
    }

    private void noVararg(int p1, int p2, int p3) {
        System.out.println("ohne vararg mit drei Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2
                + "
	p3 = " + p3);
    }

    private void noVararg(int p1, int p2, int p3, int p4) {
        System.out.println("ohne vararg mit vier Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2
                + "
	p3 = " + p3
                + "
	p4 = " + p4);
    }

    private void noVararg(int p1, int p2, int p3, int p4, int p5) {
        System.out.println("ohne vararg mit fünf Parametern:"
                + "
	p1 = " + p1
                + "
	p2 = " + p2
                + "
	p3 = " + p3
                + "
	p4 = " + p4
                + "
	p5 = " + p5);
    }

    private void vararg(int... px) {
        System.out.println("mit vararg mit " + px.length + " Parameter" 
                + (1<px.length?"n":"") + ":");
        int index = 0;
        for (int p : px) {
            System.out.println("	p" + ++index + " = " + p);
        }
    }

    public static void main(String[] args) {
        new VarargTest().run();
    }

}
```[/QUOTE]

Danke schön, das verstehe ich nun sogar.
Aber bei den Objekten die ich hier erstellt habe, keine Ahnung, wie ich das machen soll.

Ich hab mir jetzt einfach mal das hier geschnappt:
```public void addToTisch(Tisch tisch){
        this.tisch = tisch;
    }*/```

Das ordnet dem Stuhl einen Tisch zu. Sollten aber immer vier Tische sein. Jetzt kann ich natürlich via Komma abtrennen, kein Problem, weil es ja immer vier sind. Aber ich hätte das gerne einmal an diesem Beispiel mit diesem ominösen vararg erklärt.

Bussy
Lukas :)

*** Edit ***

Kleiner Nebenerfolg mal so nebenbei.
Ich glaub ich hab varargs erst einmal so ein wenig erstanden und konnte sie benutzen.

So sieht nun meine Stuhlklasse aus:
```package spiel;

public class Stuhl {
	   
    private Gastkarte gast;
    public Tisch[] tisch;
   
    //public Stuhl(/*Gastkarte gast*/) {
    	//this.gast = gast;
    //}
    
    public Stuhl(Tisch... tische) {
    	this.tisch=tische;
    }
    
    /*public void addToTisch(Tisch tisch){
        this.tisch = tisch;
    }*/
    
    public void addToTisch(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!");
        }
    }*/
    
    public void addGast(Gastkarte gast){
        if(this.gast == null){
            this.gast = gast;
        } else {
            System.err.println("Der Stuhl ist bereits belegt!");
        }
    }
 
}```

Und so meine Tisch-Klasse:
```package spiel;
import java.util.ArrayList;
import java.util.List;

import spiel.Laenderkarte;

public class Tisch {
	   
   private List<Stuhl> stuehle = new ArrayList<Stuhl>();
	
    public Laenderkarte land;

	private Stuhl[] stuhl;
	
	//public Tisch(/*Laenderkarte land*/){
	      //this.land = land;
	//}
	
	public Tisch(Stuhl ...stuehle) {
		this.stuhl = stuehle;
	}
	
	//public String toString(){
	     //return land.toString();
	//}
    
	public void addStuhl(Stuhl stuhl){
        if(stuehle.size() == 4){
            System.err.println("Kein Platz mehr fuer weitere Stuehle");
        } else {
            stuehle.add(stuhl);
        }
    }
	
	public void addLandToTisch(Laenderkarte land) {
		
	}
 
}```

Entschuldigt die vielen Kommentare, habe ja viel verändert. Bevor alles geht, lege ich mir von vorherigen Ständen lieber immer mal ne Kopie im Kommentar ab. ;)

So und ausführen lässt sich das nun so:
```stuehle.add(new Stuhl(tische.get(11),tische.get(1),tische.get(2)));
		 tische.add(new Tisch(stuehle.get(1),stuehle.get(3),stuehle.get(1)));```

Klappt soweit. Werte sind jetzt mal dahingestellt und frei erfunden.
Aber irgendwie hab ich da noch so meine Bedenken...
Beispielsweise wie ich denn `tische.get(11)` aufrufen kann, wenn ich den Tisch noch nicht erstellt habe. Egal welche Reihenfolge, letzten Endes muss ja irgendwas am Anfang kommen und sich auf etwas von `Anfang - 1` beziehen.
So eine ganze Kombinationsklasse, die beides Gleichzeitig macht, hm, mal schauen, ob ich das auch noch irgendwie zusammenkriege.

Schöne GRüße
Lukas

Jetzt fängst du wieder an in den “add”-Methoden neue Objekte zu generieren.

Vielleicht wäre es hilfreich eine Map <String,Stuhl> zu erstellen die du erstmal füllst
ID1 = new stuhl
ID2 = new stuhl
usw

Das gleiche mit Tischen. Dann holst du dir passend zur ID das benötigte Objekt.

Stuhl id2 = StuhlMap.get(“ID2”)