Modellierung, vererbung,

N

Noob1234_1234

Aktives Mitglied
Hallo zusammen,
ich soll einen ContainerTerminal modellieren. Dieser besteht insgesamt aus Containerstapeln und einem Kran, der Stapel wiederum aus 2 Arten von Container (mit ihren Eigenschaften / Vererbung) . Ich hab glaub ich soweit alles in den Bausteinen umgesetzt, aber mir ist beim Kran und dem Stappel nicht klar, wie diese interagieren sollen.

Die Aufgabe sagt mir :
"Ein Containerstapel besteht aus keinem, einem, oder mehreren Containern und es ist egal wie viele Stappel es gibt bzw erzeugt werden". Aber mich verwirrt jetzt der Kran, denn der soll :
Mit Hilfe des Krans können Container von einem Ursprungsstapel zu einem Zielstapel bewegt werden. Wichtig ist, dass der Kran nur Containertransporte durchzuführen kann, die im Rahmen seiner Fähigkeiten liegen, d.h. unter Beachtung der maximalen Traglast und Hubhöhe. Auch ist der Kran nicht fähig, mehrere Container gleichzeitig zu transportieren. Der Containertransport geschieht in vier Schritten:
1. Positioniere Kran vor Ursprungsstapel
2. Entnehme obersten Container („pick“)
3. Positioniere Kran vor Zielstapel
4. Lege zuvor aufgenommenen Container zuoberst ab („place“)

Das alles klingt doch sehr nach einem Stack oder ? Ich bin im Moment soweit, dass ich das habe :
Code: 
import java.util.ArrayList;
import java.util.List;

public class Stack<Container> {

    private int containerStackID;
    private static int firstContainerID = 0;
    private final List<Container> stackElements;

    public void createContainerStackID() {
        containerStackID = ++firstContainerID;
    }

    public int getContainerStackID() {
        return containerStackID;
    }

    public Stack() {
        createContainerStackID();
        stackElements = new ArrayList<>();
    }

    public void push(Container element) {
        stackElements.add(element);
    }

    public boolean isEmpty() {
        return stackElements.isEmpty();
    }

    public Container pop() {
        if (isEmpty()) {
            throw new EmptyStackException("Der Stack ist leer!");
        } else {
            int lastIndex = stackElements.size() - 1;
            Container lastElement = stackElements.get(lastIndex);
            stackElements.remove(lastIndex);
            return lastElement;
        }
    }

    @Override
    public String toString() {
        return "Stack [stackElements=" + stackElements + "]+ conatainerStackID ";
    }

    public void clear() {
        stackElements.clear();
    }

}
Hier dachte ich, dass es sich um den Containerstappel handelt, aber kann es sein, dass ich die Klasse gar nicht brauche, da der Kran diese ganzen Methoden braucht?

hier noch der Kran :
Code: 
public class Kran {
    
    private Container40ft container40ft;
    private Container40ftHC container40ftHC;
    private static final int maxHeight = 2438; // 160 Fuß entsprechen 2438,4 cm
    private static final int maxloadCapacity = 30; // Tonnen

    public static int getMaxheight() {
        return maxHeight;
    }

    public static int getMaxloadcapacity() {
        return maxloadCapacity;
    }

}
 
Noob1234_1234 hat gesagt.:
dass der Kran nur Containertransporte durchzuführen kann, die im Rahmen seiner Fähigkeiten liegen, d.h. unter Beachtung der maximalen Traglast und Hubhöhe
Zum Vergrößern anklicken....
Da es paar verschiedene Krans gibt, welche sich in Hubhöhe, Reichweite und Kraft unterscheiden, gilt es, diese Eigenschaften dem jeweiligen Kran zu "geben".
Eine Möglichkeit wäre es, ein Interface Kran mit Methoden wie
  • maxLiftPower() : double
  • maxLiftHight() : double
  • maxReach() : double
einzuführen und dann jede implementierende Klasse hart-codieren, wie du es bereits bei deinem Kran gemacht hast. Hat den Vorteil, dass jeweilige Klasse nur für sich geändert werden kann.
Java: 
interface Crane
{
   public double maxLiftPower();
   public double maxLiftHight();
   public double maxReach();
}

