Café International Theoriensammlung

[quote=cmrudolph]Ich finde es aber nicht so schön im Konstruktor eine externe Methode aufzurufen und dann auch noch eine Referenz auf ein noch nicht vollständig konstruiertes Objekt rauszugeben.[/quote]Das geht mir auch so.
Darum würde ich die Frage stellen, ob der Tisch seine Stühle wirklich kennen muss…
Vielleicht würde es ja auch ein GastPlatz tun?```interface GastPlatz {
boolean istBesetztVonFrau();
boolean istBesetztVonMann();
void tischIstVoll();
}
class Gast {
public static final Gast UNBESETZT = new Gast(null,null);
// …
}

class Stuhl{
private gast = Gast.UNBESETZT;
public Stuhl(Tisch … tische){
for(Tisch tisch : tische)
tisch.add(new GastPlatz (){
public boolean istBesetztVonFrau(){ return Geschlecht.WEIBLICH.equals(gast.getGeschlecht);}
public boolean istBesetztVonMann(){ return Geschlecht.MAENNLICH.equals(gast.getGeschlecht);}
});
public void tischIstVoll(){ gast = Gast.UNBESETZT;}
}
}```

bye
TT

Ich denke schon. Zumindest müssen sich die Stühle irgendwie am Tisch registrieren, damit dieser sie benachrichtigen kann, wenn abgeräumt wird.

Ich habe meinen letzten Beitrag gerade noch einmal editiert. Mit der Hilfsmethode sieht die Variante gar nicht so schlecht aus, finde ich.

vor allem dann wenn aus

