hallo,
ich studiere maschinenbau im 2. semester und wir müssen in informatik einen
beleg anfertigen der es in sich hat. die aufgabeist hier!

ich hab speziel die teilaufgabe 2 (lagerverwaltung). ich weiß echt nicht wie man da ran gehen
soll. wieviel klassen muss man erstellen und wie muss das ganze in äbhängigkeit gebracht
werden?



wäre cool wenn mir jemand auf die sprünge helfen könnte, einen schönen abend noch!

hallo, danke für die schnelle anwort. ich hab mir mal ein paar gedanken gemacht was die folgenden klassen für aufgaben übernehmen sollen:

Lager(abstact):

Atribute Operationen
ID Einlagern(Lagerelement Teil, int anzahl)
Lägerplätze Auslagern(Lagerelement Teil, int anzahl)
Kapazität

jetzt kommt die frage auf was man denn für eine datenstruktur verwenden kann
um das lager zu realisieren? es soll ja eine art matrix aus lagerplatz mal
kapazität ergeben?


Festlager/Chaoslager extends Lager

hier dann die vordefinierten operationen von lager genau festlegen
wie das lager (datentyp?) zu belagern ist.

weiterhin kontruktormethode

Lagerelement

wie auf der letzten seite beschrieben. dieses wird dann beim hinzufügen und
entnehmen aus den lagern jeweils an die entsprechenden operationen übergeben

allerdings können doch jetzt die methoden hinzufügen elemente/entnehmen elemente weggelassen werden, da das doch jetzt direkt über das lager gemacht wird oder?


LAgerverwaltung
verbindet das lagerelement mit dem lager letztendlich und überwacht alle vorgänge
darüber zerbrech ich mir später den kopf, wenn das andere so halbwegs klar ist.


ist das so in etwa schonmal richtig oder sollte es aufgrund von methodischen gegebenheiten anders gemacht werden? bin für jede hilfe dankbar. wir sind
zwar schon zu 5. aber meine kommilitonen haben noch weniger ahnung als
ich und der beleg scheint schon nich ganz ohne zu sein.

hallo, erstmal danke für die unterstützung.
so ganz nachvollziehen kann ich das jetzt auf der stelle auf anhieb nicht
aber ich werd mich diese woche mal mit meinen komilitonen hinsetzen und
die problembeschreibung analysieren und ein klassendiagramm aufstellen
damit wir sehen was wir brauchen und wie die ganzen klassen in beziehung zueinander stehen, dann versuche ich es mittels uml grafisch darzustellen und man kann schonmal besser drüber diskutieren.

wegen dem lagerelement, in der aufgabenstellung steht das man eine klasse namens
lagerelement nehmen soll auf der letzten seite:


vorgegebene minimale schnittstellen von Klassen:

Klasse Lagerelement

Attribute:
NAme
Indifikator
Meldebestand...


Methoden:
create: Name, Identifikator,....
Hinzufügen Elemente: Anzahl
Entnehmen Elemente: Anzahl
Prüfen Entnahme


also scheint das doch so gewollt zu sein obwohl es ja eigentlich nich sein muss das man so ne extra klasse braucht

naja ich melde mich gegen ende der woche wieder und danke nochmal für die hilfe

hallo,
ich versuche erstmal so weiter zu kommen und bin noch bei der analyse.
ich will die ganze verwaltung über die lagerverwaltung ablaufen lassen
und dazu die erzeugten objekte in eine art arry packen um dann damit mit ihnen
hantieren zu können, mal als beispiel:





das is so gedacht das ich über die klasse lagerverwaltung ein element erzeuge und das sich das attribut anzahl bei jeder erzeugung erhöht.
beim zuweisen der objekte in der verwaltung soll also ein array vom typ lagerelement erzeugt werden auf dessen "positionen" jeweils immer ein element zugeordnet ist.
den wert der position der neuen objekte beschreibt gleichzeitig das attribut anzahl
so das bei jeder erzeugung das neue objekt auf einen "platz" im array hinter dem vorher erzeugten objekt zugegriffen werden kann. allerdings meckert java da noch rum? kann man das denn überhaupt so machen wie ich mir das hier so zusammengebastelt hab?

bzw wie bekom ich das hin das ich die position in abhängigkeit von dem wert
des attributs machen kann. wenn ich selber eine zahl einfüge gehts aber da wäre ja immer der selbe platz belegt und es würde sich alles überschreiben?


danke für eure hilfe