class LittleCrane implements Crane
{
    private final double liftPower = 10;
    private final double liftHight = 10;
    private final double maxReach = 10;
   
    public double maxLiftPower()
    {
        return this.liftPower;
    }
    public double maxLiftHight()
    {
        return this.liftHight;
    }
    public double maxReach()
    {
        return this.maxReach;
    }

}
Man kann aber auch eine Klasse Kran erstellen, dabei ist eben die Gefahr vorhanden, dass falsche Werte an ein Kran übergeben werden können.
Java: 
class Crane
{
    private final double liftPower;
    private final double liftHight ;
    private final double maxReach;

    Crane(double lift, double hight, double power)
    {
          //Werte übertragen
    }

    public double maxLiftPower()
    {
        return this.liftPower;
    }
    public double maxLiftHight()
    {
        return this.liftHight;
    }
    public double maxReach()
    {
        return this.maxReach;
    }
}
 
Javinner hat gesagt.:
Da es paar verschiedene Krans gibt, welche sich in Hubhöhe, Reichweite und Kraft unterscheiden, gilt es, diese Eigenschaften dem jeweiligen Kran zu "geben".
Eine Möglichkeit wäre es, ein Interface Kran mit Methoden wie
  • maxLiftPower() : double
  • maxLiftHight() : double
  • maxReach() : double
einzuführen und dann jede implementierende Klasse hart-codieren, wie du es bereits bei deinem Kran gemacht hast. Hat den Vorteil, dass jeweilige Klasse nur für sich geändert werden kann.
Java: 
interface Crane
{
   public double maxLiftPower();
   public double maxLiftHight();
   public double maxReach();
}

class LittleCrane implements Crane
{
    private final double liftPower = 10;
    private final double liftHight = 10;
    private final double maxReach = 10;
  
    public double maxLiftPower()
    {
        return this.liftPower;
    }
    public double maxLiftHight()
    {
        return this.liftHight;
    }
    public double maxReach()
    {
        return this.maxReach;
    }

}
Man kann aber auch eine Klasse Kran erstellen, dabei ist eben die Gefahr vorhanden, dass falsche Werte an ein Kran übergeben werden können.
Java: 
class Crane
{
    private final double liftPower;
    private final double liftHight ;
    private final double maxReach;

    Crane(double lift, double hight, double power)
    {
          //Werte übertragen
    }

    public double maxLiftPower()
    {
        return this.liftPower;
    }
    public double maxLiftHight()
    {
        return this.liftHight;
    }
    public double maxReach()
    {
        return this.maxReach;
    }
}
Zum Vergrößern anklicken....

in der Aufgabe wird festgelegt, dass es nur einen Kran gibt und er hat die Fähigkeit entweder die Container vom Ursprungsstapel zu nehmen und zu einem Zielstappel zu bringen, aber wie leg ich das fest bzw wie setz ich diese Vorgaben um? Brauche ich eine Stappelklasse für die Container?(wenn ja welche datenstruktur nutzt sie und wie sieht sie aus) und vor allem wie setz ich es um, dass ich dem Kran 2 integer mitgebe und er automatisch, weiß, dass sich der erste Integerwert auf stappel 1 bezieht und der 2. wert eben auf den anderen Stappel ?
 
mihe7 hat gesagt.:
Stack ist das englische Wort für Stapel 🙂
Damit wollte ich eigentlich erfragen, ob ich einen Stack als Datenstruktur nutzen sollte oder eben nicht, Wenn nicht, was dann ?

Mit Hilfe einer Methode, z. B. void transportContainer(Stapel origin, Stapel destination).
Zum Vergrößern anklicken....
Aber wie sollte denn die Stappelklasse aussehen? Ist meine Umsetzung oben gut oder nicht gut. Ich hab ja im Prinzip nur quasi einen Stack für Container geschrieben oder nicht? Brauche ich jetzt noch zusätzlich eine Klasse mit Konstruktor für die Containerstappel
 
Nachtrag: wie ich gerade lese, wird es die Methode so nicht geben, da die Transportschritte einzeln durchzuführen sind.
 