[quote=cmrudolph]if (istEcktisch) { stuehle.add(neuerStuhl(tisch)); stuehle.add(neuerStuhl(tisch, naechsterTisch, letzterTisch)); } else { stuehle.add(neuerStuhl(tisch, letzterTisch)); stuehle.add(neuerStuhl(tisch, naechsterTisch)); }[/quote]
noch

            neuerStuhl(tisch);
            neuerStuhl(tisch, naechsterTisch, letzterTisch);
        } else {
            neuerStuhl(tisch, letzterTisch);
            neuerStuhl(tisch, naechsterTisch);
        }```
wird, und das Hinzufügen zum sicherlichen Attribut der Liste in der Hilfsmethode passiert

(wie immer alles wohlbemerkt unter der Beobachtung der komischen Situation, dass so viele über über so ein simples Programm reden ;) )

Ja, das ginge natürlich auch noch. Das habe ich in diesem Fall auch nur deshalb nicht gemacht, weil die Methode neuerStuhl so komplett zustandslos (und vor allem seiteneffektfrei) ist und damit quasi zur Factorymethode wird.

Ich finde das Problem auch interessant. Außerdem sieht man doch sehr schön, dass man an so einem recht einfachen Beispiel sehr viel erkennen kann.

Wundert mich, dass der Vorschlag nicht schon gekommen ist (oder habe ich ihn überlesen?): Warum machst du nicht einfach eine Karte des Spielfelds (auch wenn es in diesem Spiel nur eine zu geben scheint). Am besten mit einer Zeile “Rand” drum (wodurch man ohne Aufwand ArrayOutOfBoundsExceptions bei der Abfrage vermeiden kann):

String[] mapString = {
"           ",
"     +     ",
"    +#+    ",
"   +#+#+   ",
"  +#+ +#+  ",
" +#+   +#+ ",
"  +#+ +#+  ",
"   +#+#+   ",
"    +#+    ",
"     +     ",
"           "
};

Davon ausgehend kann man ein Array aus Tischen und Stühlen (und null-Werten) erzeugen. Dafür müssen sie allerdings eine gemeinsame Oberklasse haben (die dann gleich die Position im Spielfeld enthalten kann). Welcher Stuhl zu welchem Tisch gehört kann dann ganz einfach über eine Abfrage der vier Nachbarfelder beantwortet werden (statt die Objekte wechselseitig verlinken zu müssen).

[quote=Landei]Warum machst du nicht einfach eine Map[/quote]Ich hatte mich schon gewundert, dass noch keiner mit 'nem prozeduralen Ansatz um die Ecke kam…:twisted:

bye
TT

Was ist daran “prozedural”? Die chars in den Strings sollen doch in Tische und Stühle “übersetzt” werden, alles andere wäre ziemlich häßlich. Ich würde darüber hinaus auch vorschlagen, das Spielfeld-Array in eine Spielfeld-Klasse zu kapseln. Trotzdem finde ich es immer gut, erst einmal von einer anschaulichen Darstellung auszugehen.

das muss gar nicht unbedingt sein, bzw. dürfte kaum helfen, die Klassen könnten unverändert bleiben,

  • erste Runde Array durchlaufen, die 36 Objekte erzeugen und mit String-Key Position x+y in einer Map ablegen,
  • zweite Runde die Map durchlaufen, x und y zurückrechnen, rechts und unten nachschauen, bei Fund mit neu gebauten Map-Key in der Map wechselseitig verknüpfen
    (oder auch nach links und oben schauen und einseitig verknüpfen, aber unnötig aufwendiger)

Ergebnis sind die Objekte mit internen Listen von Nachbarn wie bisher, Position nicht weiter spannend

gute Alternative zur Initialisierung, beliebige Anordnungen realisierbar, da muss man immer versuchen dran zu denken

[quote=Landei]Was ist daran “prozedural”?[/quote]Dass Du anfangen wirst die Zusammengehörigkeit von Stühlen und Tischen über deren Indexe in dem 2D Array zu ermitteln?

bye
TT

eine nD-Matrix wird man auch in höchsten OO-Zeiten noch als nD-Array darstellen oder zumindest in einem Objekt mit get(x,y,…) verstecken, einfach weil sinnvoll in der Gesamtheit,

wobei bei manchen Verwendungen wie Matrix-Multiplikation ein durchgestylter OO-Ansatz mit Iterator-verknüften Einträgen einer Zeile/ Spalte
statt Schleife über Array mit Aufpassen zu Koordinaten noch eine Überlegung wert wäre

eine platte Darstellung wie auch

 String Norwegian = "< a, A < b, B < c, C < d, D < e, E < f, F < g, G < h, H < i, I" +
                    "< j, J < k, K < l, L < m, M < n, N < o, O < p, P < q, Q < r, R" +
                    "< s, S < t, T < u, U < v, V < w, W < x, X < y, Y < z, Z" +
                    "< \u00E6, \u00C6" +     // Latin letter ae & AE
                    "< \u00F8, \u00D8" +     // Latin letter o & O with stroke
                    "< \u00E5 = a\u030A," +  // Latin letter a with ring above
                    "  \u00C5 = A\u030A;" +  // Latin letter A with ring above
                    "  aa, AA";
 RuleBasedCollator myNorwegian = new RuleBasedCollator(Norwegian);

ist wenn möglich meist elegant

[quote=SlaterB]eine nD-Matrix wird man auch in höchsten OO-Zeiten noch als nD-Array darstellen[/quote]Selbstverständlich!
Da wo es das Problem nahe legt (Matrizen, Kodierungen) ist ja auch nichts gegen Arrays und Index-Rechnerei einzuwenden, aber das aktuelle Beispiel wird IMHO duch den Matrix-Ansatz nicht leichter verständlich oder einfacher implementierbar.

bye
TPD

[QUOTE=SlaterB]das muss gar nicht unbedingt sein, bzw. dürfte kaum helfen, die Klassen könnten unverändert bleiben,

  • erste Runde Array durchlaufen, die 36 Objekte erzeugen und mit String-Key Position x+y in einer Map ablegen,
  • zweite Runde die Map durchlaufen, x und y zurückrechnen, rechts und unten nachschauen, bei Fund mit neu gebauten Map-Key in der Map wechselseitig verknüpfen
    (oder auch nach links und oben schauen und einseitig verknüpfen, aber unnötig aufwendiger)

Ergebnis sind die Objekte mit internen Listen von Nachbarn wie bisher, Position nicht weiter spannend

gute Alternative zur Initialisierung, beliebige Anordnungen realisierbar, da muss man immer versuchen dran zu denken[/QUOTE]

Hmmm, Maps gefallen mir, wie wäre eine separate Stuhl- und eine Tisch-Map (natürlich jeweils mit Position als Key)? Ob man dann die Objekte verknüppert oder immer über die Maps zur “Nachbarschaftssuche” geht, ist schon fast Geschmackssache.

was immer man später in diesem ominösen Programm macht, man braucht doch Tisch.getListeStuehle() zum Durchlauf und Zählen oder ähnliches

weder will man an dieser Stelle an Koordinaten denken, noch lohnt es sich, in dieser Methode versteckt jedesmal die Suche durchzuführen hin zu einer Liste,
einmal am Anfang alles zuordnen, dann fertig, Listen von Nachbarn abgelegt

und für dieses Zuordnen/ Aufbau mit der Array-Darstellung eine wertvolle Alternative

Hallöle Leute,

vielen dank für eure Antworten. Man kommt ja hier gar nicht mehr hinterher mit Antworten, so viele wie hier mitdiskutieren und Ideen einbringen! Das freut mich und ich danke allen, die bisher ihre Zeit dafür geopfert haben.

An dieser Stelle entschuldige ich mich kurz für ein paar Fauxpas in meinem Post gestern um 10:40.
Ich saß im Informatikunterricht, wir arbeiten an so einem ominösen Microsoftunfugsprogramm „Access“. Totaler Unfug. Ich war mit meiner Aufgabe fertig und hab den Rest der Zeit an meinem Projekt weitergearbeitet. Entschuldigt deshalb, der Post ist deshalb ein wenig flüchtig entstanden und aufgrund der schlechten Schultastaturen auch ein wenig orthografiefehlerbelastet.

====
So, ich gehe mal der Reihe nach. Ich schreibe immer Benutzername und die Nummer des Postes hin, damit man leichter sieht, worauf ich mich beziehe.

@timbeau (#60):

Hast du dir mal auf Papier aufgezeichnet, welche Tische welche Stühle nachher haben sollen?

Ich bin mir bewusst, was wozu gehört, ja. Nur nummerntechnich hab ich mir noch absolut keine Gedanken gemacht. Ich dachte immer, es gebe ein logisches mathematisches Modell, wie man das schnellstmöglich positioniert, aber naja, aufgrund der konfusen Form hab ich das aufgegeben. Ich habe einmal mit Numbers (Das bessere Excel) ganz primitiv den Aufbau zusammengeschustert und das Bild hochgeladen.

Einfach primitiv die 12 Orangenen sind die Tische und die 24 Roten sind die Stühle. Nach diesem Bild gibt es wenigstens eine Gemeinsamkeit. Jeder Tisch (1-12) hat einen Stuhl mit der gleichen Nummer (1-12) über sich. Den Rest muss man eben manuell zusammenflicken.

Ich würde übrigens nicht jedem Tisch einen neuen Stuhl hinzufügen. Wie willst du dann Stühle mehrfach hinzufügen?

Dem bin ich mir auch bewusst. Das hatte ich versehentlich in dem flüchtigen Beitrag gestern nicht richtig notiert. Ich möchte nicht jedes mal einen neuen Stuhl hinzufügen, sondern jedes mal eine neue Beziehung zu einem vorhandenen Stuhl hinzufügen, ja. :slight_smile:

Demzufolge muss ich mit new Stuhl neue Stühle generell erschaffen. Ich habe ja auch, wie Du bereits bemerkt hast eine Stuhlliste. Dann muss ich die irgendwie zuordnen. Mit AddStuhl. Es hackt nur immer noch an der Ausführung, wie ich das in Verbindung setze…:frowning:

@Timothy_Truckle (#61):

Der Parameter GastKarte im Stuhl-Konstruktor sollte verschwinden, weil Du (vermutlich) nie eine Gastkarke hast, wenn Du einen Stuhl erstellst.

Wieso muss der weg? Ich dachte daran, dass er null ist, bis sich da jemand reinsetzt? Und wenn der sich reinsetzt, muss der doch mal vorhanden sein, oder nicht?

stuehle.add(new Stuhl(tische.get(3),tische.get(4),tische.get(5)); // Stuhl an drei Tischen
So oder in der Form hatte ich das mal vorgesehen, aber irgendwie ist das Codetechnisch stillstehend und nach wie vor nicht möglich. Ich arbeite daran, irgendwie.

@Timothy_Truckle (#67):

Darum würde ich die Frage stellen, ob der Tisch seine Stühle wirklich kennen muss…

Ja, sollte er. Er muss wissen, welche Stühle er hat, damit er auch weiß, wann er voll ist. Und er muss ja auch mal überprüfen können, welche Geschlechter gerade dran sitzen, was er schlecht kann, wenn er nicht weiß, dass die Dame am Stuhl 5 überhaupt zu ihm gehört. :wink:

@Alle_die_das_Wort_Map_erwähnt_haben (#71+):
Sorry, ich dachte bisher, das geht so, wie ich mir das vorgestellt habe. Habe mich noch absolut gar nicht mit Maps beschäftigt und noch weniger Ahnung davon, als vom Rest. Ist das sowas wie die Dictionarys in Python? Mit key-value-Zuordnung?
Nichts gegen konstruktive Vorschläge, aber ich bin jedem Dankbar, der mir Vorschläge nach aktuellem Modell macht, ohne damit mein Weltbild komplett umzustricken.:wink:

@Alle:
Ich muss gestehen, mich verwirrt das ganze inzwischen ganz schön. Es freut mich, dass so viele sich dem Problem annehmen und sich damit beschäftigen, aber wenn hier 5-6 Leute nach jedem meiner Beiträge 20 andere Dinge schreiben, die sich teils in den Konzepten widersprechen, dann verwirrt das ein wenig. Nichts dagegen, das kann ruhig weiter so laufen, aber ich möchte jetzt einmal einen Cut machen und nachfragen:
Kann mir irgendjemand jetzt einmal anhand meines aktuellen Codes, wie er gegenwertig existiert (siehe GitHubLink des aktuellen Zustands: Java-CafeInternational-DOS/spiel at master · Dabendorf/Java-CafeInternational-DOS · GitHub ) sagen, wie ich 5 Tische und 8 Stühle erzeuge?

//Tisch 2: Stühle 2 und 3
//Tisch 3: Stühle 4 und 5
//Tisch 4: Stühle 6, 7 und 8
//Tisch 5: Stühle 1, 3 und 6```

