Modellierung einer Bar < Java < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) überfällig  | | Datum: | 12:03 Mi 07.12.2011 | | Autor: | dennis2 |
| Aufgabe | Es geht darum, eine Bar zu modellieren bzw. das "Nachtleben" in einer Bar.
Das umfasst z.B. das Bestellen von Getränken, das Rauswerfen mancher Gäste und und und.
Als erstes soll eine Klasse "Bereich" geschrieben werden: Jede Bar besteht aus den Bereichen Bühne, Theke und Tür.
Die Klasse "Bereich" soll solch einen Bereich darstellen. Dabei zeichnet sich ein Bereich durch Folgendes aus:
Es ist eine bestimmte Anzahl an Sitzplätzen vorhanden.
Ein Bereich hat einen Namen.
Ein Bereich hat eine Liste mit Gästen, wobei die Größe der Liste die Anzahl an Sitzplätzen nicht überschreiten darf.
[Die Aufgabe geht dann natürlich noch weiter, aber mir geht es nur erstmal darum, diese Klasse beispielhaft für die anderen zu verstehen.]
Achso: Bereitgestellt ist uns ein Klassendiagramm. Zur Klasse "Bereich" sieht man dort Folgendes:
Bereich
+name: String
+size: int
+guests: List<Guest>
[Wobei "Guest" auch eine Klasse ist, die ich hier aber erstmal weglasse.] |
Hallo, ich bin mal wieder mit Programmieren beschäftigt...
Meine bisherige Idee zur Klasse "Bereich" ist:
| 1: |
| | 2: | import java.util.ArrayList
| | 3: |
| | 4: | public class Bereich {
| | 5: |
| | 6: | String name;
| | 7: | int size;
| | 8: | List<Guest> guests;
| | 9: |
| | 10: | public Bereich(String name, int size){
| | 11: |
| | 12: | this.size=size;
| | 13: | this.name=name;
| | 14: | guests = new ArrayList<Guest>;
| | 15: | }
|
Das ist noch ziemlich dürftig, würde ich meinen.
Der Konstruktor ist wohl noch ausbaufähig..
Und Methoden fehlen irgendwie noch...
Insbesondere ist mir nicht klar, wieso für die Liste der Typ List<Guest> verwendet wurde. Das bezieht sich doch auf das Interface java.util.List?
Muss ich auch noch
| 1: |
| | 2: | import java.util.List |
vor die Klasse schreiben oder ist das mit
import java.util.ArrayList
überflüssig, da ArrayList ja das Interface List implementiert?
Wie ist das mit der Größe der Liste: Wie erreiche ich denn, daß die Größe der Liste nicht größer sein kann als die Anzahl der Sitze?
Könnt ihr mir bitte weiterhelfen?
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 13:28 Mi 07.12.2011 | | Autor: | dennis2 |
Vielleicht ist es doch besser, wenn ich die komplette Aufgabe poste.
Ich glaube zum Beispiel, dass ich die Länge der Gästeliste in einem Bereich erst bei "Bar" beachten muss?
Area
Alle Kneipen sind gleich aufgebaut. Es gibt eine Buhne, eine Theke und eine Tur.
Natürlich sind einige Plätze begehrter als andere. Gäste bevorzugen die Bühne, mit der Theke
geben sie sich auch noch zufrieden. Am unbeliebtesten ist der Bereich um die Tür.
Schreibt eine Klasse Area, die solch einen Bereich darstellt. Jeder Bereich zeichnet sich dadurch
aus, dass eine bestimmte Anzahl an Sitzplätzen vorhanden ist. Außerdem hat eine Area
einen Namen (also Bühne etc.) und eine Liste mit Gästen. Natürlich darf die Größe der Liste
nicht die Anzahl der Sitzplätze überschreiten.
Bar
Entwickelt weiterhin eine Klasse Bar, die jeweils die drei oben genannten Bereiche beinhaltet.
Beim Erstellen eines Objektes der Klasse Bar (also im Konstruktor) wird ubergeben,
welchem Bereich wie viele Sitzplatze zugesichert werden. Diese Anzahl kann sich nach dem Konstruktoraufruf
nicht mehr verandern (Begrundet hier eure Vorgehensweise). Zusatzlich ist die
Anzahl der Personen einer Kneipe beschrankt. Es kann nur so viele Gaste geben, wie es auch
Sitzplatze gibt. Die maximale Anzahl der Kellner entspricht der Anzahl der Sitzplatze durch
funf, mindestens jedoch 3. Live-Bands mit mehr als funf Musikern passen nicht auf die Buhne.
Um eine gute Trennung zu ermoglichen, enthalt jede Bar zwei Listen. Zum Einen eine fur die
Kellner, zum Anderen eine fur die Musiker.
Person
Jeder der eine Kneipe besucht (ob nun als Gast, Kellner oder Musiker) ist eine Person.
Alle Personen haben einen Namen (welcher im Konstruktor ubergeben wird) und konnen eine
Kneipe betreten und wieder verlassen (Methode enter(Bar bar) und leave()). Jede Person weiß,
in welcher Kneipe sie sich befindet, hat also ein Attribut von Typ Bar. Ist eine Person in keiner
Kneipe, so ist dieses Attribut = null. Weiterhin spezi fiziert eine abstrakte Methode doSomething().
Diese wird von der konkreten Person (also dem Gast, dem Kellner etc.) implementiert
und stellt eine Aktion innerhalb der Kneipe dar.
Immer wenn etwas passiert (ein Gast bestellt z.B. ein Getrank), soll eine Ausgabe auf der Konsole
erscheinen mit Namen der Person und der gerade ausgeubten Tatigkeit.
Ziel ist es, am Ende anhand der Ausgaben nachvollziehen zu konnen, was in der Kneipe so
passiert.
Guest
Ein Gast ist eine Person. Wenn er die Kneipe betritt, versucht er zunachst einen Platz
bei der Buhne zu bekommen. Sind dort schon alle Sitzplatze belegt, so versucht er es weiter bei
der Theke. Ist dort ebenfalls alles besetzt, so versucht er es bei der Tur. Ist gar kein Platz mehr
frei, so muss der Gast leider drauen bleiben. Wurde ein freier Platz gefunden, so tragt sich der
Gast in die Liste des jeweilig gewahlten Bereichs ein. Ein Gast kann, sofern er in einer Kneipe ist,
sich entschlieen diese wieder zu verlassen (wird in der Methode doSomething() ausgefuhrt). Die
Auswahl, ob er dies tut oder nicht, ndet zufallig statt. Zufallswerte lassen sich mit der Methode
random der Klasse Math erzeugen (also Math.random()). Verlasst ein Gast eine Kneipe, so muss
er aus der jeweiligen Liste entfernt werden
Musician
Ein Musiker ist eine Person. Er besitzt immer ein Instrument, welches im Konstruktor
ubergeben wird. Beim Aufruf der Methode doSomething() gibt er an, welches Instrument er
gerade spielt. Beim Betreten der Kneipe wird der Musiker in die Liste fur die Musiker eingetragen.
Main
Die Klasse Main erzeugt eine Kneipe und fullt diese mit Personen. Die Klasse Main
erzeugt eine Kneipe und fullt diese mit Personen. Damit etwas in der Kneipe passieren kann,
gibt es eine Schleife die fur jede Person doSomething() aufruft. Zur Umsetzung dieser Schleife
sollten alle Referenzen der erzeugten Personen in dieser Klasse gespeichert sein.
In der bereits vorgegebenen Klasse Main be ndet sich eine statische Methode waitFor(long millis).
Diese Methode sorgt dafur, dass das Programm eine bestimmte Zeit wartet, bevor es weiter
arbeitet (Angaben in Millisekunden). Verwendet diese Methode, um die Konsolenausgaben etwas
zu verzogern.
Drink
Ein Getrank hat einen Namen, Kosten und einen Alkoholgehalt. Entwickelt hierfur eine
Klasse Drink.
Menu
Die Karte unserer Kneipe enthalt nur Getranke. Gebt einige Getranke vor und bietet
sie als statische Attribute der Klasse Menu an.
Waiter
Ein Kellner ist eine Person. Wie bereits erwahnt, kann ein Kellner eine Bestellung
entgegen nehmen und diese bearbeiten (vgl. Punkt Bestellung). Die Methode doSomething hat
keinen E ekt bei einem Kellner. Kellner tragen sich beim Betreten der Bar in die entsprechende
Liste fur Kellner ein.
Bestellungen
Damit nun Gaste auch Getranke bestellen konnen, erweitert die Klasse Bar um
eine Methode order(Drink drink, Guest guest). Wird diese Methode durch einen Gast aufgerufen,
(dies soll ebenfalls zufallig in doSomething() passieren, bei dem Getrank handelt es sich um ein
Getrank aus der Klasse Menu) wird ein zufalliger Kellner ausgesucht und diese Bestellung an
ihn weitergeleitet (serve(Drink drink, Guest guest)). Damit der Kellner dem Gast das Getrank
auch bringen kann, erweitert die Klasse Guest um die Methode give(Drink drink). Wird diese
Methode aufgerufen, so konsumiert der Gast das Getrank. Je mehr alkoholische Getranke ein
Gast trinkt, desto hoher wird sein Alkoholpegel. Damit die Kneipe auch Gewinn machen kann,
erhalt die Klasse Bar ein weiteres Attribut cashBox. Nachdem der Kellner nun also dem Gast
sein Getrank gebracht hat, legt er das Geld fur dieses Getrank in die Kasse. Der Einfachheit
halber gehen wir davon aus, dass ein Gast unendlich viel Geld bei sich hat.
VIP
Ein VIP ist ein Gast. Der VIP ist in der Lage andere Gaste von ihren Platzen zu
"
[mm] vertreiben\,
[/mm]
sofern kein freier Platz mehr vorhanden ist. Dazu wahlt er einen zufalligen Gast aus
der Liste der jeweiligen Area und verdrangt diesen anschlieend. Um dies zu realisieren benotigt
die Klasse Gast eine Methode kick(). Gaste suchen sich anschlieend einen freien Platz auf der
nachsten Area (also z.B. bei der Theke) und setzten sich dort hin. Ist nichts mehr frei, so verlasst
der Gast die Kneipe. Handelt es sich bei dem
"
vertriebenen\ Gast wiederum um einen VIP, so
geht dieser in den nachsten Bereich und vertreibt dort ggf. einen anderen Gast. Wird ein VIP
aus dem Bereich Tur vertrieben, so verlasst er, genau wie ein normaler Gast, die Kneipe. Wie
konnte man verhindern, dass ein VIP andere VIPs vertreibt?
Roughneck
In jeder Kneipe gibt es schwarze Schafe. Einige der Gaste werden daher unangenehm,
wenn sie zu viel Alkohol getrunken haben. Jedoch reagieren die Personalkrafte stets
rechtzeitig. Wenn ein Raufbold genugend Alkohol getrunken hat, wirft er einen Stuhl um (oder
vlt. sogar durch die Gegend) und wird von einer zufalligen Personalkraft aus der Kneipe entfernt.
Dazu erweitert die Klasse Bar um die Methode throwChair(Roughneck roughneck) und die
Klasse Waiter um die Methode kickRoughneck(Roughneck roughneck). Raufbolde sind wahre
Trinker. Sie bestellen viel hau ger als normale Gaste neue Getranke.
|
|
|
| |
|
| Status: |
(Frage) überfällig | | Datum: | 14:17 Mi 07.12.2011 | | Autor: | dennis2 |
Irgendwie läuft es diesmal nicht...
Für die Klasse Bar ist im Klassendiagramm Folgendes angegeben:
Bar
+waiter: List<Waiter>
+musicians: List<Musician>
+cashBox: double
+maximumNumberOfWaiter: int
+maximumNumberOfMusicians: int
---------------------------------
+Bar(sizeOfStage: int, sizeOfCounter: int, sizeOfDoor: int): Bar
+order(drink: Drink, guest: Guest): void
+throwChair(roughneck: Roughneck): void
Ich habe bisher Folgendes zur Klasse Bar:
| 1: |
| | 2: | public class Bar{
| | 3: |
| | 4: | Area Stage;
| | 5: | Area Counter;
| | 6: | Area Door;
| | 7: | List<Waiter> waiter;
| | 8: | List<Musician> musician;
| | 9: | double cashBox;
| | 10: | int maximumNumberOfWaiter;
| | 11: | int maximumNumberOfMusicians;
| | 12: |
| | 13: | public Bar( int sizeOfStage, int sizeOfCounter, int sizeOfDoor){
| | 14: |
| | 15: | Stage=new Area(sizeOfStage, Stage);
| | 16: | Counter=new Area(sizeOfCounter, Counter);
| | 17: | Door=new Area(sizeOfDoor, Door);
| | 18: | waiter=new ArrayList<Waiter>;
| | 19: | musician=new ArrayList<Musicians>:
| | 20: | } |
Aber ich verstehe einfach nicht, wie es weitergeht und was fehlt.
Wer kann mir bitte helfen, indem er anschaut, was ich bisher zu den Klassen Area und Bar gemacht habe?
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 14:20 Fr 09.12.2011 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
| Status: |
(Frage) überfällig | | Datum: | 19:24 Mi 07.12.2011 | | Autor: | dennis2 |
Hallo, noch hat niemand reagiert, aber ich stelle Euch mal meine bisherigen Ideen zur Verfügung.
Ich bleibe guter Dinge, dass Irgendjemand helfen kann. 
Hier meine Idee zur Klasse Area:
| 1: |
| | 2: | import java.util.List;
| | 3: | import java.util.ArrayList;
| | 4: |
| | 5: | public class Area{
| | 6: |
| | 7: | int size;
| | 8: | String name;
| | 9: | List<Guest>= new ArrayList<Guest>;
| | 10: |
| | 11: |
| | 12: | // Konstruktor, den ich glaube ich, für die Klasse Bar brauche
| | 13: | public Area(int size){
| | 14: | this.size=size;
| | 15: | }
| | 16: |
| | 17: | //Methoden, die man glaube ich später für die Klasse Guest braucht
| | 18: |
| | 19: | public boolean addGuest(Guest g){
| | 20: |
| | 21: | boolean untergekommen=false;
| | 22: | if(guests.size()<size){
| | 23: | guests.add(g);
| | 24: | untergekommen=true;
| | 25: | }
| | 26: |
| | 27: | return untergekommen;
| | 28: | }
| | 29: |
| | 30: | public void deleteGuest(Guest g){
| | 31: | guests.remove(g);
| | 32: | }
| | 33: |
| | 34: | }
|
Weiter geht es dann mit meiner Idee zur Klasse Bar (knüpft an den Code oben an):
| 1: |
| | 2: | public class Bar{
| | 3: |
| | 4: | Area Stage;
| | 5: | Area Counter;
| | 6: | Area Door;
| | 7: | List<Waiter> waiter=new ArrayList<Waiter>;
| | 8: | List<Musician> musicians=new ArrayList<Musician>;
| | 9: | int maximumNumberOfWaiter;
| | 10: | int maximumNumberOfMusicians;
| | 11: | double cashBox;
| | 12: |
| | 13: | public Bar(int sizeOfStage, int sizeOfCounter, int sizeOfDoor){
| | 14: |
| | 15: | Stage= new Area(sizeOfStage);
| | 16: | Counter= new Area(sizeOfCounter);
| | 17: | Door= new Area(sizeOfDoor);
| | 18: | }
| | 19: |
| | 20: | public void addWaiter(Waiter w){
| | 21: |
| | 22: | if( (waiter.size()<3) || (3<=waiter.size()<(sizeOfStage+sizeOfCounter+sizeOfDoor)/5) )
| | 23: | {
| | 24: | waiter.add(w);
| | 25: | }
| | 26: |
| | 27: | public void deleteWaiter(Waiter w){
| | 28: | waiter.remove(w);
| | 29: | }
| | 30: |
| | 31: | public void addMusician(Musician m){
| | 32: | if(musicians.size()<5){
| | 33: | musicians.add(m);}
| | 34: |
| | 35: | public void deleteMusician(Musician m){
| | 36: | musicians.remove(m);
| | 37: | }
| | 38: |
| | 39: | } |
Weiter geht's mit meiner Idee zur Klasse Person:
| 1: |
| | 2: | public class Person{
| | 3: | String name;
| | 4: | Bar bar=0;
| | 5: |
| | 6: | public Person(String name){
| | 7: | this.name=name;
| | 8: | }
| | 9: |
| | 10: | public void enter(Bar bar){
| | 11: | this.bar=bar;
| | 12: | }
| | 13: |
| | 14: | public void leave(){
| | 15: | bar=0;
| | 16: | }
| | 17: |
| | 18: | abstract public void doSomething();
| | 19: | } |
Bishierhin bin ich mir ja wenigstens noch einigermaßen sicher, jetzt wirds heikel.
Meine Idee zur Klasse Guest:
| 1: |
| | 2: | public class Guest extends Person{
| | 3: |
| | 4: | Area area;
| | 5: |
| | 6: | public void doSomething(){
| | 7: |
| | 8: | enter(bar);
| | 9: | Stage.addGuest(name);
| | 10: | if(untergekommen==false){
| | 11: | Counter.addGuest(name)}
| | 12: | if(untergekommen==false){
| | 13: | Door.addGuest(name)}
| | 14: | if(untergekommen==false){
| | 15: | leave();}
| | 16: | }
| | 17: |
| | 18: | double a=Math.random();
| | 19: |
| | 20: | if(a<0.5){
| | 21: | leave();
| | 22: | }
| | 23: |
| | 24: | } |
Das schmerzt wahrscheinlich im Auge eines Programmierers, aber ich weiß es leider nicht besser!
Das sind meine bisherigen Ideen.
Ich hoffe sehr auf Hilfe.
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 20:20 Fr 09.12.2011 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
| Status: |
(Frage) überfällig | | Datum: | 14:57 Mi 07.12.2011 | | Autor: | dennis2 |
Muss ich bei der Klasse Array noch irgendeine Methode vielleicht hinzufügen?
Mich stört, dass ich nicht berücksichtigt habe, dass die Listenlänge nicht größer sein kann als die Anzahl der Stühle!
Aber ich stehe auf dem Schlauch.
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 15:21 Fr 09.12.2011 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 12:20 Fr 09.12.2011 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
|