mihe7 hat gesagt.:
Nachtrag: wie ich gerade lese, wird es die Methode so nicht geben, da die Transportschritte einzeln durchzuführen sind.
Zum Vergrößern anklicken....
Muss soweit ich weiß nicht, es gilt nur die Bedingungen zu beachten, dass der zu transportierende Container nicht schwerere als die Traglast des Krans ist und dass der Stapel nicht die Höhe des Krans überschreitet. Also müsste es doch so irgendwie aussehen oder ?
Java: 
public class Kran {

    private Container40ft container40ft;
    private Container40ftHC container40ftHC;
    private static final int maxHeight = 2438; // 160 Fuß entsprechen 2438,4 cm
    private static final int maxloadCapacity = 30;

    public static int getMaxheight() {
        return maxHeight;
    }

    public static int getMaxloadcapacity() {
        return maxloadCapacity;
    }

    public static void transportContainer(Stack<Container> origin, Stack<Container> destination) {
        if (Kran.getMaxloadcapacity() > origin.getContainer.getWeight()) {
            Container origin = pop();
            destination.push(origin);
        }
    }

}
 
Aber es bleibt immernoch die Frage wie ich die Containerstappelklasse implementiere, denn ich muss ja irgendwie an die Container kommen, um Zugriff auf deren Gewicht zu kriegen, aber wie mach ich das ?
 
Noob1234_1234 hat gesagt.:
Muss soweit ich weiß nicht, es gilt nur die Bedingungen zu beachten, dass der zu transportierende Container nicht schwerere als die Traglast des Krans ist und dass der Stapel nicht die Höhe des Krans überschreitet.
Zum Vergrößern anklicken....
Das musst Du wissen. Ich habe nur gelesen:
Noob1234_1234 hat gesagt.:
Der Containertransport geschieht in vier Schritten:
Zum Vergrößern anklicken....

Also, jetzt gehen wir mal zurück auf Anfang - ohne Code. Wie sieht denn Dein Modell im Diagramm aus?
 
Noob1234_1234 hat gesagt.:
Aber es bleibt immernoch die Frage wie ich die Containerstappelklasse implementiere, denn ich muss ja irgendwie an die Container kommen, um Zugriff auf deren Gewicht zu kriegen, aber wie mach ich das ?
Zum Vergrößern anklicken....

Grob soll der Stapel der Aufgabe nach so aussehen:

Java: 
public class Stapel {
 
    public Container pick() {
     
    }
 
    public void place(Container container) {
     
    }
}

Edit:

"pick()" und "place()" könnten allerdings auch Methoden des Kranes sein. Die Aufgabe, wie oben beschrieben, lässt es offen, wie die Methoden des Stapels heißen, um den obersten Container zu entfernen, bzw. hinzuzufügen.
 
Zuletzt bearbeitet:
mihe7 hat gesagt.:
Das musst Du wissen. Ich habe nur gelesen:


Also, jetzt gehen wir mal zurück auf Anfang - ohne Code. Wie sieht denn Dein Modell im Diagramm aus?
Zum Vergrößern anklicken....
Also die Modellierung ist eigentlich relativ simple :
Ein Container-Terminal besitzt genau einen fahrbaren Kran sowie einen oder mehrere
Containerstapel. Containerstapel sind beginnend mit 0 fortlaufend nummeriert; Integer genügt,
um die Stapelnummern darzustellen. Ein Containerstapel besteht aus keinem, einem, oder mehreren
Containern.
Für die Container gilt :
Man unterscheidet zwei Arten von Containern: 40-Fuß-Container (Kurzschreibweise: 40ft) sowie 40-Fuß-High-Cube-Container ( Kurzschreibweise: 40ftHC). Dabei bezeichnet 40 Fuß1 die Länge der Container. „High Cube“-Container sind höher im Vergleich zu regulären 40-Fuß-Containern. Erstere haben eine Höhe von 9 Fuß und 6 Zoll, letztere haben eine Höhe von nur 8
Fuß und 6 Zoll. Ein Container in unserem vereinfachten Modell besitzt neben seinem Typ folgende Eigenschaften: Länge, Höhe, Gewicht, sowie eine eindeutige Identifizierungsnummer. Das Gewicht beinhaltet das Eigengewicht des Containers sowie die im Container enthaltene Fracht. Breite und weitere Eigenschaften sollen vernachlässigt werden.