Ich möchte einfach mal an diesem kleinen Beispiel sehen, wie das gemacht wird, nichts großes, einfach mal gucken und verstehen. ;)

PS: Die Methode wo das Spielfeld generiert wird ist in der Klasse `Spielstart` in Methode `spielfeldgenerieren()`.

Vielen Dank und schöne Grüße
Lukas :)

[quote=FranzFerdinand]Wieso muss der weg? Ich dachte daran, dass er null ist, bis sich da jemand reinsetzt?[/quote]Das **Feld **im Stuhl-Objekt referenziert null (oder eine dummy-Gast-Konstante Gast.UNBESETZT) solange er leer ist. Das heißt aber nicht, das diese initiale Belegung im Konstruktor übergeben und gesetzt werden muss/soll.

[quote=FranzFerdinand;107429]@Timothy_Truckle (#67):

Ja, sollte er. Er muss wissen, welche Stühle er hat, damit er auch weiß, wann er voll ist.[/quote]Hast Du Dir meinen Code in Post #67 angesehen? GastPlatz ist darin nicht nur lexikalisch ein Synonym für einen Stuhl. Der Tisch kann die Implementierung von GastPlatz wie einen Stuhl behandeln ohne, dass er den Stuhl tatsächlich kennt.

bye
TT

Hallöle,

der Code ist in der Flut von Informationen, die auf mich niederging wohl etwas untergegangen, sorry. Soll ich das so interpretieren:
Du möchtest den Stuhl aufteilen auf den Stuhl als Stuhl und den Platz, der der auf dem Stuhl zur Verfügung steht?
Und dieser Platz hat dann ein Land sowie die Eigenschaft Männlich/Weiblich, bzw. wenn beide Leer sind, dann ist der UNBESETZT?

Und ich soll jetzt erst einmal 24 leere Stühle und die 12 Tische einfach in meine zwei Listen generieren?

Wie siehst Du vor, dass man die einander zuordnet?
Hab das Bild, wie ich das Zahlenmäßig vorhabe ja gepostet gestern. Aber generell, nach wie vor hab ich absolut keinen Plan, wie ich die Beziehung Tisch-Stuhl da umsetzen soll…

Kann mir da irgendwer helfen?

Gruß
Lukas

also bei Posting #67 http://forum.byte-welt.net/sonstiges/hausaufgaben/13445-café-international-theoriensammlung-post107328.html#post107328
muss ich auch weitgehend kapitulieren,
ein verrücktes Interface und dreifach verrückte anonyme innere Klasse, alles völlig unnötig?
so kann man jeden Neuling den Rest über den Rand schubsen, wobei der ganze Thread zugegeben schon nahe an den Rand gebracht hat,

GastPlatz scheint einfach nur was anderes für Stuhl zu sein, gleiche Funktion, mit komplexen Zugriff auf Attribute von Stuhl, aber eben nicht Stuhl…,
aus einem Stuhl werden bis zu 4 GastPlatz-Objekte, ohne Unterscheidungsfunktion, alle reagieren exakt nach Zustand von Stuhl

im derzeitigen Stand rate ich von weiterer Berücksichtigung ab…


in Posting #66 davor ist eine Zuordnung zwischen Tisch und Stühlen, inklusive Erzeugung aller 36 Objekte

[quote=FranzFerdinand]Soll ich das so interpretieren:
Du möchtest den Stuhl aufteilen auf den Stuhl als Stuhl und den Platz, der der auf dem Stuhl zur Verfügung steht?[/quote]Nicht ganz Richtig, aber auch nicht ganz falsch…

Ich habe eine “Fassade” GastPlatz. Diese Fassade hat selbst keine eigenen Properties, sondern wertet, wenn gefragt, die Eigenschaften seines Stuhls aus.

[quote=FranzFerdinand;107509]Und dieser Platz hat dann ein Land sowie die Eigenschaft Männlich/Weiblich,[/quote]Nein. Dass sind Eigenschaften des Gastes, der auf diesem Platz sitzt.

[quote=FranzFerdinand;107509]bzw. wenn beide Leer sind, dann ist der UNBESETZT?[/quote]Nein.
Die Konstante UNBESETZT ist ein spezielles, zuzätzliches Gast-Objekt. Es ist das Einzige, dass kein Land hat und das kein Geschlecht hat. Dieses eine Gastobjekt wird immer dann auf den Stuhl gesetzt, wenn er Leer ist. Das macht der Stuhl selber, wenn der Tisch bescheid gibt, dass die Gäste verschwinden sollen.

[quote=FranzFerdinand;107509]Wie siehst Du vor, dass man die einander zuordnet?[/quote]Aus dass stand in dem Code, und nicht das Prinzip sowieso schon mehrfach…
Der Stuhl bekommt im Konstruktor seine Tische zugewiesen und registriet bei diesen seine GastPlätze (oder sich selbst , wenn man diese Abstraktion nicht will).
Der Tisch sammelt dann alle GastPlätze (oder Stühle) in einer eigenen Liste.

[quote=FranzFerdinand;107509]Aber generell, nach wie vor hab ich absolut keinen Plan, wie ich die Beziehung Tisch-Stuhl da umsetzen soll…[/quote]Die Zahle helfen einen Algorithmus für die Stuhl/Tisch-Verteilung zu finden, sollten aber darüber hinaus nicht überbewertet werden. Ein ziemlich smarter Weg wurde ja von @cmrudolph im Post #66 vorgestellt.

bye
TT

Sorry @Timothy_Truckle
Ich schätze Deine Beiträge sehr, aber ich muss auch echt sagen, das was Du da jetzt vorgeschlagen hast finde ich unnötig kompliziert und für meinen Kenntnisstand nicht groß bereichernd. Aber es war eine Idee, danke. :wink:

Ich beziehe mich nun mal auf Beitrag #66, ja:

    tische = new ArrayList<>(12);
    for (int i = 0; i < 12; i++) {
        tische.add(new Tisch());
    }
 
    stuehle = new ArrayList<>(24);
    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);
        boolean istEcktisch = i % 3 == 0;
        if (istEcktisch) {
            stuehle.add(neuerStuhl(tisch));
            stuehle.add(neuerStuhl(tisch, naechsterTisch, letzterTisch));
        } else {
            stuehle.add(neuerStuhl(tisch, letzterTisch));
            stuehle.add(neuerStuhl(tisch, naechsterTisch));
        }
    }
}
 