hi,
erstmal danke schön, hab gemerkt das das irgendwie doppelt gemoppelt
ist nachdem du mich drauf aufmerksam gemacht hast und mir is auch aufgefallen das man doch eigentlich gar keine rückgabe hat da das ganze ja eh in der verwaltung bleibt? ich hab das jetzt so geschrieben das man mit zwei methoden 2 verschiedene "positionen" von L belegen kann und man mit der dritten methode abhängig vom wert des attributs dann die entsprechende information vom entsprechenden ort abrufen kann, allerdings will das einfach nich so richtig funktionieren..... :oops:

ich hab das jetzt genau so eingegeben und will das testen (mit BlueJ) und der gibt
mir immer den fehler NullPointerExeption, null?
liegt das am blueJ oder stimmt immer noch etwas nicht?

hallo,
danke so hat es funktioniert. um nochmal auf die aufgabe zurückzukommen.
du hattest ja gemeint ich soll erstmal grob ne klassenstruktur erarbeiten.
das hab ich gemacht und es sieht so aus:

[Blockierte Grafik: http://www.mbz-leipzig.de/hummel/info/Klassendiagramm1.jpg]

ich hab mir überlegt die lagerelemente und lager die ich erzeuge in den
jeweiligen containerklassen zu verwalten. im lagerelement stehen die
eigenschaften der elemente(mindestanzahl,maximalzahl,....).

wenn ich nun was ein lagern will soll die die entsprechende (eindeutige) id
vom entsprechenden lagerelement und die id vom lager sowie die anzahl
an die entsprechende methode gegeben werden die dann wiederrum die
entsprechende methode im entsprechenden lager(aufgrund der id) mit dem
einlagern aufruft und durch die id vom lagerelementcontainer das
entsprechende lagerelementobjekt bekommt.

müsste ja eigentlich so funktionieren oder?


wenn ich ein lager erzeugen will (erstmal nur ein Festlager)
dann rufe ich die methode auf und übergebe ihr die anzahl
der lagerplätze und die kapazität.
drauf hin werden dann soviel objekte wie lagerplätze vorhanden
sein sollen erzeugt, die Lagerplätze haben die attribute:

int zuordnunug --> damit dort wird die id des lagerelementes eingetragen

int reihe[kapazität] --> es werden also soviel reihen erzeugt wie man an kapazität
zur verfügung hat
ist eine bestimmte reihe belegt wird sie mit 1 gefüllt
ist die reihe leer mit 0

bei diesem beispiel gehen wir einfach mal davon aus das jedes element nur
eine reihe eines lagerplatzes belegt. die verfeinerung kommt später.

aufgrund der zuordnung mit der id kann man jederzeit die weiter daten aus dem element auslesen und kommt jederzeit ran.
wird zum beispiel ein objekt eingelagert wird so verfahren wie grad beschrieben
und wenn das der fall ist, dann wird über den container die entsprechende die
aktuelle zahl der elemente geändert mit einer entsprechenden methode in der klasse lagerelement.

kann man das so machen? mir scheint die lösung erstmal recht gut

allerdings hab ich noch ein problem ich weiß nicht wie ich die das
observer-entwurfsmuster einbauen soll:
in der beschreibung vom beleg ist ja das folgende uml diagramm
verzeichnet

[Blockierte Grafik: http://www.mbz-leipzig.de/hummel/info/observe.jpg]

ich nehme an das subjekt soll das lager sein, allerdings steht da das das
subjekt ne unterklasse der klasse beobachtende ist und das wäre ja
dann die klasse lager. aber isses nich besser die beobachter über
die lagerverwaltung zu hinzuzufügen?

danke für eure hilfe

Hi,
Also das Ganze nochmal gut lesbarem Deutsch:

Zuerst einmal zu den Containerklassen. Die hab ich eingeführt weil ich da die Lager- sowie die Elemente nicht in der Klasse Lagerverwaltung unterbringen muss und somit mehr Ordnung und übersicht hab, da aber beide in in etwa die gleiche Aufgabe haben und auch ähnlich arbeiten könnte ich sie eigentlich auch von einer abstrakten Klasse erben lassen.

Das Lagerelement beschreibt jeweils immer einen Typ den man in ein Lager einlagern kann. Dabei hat er folgende Eigenschaften(Atrribute):

Name
ID
Meldebestand
Mindestbestand
Maximalbestand
Aktueller Bestand

und folgende Mehtoden:

Konstruktor
GetMeldebestand
GetMinestbestand
GetMaximalbestand
GetAktueller Bestand
Hinzufügen Elemente(Anzahl)
Entnehmen Elemente(Anzahl)
Prüfen Entnahme
Prüfen Hinzufügen

Diese Methoden und Attribute sind von der aufgabenstellung vorgegeben!

Das ganze ist so gemeint (ich hab einen Tutor gefragt) das wenn man etwas Einlagert das dann die Methode Hinzufügen Elemente(Anzhal) aufgerufen wird und dann dort das Attribut Aktuell Bestand erhöht wird um die entsprechende Anzahl.
Das war ja auch meine Frage anfangs ob es Sinn macht das Einlagern über die Lagerelemente zu regeln aber wie gesagt die Methode Hinzufügen Elemente/Entnehmen Elemente ist nur dazu da um den Zustand des Elementes zu ändern (Aktueller Bestand).
Das wirkliche Einlagern (in ein Lager) soll schon über die Lagerverwaltung durchgeführt werden.

Dazu wollte ich wie folgt vorgehen:

In Klasse Lagerverwaltung gibt es eine Methode Einlagern(LagerID,LagerelementID,Anzahl), unter der Annahme es existieren bereits mit einer ID eindeutig unterscheidbare Lager und mit einer eindeutigen ID unterscheidbare Lagerelemente).

die Methode macht dann folgendes:

sie ruft dann vom Objekt der LagerelementContainerklasse die Mehtode
getLagerelement(ID) auf die zu der entsprechenden ID das enstprechende
Lagerelementobjekt zurückgibt.
Darüber wird dann ersteinmal geprüft(Methode im Lagerelement) ob ein Einlagern unter den Umstanden (Anzahl einzulagernder Elemente, Maximalzahl, Aktuellzahl) möglich ist.

Sofern ein Einlagern möglich ist, wird das entsprechende Lagerelement an die Methode Einlagern(Lagerelement, Anzahl) des Lagers gegeben.
Dafür kommt die Klasse LagerContainer zum Einsatz.
Hier kann man genau wie im LagerelementContainer auf über eine Methode getLager(ID) das entsprechende Lagerobjekt zurückgeben lassen und damit arbeiten um das Einlagern(Lagerelement, Anzahl) zu veranlassen.

Dabei prüft das Lager erstmal ob es genug Platz hat um die entsprechende Anzahl an Lagerelementen aufzunehemen. Ist dies der Fall dann werden diese eingelagert.
wie genau ich mir das mit dem Einlagern vorstelle schreibe ich ganz zum Schluss.

Wurden die Elemente im Lager erfolgreich eingelagert dann wird wieder über den LagerelementContainer die Methode HinzufügenElemente(Anzahl) der Aktuell Bestand des enstsprechenden Lagereelementes erhöht, so das das Lagerelement "nun auch weiß das es einlagert wurde".

So stell ich mir das ganze unter der gegebenen Aufgabenstellung vor!
Meiner Meinung nach ist das ganze recht logisch und ich finde ich sollte die ContainerKlassen drin lassen weil man damit sehr leicht auf die Objekt in den Containern zurückgreifen kann.


So jetzt noch meine Grundüberlegung wie ich die ganze Sache mit dem Einlagern im Lager bewerkstelligen will.
Erstens gehen wir jetzt einmal davon aus das Es sich um ein Festlager handelt, mit einer vorgegebenen Kapazität(die auf jedem Lagerplatz gleich ist) und mit einer festgelegten Anzahl an Lagerplätzen.

Die Klasse Lagerplatz hat folgende Attribute: (im Fall Festlager)

Zuordnung = Lagerelement
int[] Reihe = new Integer[Kapazität]

Somit entspricht die Reihe der Kapazität!

Im Lagerobjekt wird ein LagerplatzArray der Länge (Anzahl der Lagerplätze) erstellt.

Wir nehmen an wir haben 5 Lagerplätze mit der Kapazität 4.
Auf dem ersten Lagerplatz befinden sich nur Lagerelemente mit der ID 82! (Festlager)
Außerdem sind nicht alle Reihen belegt sondern nur Reihe 1 und Reihe 3!

Damit sieht die Zuordnung nun so aus:

LagerplatzArray[1].Zuordnung= 82;

LagerplatzArray[1].Reihe[1]=1;
LagerplatzArray[1].Reihe[2]=0;
LagerplatzArray[1].Reihe[3]=1;
LagerplatzArray[1].Reihe[4]=0

Wobei 1 für Belegt steht und 0 für nicht belegt. Aufgrund der Zuordnung kann man jederzeit über die ID über getLagerelent(ID) -->ContainerKlasse<-- zugreifen und da noch weitere Daten auslesen.

Das Beispiel ist jetzt sehr verallgemeinert aber ich denke man erkennt wie ich die
ganze sache strukturieren will. natürlich muss man das ganze noch weiter ausbauen weil ja bestimmte Elemente auf mehrere Plätze belegen können aber das sollte hier erstmal nicht das Hauptproblem sein.

Beim Chaoslager würde ich dann den Array wahrscheinlich 2 Spaltig machen so das man eine Art Matrix hat wo zu jeder Belegung die Entsprechende Zuordnung hat.

Die feinheiten wie genau und unter welchen Kriterien die ganze Einlagerung ablaufen soll muss ich nochmal mit dem Tutor besprechen.

So,
ich hab das Klassendiagramm nochmal überarbeitet und gleich noch ne abstakte Klasse Container eingeführt von der die Containerklassen abgeleitet werden.

[Blockierte Grafik: http://www.mbz-leipzig.de/hummel/info/Klassendiagramm2.jpg]

Um nochmal auf das Observer Pattern zu kommen:

Ich denke beim Subjekt handelt es sich um das Entsprechende Lager(Festlager/Chaoslager) und die Klasse Beobachtende soll die abstrakte Klasse Lager sein.
Somit kann man über jedes Lagerobjekt beliebig viele Beobachter anmelden die dann bei einer Änderung im Lagerobjekt bei den Beobachtern die entsprechenden Reaktionen auslöst.

Ist das so in etwa richtig?

Motivation für das Beobachter-Muster:

Trennung der zu verarbeitenden Daten von der externen Darstellung. In einer MVC-Architektur werden das Modell und die Präsentation (view) getrennt

das Modell bleibt frei von Ausgabe-Anweisungen
die Präsentation kann dynamisch ausgetauscht werden
Mit unterschiedlichen Standardbausteinen können die internen Daten auch mehrfach und unterschiedlich angezeigt werden.

Gamma hat deswegen in seinem Diagramm extra eine mehrfach Aggregation zwischen Beobachtender und Beobachter (du hast es so wie Wikipedia gemalt). Salopp gesagt musst du deine Ausgabe von deinen Daten trennen.

Wir sollen keine GUI machen, wenn das mit der Trennung gemeint ist. Mir gehts ganz Allgemein um die Beobachtung wie man das am besten einbaut.
Was denn genau "Objekt" der Beobachtung ist und relevant ist, das frage ich den Tutor nochmal.

Achja dann noch eine Frage zur Umsetzung:

Ist es Möglich wenn ich eine Mehtode zu schreiben um ein Lagerobjekt(entweder Festlager oder Chaoslager) zurückzugeben so zu schreiben das sie in der Definition
als Rückgabewert allgemein den Typ Lager besitzt aber dann entweder den Typ Festlager oder Chaoslager zurückgibt?
Also so in der Form:

public Lager createLager(Lagerform, Anzahl, Kapazität)
{
wenn Festlager
{
return Festlagerobjekt;
}

wenn Chaoslager
{
return Chaoslagerobjekt;
}
}

Geht Das? Oder muss ich für jedes Lager eine eigene Methode schreiben?
So in der Form?

public Festlager createFest(Anzahl, Kapazität){}
public Chaosager createChaos(Anzahl, Kapazität){}


Riesen Lob und Danke von mir wie auch von meinen vier anderen Gruppenmitgliedern das ihr uns hier so weiterhelft!!!!

Hi,
also das Klassendiagramm sieht jetzt so aus:

[Blockierte Grafik: http://www.mbz-leipzig.de/hummel/info/Klassendiagramm3.jpg]

Hauptbestandteil der Überwachung ist natürlich das Lager. Sobald eine Meldung
eingeht das ich etwas geändert hat im Lager werden die KonkretenBeobachter
benachrichtigt und inspizieren das Lager. Über die Lagerbelegung kommen die
Beobachter dann auch automatisch zu den Lagerelementen. Ich weiß selber auch nicht was alles Gegenstand der Überwachung sein soll, aber das spielt ja im Moment auch keine Rolle.


Jetzt stellt sich die Frage ob man die abstrakte Klasse nicht einfach weglassen kann, weil im Prinzip gibts ja nur eine Unterklasse(bis jetzt :lol: ).
Was meint ihr dazu? Solang ich keine Unterschiedlichen konkretenBeobachter für
die 2 Lagerarten benötige, brauch ich ja nicht unbedingt die aktrakte Klasse Observer....meine ich zumindest :?

So Richtig verstehe ich es aber noch nicht wie man es bewerkstelligen soll das über eine Änderung am Lager alle Konkreten Beobachter gleichzeitig benachrichtigt werden sollen. kann man das über eine Klassenmethode umsetzen? wie würdet ihr das machen?

Übrigens die zwei Assoziationen zwischen den Containerklassen hab ich mit Absicht gelassen und nicht allgemein auf die Superklasse Container vereinfacht weil man meiner Meinung nach dann nicht ganz klar ist was für Container explizit in der Lagerverwaltung verwaltet werden sollen.