Ich denk mal bei den Containern kann man nicht viel falsch machen. Ich hab eine allgemeine Container Klasse und lasse die beiden speziellen Arten davon erben und statte sie mit einem Konstruktor jeweils aus, der ihnen eine int und ein gewicht mitgibt
 
temi hat gesagt.:
Grob soll der Stapel der Aufgabe nach so aussehen:

Java: 
public class Stapel {

    public Container pick() {
    
    }

    public void place(Container container) {
    
    }
}

Edit:

"pick()" und "place()" könnten allerdings auch Methoden des Kranes sein. Die Aufgabe, wie oben beschrieben, lässt es offen, wie die Methoden des Stapels heißen, um den obersten Container zu entfernen, bzw. hinzuzufügen.
Zum Vergrößern anklicken....
Braucht die ganze Klasse den Stack oder erstellt sich der Stack immer nur im Konstruktor bzw in lokalen Methoden?
 
temi hat gesagt.:
Grob soll der Stapel der Aufgabe nach so aussehen:

Java: 
public class Stapel {

    public Container pick() {
    
    }

    public void place(Container container) {
    
    }
}

Edit:

"pick()" und "place()" könnten allerdings auch Methoden des Kranes sein. Die Aufgabe, wie oben beschrieben, lässt es offen, wie die Methoden des Stapels heißen, um den obersten Container zu entfernen, bzw. hinzuzufügen.
Zum Vergrößern anklicken....
Weil beim placen der Container muss der Container ja durch irgendeine Datenstruktur gespeichert werden und das ist ja dann der Stack ?
 
So in die Richtung sollte es dann gehen oder ?
Code: 
ublic class ContainerStack {

    private Container40ft container40ft;
    private Container40ftHC container40ftHC;

    Stack<Container> stack = new Stack<>();

    public Container pick() {
        Container container = stack.pop();
        return container;
    }

    public void place(Container container) {
        stack.push(container);
    }

}
 
mihe7 hat gesagt.:
Muss man hier alles selber machen?

Anhang anzeigen 12884

Hier fehlen noch Methoden. Wo und welche?
Zum Vergrößern anklicken....

Wenn ich es richtig sehe, fehlen nur die Methoden vom Kran. Darf ich fragen, wie du dieses Diagramm erstellt hast ?
Der Kran muss doch auch Zugriff auf den Stapel haben oder ? Den der Kran muss die Container ja bewegen und wie gesagt er kann das nur wenn der Container nicht schwerer als seine Traglast ist. Mit der 2. Bedingung tue ich mir schwer. Ich denke man merkt, dass ich kein Muttersprachler in der deutschen Sprache bin. Aber vielleicht kann mir wer das erläutern:

"
Ein Kran besitzt eine maximale Hubhöhe. Das ist die Höhe, die ein theoretisch vollkommen flacher Gegenstand der Höhe 0 angehoben werden könnte. Die tatsächliche Hubhöhe muss um die Höhe des angehobenen Gegenstands vermindert werden. Beträgt die maximale Hubhöhe 80 Fuß, so ergibt sich für einen 10 Fuß hohen Container eine tatsächlich erreichbare Hubhöhe von 70 Fuß. Falls die tatsächlich erreichbare Hubhöhe geringer als die Höhe des Zielstapels ist, ist es dem Kran nicht möglich, den Container auf dem Zielstapel zu platzieren. Der Container wird in diesem Fall gar nicht erst vom Ursprungsstapel entnommen. Stellen Sie die maximale Hubhöhe des Krans unveränderlich auf 160 Fuß ein. " Die Einheiten hab ich umgerechnet in cm
 
Code: 
import java.util.Stack;

public class ContainerStack {

    private int containerStackID;
    private static int firstContainerID = 0;

    Stack<Container> stack = new Stack<>();

    public void createContainerStackID() {
        containerStackID = ++firstContainerID;
    }

    public int getContainerStackID() {
        return containerStackID;
    }

    public Container pick() {
        Container container = stack.pop();
        return container;
    }

    public void place(Container container) {
        stack.push(container);
    }

    public ContainerStack(Container container) {
        createContainerStackID();
        place(container);
    }
}