private Stuhl neuerStuhl(Tisch... tische) {
    Stuhl stuhl = new Stuhl(tische);
    for (Tisch tisch : tische) {
        tisch.addStuhl(stuhl);
    }
    return stuhl;
}```

Ich habe diese beiden Listen bereits vorgegeben in meinem Projekt:

  protected static List<Stuhl> stuehle = new ArrayList<Stuhl>(24);```

Meine Klasse Tisch sieht nach wie vor so aus:
```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;
	
	public Tisch(Laenderkarte land){
	      this.land = land;
	}
	
	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);
        }
    }
 
}```

Und Stuhl:
```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 generiere mit diesen beiden Schleifen neue Tische und Stühle:
```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));
		 }```

Aber hier auch mit Parametern hinten dran im Gegensatz zu der Lösung da oben. Der Tisch kennt anfangs schon mal sein Land, er gettet sich einfach die ersten 12 Länder aus der Laenderkarten-Liste. Und der Stuhl hat null, weil er einfach leer ist.

Bei Alternativideen bitte ein Codebeispiel, ich dreh hier irgendwie schon durch bei den verschiedenen hunderten Ideen, die sich alle widersprechen. ;)

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);
        boolean istEcktisch = i % 3 == 0;
        if (istEcktisch) {
            stuehle.add(neuerStuhl(tisch));
            stuehle.add(neuerStuhl(tisch, naechsterTisch, letzterTisch));
        } else {
            stuehle.add(neuerStuhl(tisch, letzterTisch));
            stuehle.add(neuerStuhl(tisch, naechsterTisch));
        }
    }```

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