Ich glaube so kann die Stapel Klasse auch nicht stimmen oder ? Muss Im Konstruktor jedes Mal eine neuer stack erstellt werden oder passt es so ? Ich will ja am Ende mindestens 3 Stapel im TerminalContainer haben, auf denen man die Container ablegen kann. Also sollten es auch 3 unterschiedliche Stacks zum speichern sein, aber ich bin mir nicht sicher, ob meine Implementierung, das so gewährleistet
 
Noob1234_1234 hat gesagt.:
Ein Kran besitzt eine maximale Hubhöhe. Das ist die Höhe, die ein theoretisch vollkommen flacher Gegenstand der Höhe 0 angehoben werden könnte. Die tatsächliche Hubhöhe muss um die Höhe des angehobenen Gegenstands vermindert werden. Beträgt die maximale Hubhöhe 80 Fuß, so ergibt sich für einen 10 Fuß hohen Container eine tatsächlich erreichbare Hubhöhe von 70 Fuß. Falls die tatsächlich erreichbare Hubhöhe geringer als die Höhe des Zielstapels ist, ist es dem Kran nicht möglich, den Container auf dem Zielstapel zu platzieren. Der Container wird in diesem Fall gar nicht erst vom Ursprungsstapel entnommen. Stellen Sie die maximale Hubhöhe des Krans unveränderlich auf 160 Fuß ein. " Die Einheiten hab ich umgerechnet in cm
Zum Vergrößern anklicken....

Was verstehst du denn daran nicht? Du musst halt vor dem Abladen/Absetzen prüfen, ob der Kran die Höhe des Stapels überhaupt erreichen kann.
 
Noob1234_1234 hat gesagt.:
Code: 
import java.util.Stack;

public class ContainerStack {

    private int containerStackID;
    private static int firstContainerID = 0;

    Stack<Container> stack = new Stack<>();

    public void createContainerStackID() {
        containerStackID = ++firstContainerID;
    }

    public int getContainerStackID() {
        return containerStackID;
    }

    public Container pick() {
        Container container = stack.pop();
        return container;
    }

    public void place(Container container) {
        stack.push(container);
    }

    public ContainerStack(Container container) {
        createContainerStackID();
        place(container);
    }
}

Ich glaube so kann die Stapel Klasse auch nicht stimmen oder ? Muss Im Konstruktor jedes Mal eine neuer stack erstellt werden oder passt es so ? Ich will ja am Ende mindestens 3 Stapel im TerminalContainer haben, auf denen man die Container ablegen kann. Also sollten es auch 3 unterschiedliche Stacks zum speichern sein, aber ich bin mir nicht sicher, ob meine Implementierung, das so gewährleistet
Zum Vergrößern anklicken....

Und jetzt wo ich so darüber nachdenke, weiß ich auch net, ob die place methode in den Konstruktor gehört. Die Aufgabe gibt ja nicht her, ob schon stapel mit Containern vorhanden sind, aber es muss ja eigentlich so sein, denn der Kran oder das Terminal kann sie ja schließlich nicht herzaubern
 
Noob1234_1234 hat gesagt.:
Ich will ja am Ende mindestens 3 Stapel im TerminalContainer haben, auf denen man die Container ablegen kann.
Zum Vergrößern anklicken....

Es ist ja nicht festgelegt, wieviele Containerstapel am ContainerTerminal stehen. Deshalb wirst du in ContainerTerminal auch eine flexible Möglichkeit benötigen mehrere Containerstapel zu haben. List<ContainerStack> würde sich da anbieten.

Da die Liste indexiert ist, könnte dieser Index auch gleich als Identifikation für die Stapel verwendet werden.
 
temi hat gesagt.:
Was verstehst du denn daran nicht? Du musst halt vor dem Abladen/Absetzen prüfen, ob der Kran die Höhe des Stapels überhaupt erreichen kann.
Zum Vergrößern anklicken....
Also sollte ich in der Stapel klasse eine Methode haben, die die Größe des Stapels berechnet, um es zu vereinfachen ?