Aber mein Javaquelltext gibt mir bei meinen aktuellen Quelltextzuständen nur Error über Error aus.
Bei `neuerStuhl` dreht er durch.
Dann hab ich Deine Methode neuerStuhl mal importiert.

Aber:
```private Stuhl neuerStuhl(Tisch... tische) {
    Stuhl stuhl = new Stuhl(tische);
    for (Tisch tisch : tische) {
        tisch.addStuhl(stuhl);
    }
    return stuhl;
}```

new Stuhl mit der Eigenschaft Tische? Das geht nicht mit meinem aktuellen Code. Und ich versteh das auch jetzt rein logisch nicht. Soll das jetzt die Eigenschaft sein, welche Tische dem Stuhl zugeordnet sind? Also mein Eclipse meckert in erster Linie, dass das so nicht vorgesehen ist, den Tisch-Parameter für den Stuhl.

Danke und
Gruß
Lukas :)

du hattest doch schon einen Konstruktor Stuhl(Gastkarte gast),
also ist dier das Konzept, ein Objekt zu übergeben irgendwie geläufig, wenn auch das nicht irgendwoher kopiert,

da du bisher nur 24 Stühle mit Gastkarte null erzeugst und keine weiteren Stühle hinzukommen ist Gastkarte im Konstruktor eh unnütz, stattdessen Tisch im Konstruktor (bzw. Liste von Tischen),
oder auch nicht und direkt danach eben addToTisch(Tisch)-Methode aufrufen,

wobei die nur für einen Tisch funktioniert, das bringt natürlich nicht viel,
entweder eine ganze Liste merken, oder gut möglich, auch gar nichts im Stuhl merken,

könnte auch reichen im Programm immer nur von Tischen auszugehen,
etwa: einen Gast auf Stuhl x → danach für alle Tische prüfen ob Tisch jeweils ok