Aber in der Kran Klasse versteh ich dann nicht, wie ich denn über die Stappel auf die Container zugreifen kann
Java: 
ublic class Crane {

    private static final int maxHeight = 2438; // 160 Fuß entsprechen 2438,4 cm
    private static final int maxloadCapacity = 30; // in Tonnen
    private ContainerStack containerstack;

    public static int getMaxheight() {
        return maxHeight;
    }

    public static int getMaxloadcapacity() {
        return maxloadCapacity;
    }

    public static void transportContainer(ContainerStack origin, ContainerStack destination) {
        if (Crane.getMaxloadcapacity() > origin.getContainer???? { // Wie greife ich auf die Container zu
            Container origin = origin.destination.push(origin);
        }
    }

}

Edit : Ich weiß inzwischen wie ich darauf zugreife, aber ich weiß nicht wie ich die Höhe vom Stappel bestimmen soll. Eigentlich hätte ich ja stack.size * Höhe gesagt, aber die Container haben keine einheitliche Höhe

Edit : Ich bin dumm und die Container haben eine einheitliche Größe. habs verwechselt mit der Länge
 
Zuletzt bearbeitet:
Noob1234_1234 hat gesagt.:
Aber in der Kran Klasse versteh ich dann nicht, wie ich denn über die Stappel auf die Container zugreifen kann
Zum Vergrößern anklicken....

origin.pick() nimmt den obersten Container des Ursprungsstapels...

Edit: Allerdings hast du hier das Problem, dass du vor dem Nehmen prüfen musst, ob du den Container überhaupt nehmen kannst. Wir kennen die Aufgabe nicht. Gibt es genauere Angaben, welche Methoden der Stapel hat und wie sie benannt sind?
 
Also ich glaube, dass ich soweit die Grundbausteine für die Modellierung habe. So sieht jetzt mein Kran aus(siehe unten), aber ich hab gerade in der Aufgabe weitergelesen, dass ich eine Textdatei mit 1. <Typ >;<Id >;< Gewicht >;< Stapel > und 2. <Ursprung >;< Ziel > schreiben muss. Der Path der Textdatei soll der Kommandozeile übergeben werden und jetzt hab ich das Problem, dass das Token <Ursprung > für die Ursprungsstapel-Numme steht und wieder eine positive int-Zahl inklusive 0 ist . Das Token <Ziel > steht für die Zielstapel-Nummer und ist wieder eine positive int-Zahl inklusive 0. Also werden der Methoden Zahlen übergeben und keine Container

Code: 
public class Crane {

    private static final int maxHeight = 2438; // 160 Fuß entsprechen 2438,4 cm
    private static final int maxloadCapacity = 30; // in Tonnen

    public static int getMaxheight() {
        return maxHeight;
    }

    public static int getMaxloadcapacity() {
        return maxloadCapacity;
    }

    public static void transportContainer(ContainerStack origin , ContainerStack destination) {
        if (Crane.getMaxloadcapacity() >= origin.getContainerWeight()
                && Crane.getMaxheight() >= (Crane.getMaxheight() - destination.calculateContainerStackHeight())) {

            Container c = origin.pick();
            destination.place(c);
        }
    }
}
 
Also ich bin wieder zurück und es gibt noch 2 Sachen bisher, die mich grundlegend irritieren. Also erstens soll der Kran zwei Zahlen (Integer entgegennehmen) und anhand von diesen die jeweiligen Stapel finden. Ich hab zwar in der Stapelklasse die Methode, die automatisch hochzählt wenn ein neuer Stapel erzeugt wird und entsprechend einen getter dafür, aber wie setz ich das im Kran um?

und seh ich es richtig, dass meine TerminalContainer Klasse die Hauptklasse inklusive main Methode ist ?
 
Poste doch mal die ganze Aufgabe, da fehlen mir zu viele Infos. Bislang haben wir ja nur ein grobes Modell, mir fehlt z. B., was zur Laufzeit überhaupt gemacht werden soll.
 
mihe7 hat gesagt.:
Poste doch mal die ganze Aufgabe, da fehlen mir zu viele Infos. Bislang haben wir ja nur ein grobes Modell, mir fehlt z. B., was zur Laufzeit überhaupt gemacht werden soll.
Zum Vergrößern anklicken....

Ihr Programm nimmt als erstes und einziges Kommandozeilenargument einen Pfad auf eine Textdatei entgegen. Verwenden Sie die Methode readFile der Klasse Terminal, um den Inhalt einer Datei zu lesen. Diese Methode hat als Rückgabewert ein String [], das die einzelnen Zeilen der Datei path enthält. Diese Datei beschreibt ein Container-Terminal wie beispielsweise in Abb. 0.1 dargestellt. Diese Datei besteht aus zwei Bereichen. Der erste Bereich beschreibt den initialen Aufbau eines Container-
Terminals. Der zweite Bereich beschreibt Containertransporte, die der Kran, ausgehend von dem initialen Aufbau, ausführen soll. Beide Bereiche sind durch eine Zeile mit dem Inhalt -- voneinander separiert. Hierbei können Sie nicht davon ausgehen, dass gegebene Eingabedateien immer genau nach den gegebenen Spezifikationen aufgebaut sind, folglich müssen Sie diese sowohl auf Semantik- als auchauf Syntaxfehler überprüfen. Eingabedateien, welche gegen die Spezifikation für Container und das Terminal verstoßen oder nicht nach untenstehender Syntaxspezifikation aufgebaut sind, führen zum Beenden des Programms, nachdem eine passende Fehlermeldung ausgegeben wurde. (Also hier muss ich die Eingabedateien irgendwie mit regex matcher und pattern überprüfen oder? )

Der erste Bereich enthält beliebig viele Zeilen. Jede Zeile beschreibt einen Container und seinen Lagerort. Befinden sich zwei Container im selben Containerstapel, liegt der Container mit kleinerer Zeilennummer unter dem Container mit größerer Zeilennummer. Jede Zeile ist folgendermaßen aufgebaut:
<Typ >;<Id >;< Gewicht >;< Stapel >
Das Token <Typ > steht für den Containertyp und ist dabei entweder 40 ft oder 40 ftHC. Das Token <Id > steht für Container-Id und ist eine positive int-Zahl. Das Token <Gewicht > steht für das Containergewicht und ist eine positive int-Zahl. Das Token <Stapel >steht für die Containerstapel-Nummer und ist eine positive int-Zahl inklusive 0. (Für den Typ ein Enum? aber wie geht das mit Zahlen?)

Der zweite Bereich enthält beliebig viele Zeilen. Jede Zeile beschreibt einen Containertransport des Krans, bestehend aus den vier Teilschritten (1) positionieren vor Ursprungsstapel, (2) aufnehmen, (3) positionieren vor Zielstapel, (4) ablegen. Jede Zeile ist folgendermaßen aufgebaut:
<Ursprung >;< Ziel >
Das Token <Ursprung > steht für die Ursprungsstapel-Nummer und ist wieder eine positive int-Zahl inklusive 0. Das Token <Ziel > steht für die Zielstapel-Nummer und ist wieder eine positive int-Zahl inklusive 0. (Hier habe ich das Problem mit den Zahlen)

Wie soll die Terminalklasse denn aussehen, ich hab es gerade versucht, aber ich hab wirklich keine Ahnung. Auf jeden Fall besitzt diese Klasse ja einen Kran und den habe ich instanziert, aber wie ich mit den Stappeln weiter vorgehen soll weiß ich nicht
 
Code: 
import java.util.Stack;

public class ContainerStack {

    private Container container;
    private int containerStackID;
    private static int firstContainerID = 0;
    private int ContainerStackHeight;

    Stack<Container> stack = new Stack<>();

    public int calculateContainerStackHeight() {
        ContainerStackHeight = stack.size() * 1219;
        return ContainerStackHeight;
    }

    public int getContainerWeight() {
        return container.getWeight();
    }

    public ContainerTyp getConTainerTyp() {
        return container.getContainertyp();
    }

    public void createContainerStackID() {
        containerStackID = ++firstContainerID;
    }

    public int getContainerStackID() {
        return containerStackID;
    }

    public Container pick() {
        Container container = stack.pop();
        return container;
    }

    public void place(Container container) {
        stack.push(container);
    }

    public ContainerStack(Container container) {
        createContainerStackID();
        place(container);
    }

    public String toString() {
        return String.format("%s;%s;%s;%s", container.getContainertyp(), container.getId(), container.getWeight(),
                containerStackID);
    }

    public static void main(String[] args) {
        ContainerStack cs = new ContainerStack(new Container40ft(ContainerTyp.A, 1, 1));
        ContainerStack cs1 = new ContainerStack(new Container40ft(ContainerTyp.B, 1, 1));
        System.out.println(cs);
        //System.out.println(cs1);
    }
}
Ich bekomme beim testen der toString eine NullpointerException, aber wieso?

Hier die ContainerKlasse
Code: 
public class Container {
    protected int length;
    protected static final int height = 1219; // in Fuß (umgerechent = 1219,2)
    protected int id;
    protected int weight;
    protected ContainerTyp containertyp;

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public static int getHeight() {
        return height;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public ContainerTyp getContainertyp() {
        return containertyp;
    }

}

Und hier die 2 Klassen, die erben
1.
Code: 
public class Container40ft extends Container {
    private static final int lenght = 259; // 8 Fuß 6 Zoll sind umgerechnet 259.08 cm
    private final ContainerTyp containertyp;

    Container40ft(ContainerTyp container, int id, int weight) {
        this.containertyp = container;
        super.id = id;
        super.weight = weight;
    }

    public int getLenght40ft() {
        return lenght;
    }

}

2.
public class Container40ftHC extends Container {
private static final int lenght = 289; // 9 Fuß 6 Zoll sind umgerechent ca 289.56 cm
private ContainerTyp containertyp;

Container40ftHC(ContainerTyp containertyp, int id, int weight) {
this.containertyp = containertyp;
super.id = id;
super.weight = weight;
}

public int getLenght40ftHC() {
return lenght;
}
}

Ich erstelle doch oben bei der test main methode einen neuen Container und will diesen printen. In den 2 erbenden Containern selbst werden doch die Werte, die mitgegeben werden, in der allgemeinen Container Klasse gespeichert (durch den Aufruf super.), aber wieso klappt das nicht ? Ich krieg eine Nullpointer
 
mihe7 hat gesagt.:
Aha, mit #45 wird endlich ein Schuh draus.


Ja, was soll denn container sein?
Zum Vergrößern anklicken....
in dem Fall war es ein Enum, dass aus nur 40ft und 40ftHC besteht, aber das mit dem Enum klappt irgendwie nicht und ich bin seit stunden am Testen und bin mir sicher, dass meine Datenkapselung scheiße ist. Wie greif ich in meiner Modellierung bitte auf die entsprechenden Attribute der anderen Klassen zu ?

Am Bsp kran und Stapel: So funktioniert die Methode, aber so wie oben mit den Bedingugen, die eigentlich auf die Werte von Container greifen sollten, klappt es nicht? Was mach ich falsch bei der Datenkapselung

Code: 
public void transportContainer(ContainerStack origin, ContainerStack destination) {

            Container c = origin.pick();
            destination.place(c);
        }
 
Wo ist mein Denkfehler bei der Datenkapselung ? Wie greife ich in meiner Crane Klasse auf Attribute von ContainerStack zu ? Das ist nicht das erste Mal, dass ich diesen Fehler habe, aber ich checke net wo das Basisproblem liegt

Code: 
public class Crane {

    private static final int maxHeight = 2438; // 160 Fuß entsprechen 2438,4 cm
    private static final int maxloadCapacity = 30; // in Tonnen
    private ContainerStack origin;
    private ContainerStack destination;

    public static int getMaxheight() {
        return maxHeight;
    }

    public static int getMaxloadcapacity() {
        return maxloadCapacity;
    }

    public void transportContainer(int number, int secondNumber) {
        if (origin.getContainerStackID() == number && destination.getContainerStackID() == secondNumber) {

            /*if (Crane.getMaxloadcapacity() >= origin.getContainerWeight()

                    && Crane.getMaxheight() >= (Crane.getMaxheight() - destination.calculateContainerStackHeight())) {*/

                Container c = origin.pick();
                destination.place(c);
            }
        }
    }
//}
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Modellierung eines graphentheoretischen Problems
Antworten: 5
Modellierung in Eclipse - Java-Code <-> Model
Antworten: 13
Spring Data: Modellierung mit einer Embeddable bean
Antworten: 2
Arbeitszeit / Zeiterfassung - Gedanken und Modellierung
Antworten: 122
UML Modellierung
Antworten: 1

Zurück
Oben