2dimensionales array, Lagerverwaltung

Danke für die Beiträge.

So sieht jetzt der Entwurf des Lösungscodes aus (ohne Ein & Ausgabe in der Console).

Wir sind dabei die Methodenimplementierung richtig zu schreiben.

Ich habe es mit diesem Code versucht, brauche aber noch eure Ratschläge dazu, wie man Methoden richtig implementiert.

Vllt kann ja Handshake die Methodenimplementierung codieren (den Quellcode anbieten). das wäre perfekt.

Bitte um eure Antworten, was und wie zu verbessern wäre.

Danke im Voraus.

Code:
public class Lagerverwaltung {

    private final static int ANZ_KISTEN = 75; // hier Vorgabewert angeben

    private final static int ANZ_FELDER = 3; // dito



private int[][] kisten = new int[4][75];

    private int id;







    // Beispiel: Methode, um eine Kiste zu löschen.

    // Für die id wurde hier int gewählt, das steht dir ja frei, was du da nehmen möchtest

    public void kisteLoeschen(int id) {

        this.id = id;

        // code

    }



  public void kisteAusgeben(int id){

   this.id = id;

  }



public void alleKistenAusgeben() {

    // hierzu fällt mir nichts ein, was soll denn alle Kisten repräsentieren? Welche Variable?

 

}



public void kisteAendern(int id) {

 

    this.id = id;

}



public int neueKiste(int i, int j, int k) {



    // vllt muss hier return: i, j, k; stehen, ich bekomme darauf eine Fehlermeldung

    return neueKiste(0, 0, 0);

}



}







public class Main {



    public static void main(String[] args) {

 

        Lagerverwaltung lager = new Lagerverwaltung();

 

        // Kiste mit den Abmessungen 10x10x10 dem Lager hinzufügen und id der Kiste merken

        int id = lager.neueKiste(10,10,10);

 

        // Kiste wieder aus dem Lager löschen

        lager.kisteLoeschen(id);

 

       // Kiste ändern

       lager.kisteAendern(id);

 

//alle Kisten anzeigen lassen

lager.alleKistenAusgeben();



// bestimmte Kiste anzeigen lassen

lager.kisteAusgeben(id);







//egal welche Methode ich hier eintippe =>Fehler



// The method println(boolean) in the type PrintStream is not applicable for the arguments (void)



System.out.println(lager.kisteLoeschen(64));

    }



}
 
Na jetzt bin ich gespannt, was ist denn im Sinne der Aufgabenstellung ungenau...?
Nicht ungenau sondern im Sinne der Aufgabenstellung falsch. Deine Lagerverwaltung unterstützt eben nur einen Kistenstapel. Man soll aber beliebig Kisten einfügen, ändern und entfernen können, solange man nicht die genannten Restriktionen verletzt. Dementsprechend falsch sind alle deine Methoden außer clear(). Außerdem sollen die Kisten nicht über ihre Array-Position identifiziert werden, sondern über ihre jeweilige ID.
 
wenn du diesen Satz meinst: "Was müsstest Du schreiben, um eine (einzige) Kiste zu erstellen?"

Code:
public class Lagerverwaltung {
..

public int neueKiste(int i, int j, int k) {



    // vllt muss hier return: i, j, k; stehen, ich bekomme darauf eine Fehlermeldung

    return neueKiste(0, 0, 0);

}



public class Main {

    public static void main(String[] args) {

// Kiste mit der Nr.4 & den Abmessungen 10x10x10 dem Lager hinzufügen und id der Kiste merken

        int id = lager.neueKiste(4,10,10,10);
      
        }
        ..

dann würde ich es so probieren

& das array haben wir doch schon richtig deklariert, s. #40:

Es sollte ein array sein 2 dimensional, mit 4 Spalten (id, Länge, Höhe, Breite). Das soll dort gespeichert werden. Ich visualisiere es als zwei.dimensionales array (also 4 Spalten).
ID rufen wir immer so ab:
Länge

[4 spalten für id, Länge, Höhe, Breite][75 zeilen für 75 Kisten]

muss es so aussehen?

private int[][] kisten = new int[4][75];
 
dann würde ich es so probieren
Nein. Du sollst keine Methoden verwenden, sondern einfach eine "Kiste" erzeugen (s. u.)

muss es so aussehen?
Nein, andersrum, nochmal: #42 (jetzt weiß ich, warum 42 die Antwort auf alles ist 😀) Warum das so ist, wirst Du sehen, wenn Du mal eine Kiste erzeugst.

Was ist in Deinem Modell denn eine Kiste? Wie wird eine einzelne Kiste denn dargestellt?
 
int[][]kiste = (4,10,10,10);

//oder so

Code:
public class Lagerverwaltung {

    public static void main(String[] args) {
        int[][] kiste = {{ Nummer 1, "Länge 10", "Höhe 10", "Breite 10" }};
        ..

// oder

public class Lagerverwaltung {

    public static void main(String[] args) {
        int [][] kisten = {

// Positionen [0,0 = Nummer1], [0,1 = Höhe 10], [0,2 = Länge 10], [0,3 = Breite 10]

                { "Nummer 1", "Höhe 10", "Länge 10", "Breite 10" },

// Positionen [1,0 = Nummer2], [1,1 = Höhe 12], [1,2 = Länge 12], [1,3 = Breite 12]

    {"Nummer 2", "Höhe 12", "Länge 12", "breite 12"},

//etc. };
 
Zuletzt bearbeitet:
Was ist denn an meiner Implementierung, s. #43, falsch? Weil ich die IDs vergessen habe und die Methoden ganz anders heißen, stimmts?

@Codix Du musst bei Adam und Eva anfangen....
 
Was ist denn an meiner Implementierung, s. #43, falsch? Weil ich die IDs vergessen habe und die Methoden ganz anders heißen, stimmts?
Hast du die Aufgabenstellung noch immer nicht gelesen? Angenommen man fügt 75 Kisten mit den IDs 0-74 in aufsteigender Reihenfolge der IDs ein. Dann ist auf jeder Array-Position eine Kiste, deren ID der Array-Position entspricht. Nun entfernt man Kiste 33 (geht mit deiner Lösung nicht) und fügt Kiste 75 ein. Das geht mit deiner Lösung auch nicht, obwohl an Position 33 ein Platz frei wäre.
 
int[][]kiste = (4,10,10,10);
Nein, Deine Kiste ist kein zweidimensionales Array, nur ein eindimensionales. In diesem eindimensionalen Array werden vier Werte gespeichert, also wird eine Kiste mit new int[4]; erzeugt. Damit wir mit der Kiste arbeiten können, weisen wir diese neue Kiste noch einer Variablen zu:
Java:
int[] kiste = new int[4];

Jetzt hast Du ein "Lager" (Variablen kisten - mit n am Ende) und wir sagen einmal, wir möchten die eben erzeugte Kiste an Position 15 im Lager einlagern, dann können wir schreiben:
Java:
kisten[15] = kiste;
Das ist jetzt der Grund, warum man die "Zeilen" zuerst angibt. Würdest Du kisten mit new int[4][75] erzeugen, könntest Du nicht direkt auf die 15. Kiste zugreifen - bei new int[75][4] schon. Es wird aber noch besser: die zweite Angabe kannst Du Dir sparen, weil in Java ein zweidimensionales Array einfach ein Array von Arays ist: kisten = new int[75][]; reicht also aus, um zu sagen: ich will ein Array, das Platz für 75 int-Arrays hat.

Verstanden?
 
weil wir aber ein 2D array haben, sollte wir das hier anwenden:
Nein, Deine Kiste ist kein zweidimensionales Array, nur ein eindimensionales. In diesem eindimensionalen Array werden vier Werte gespeichert, also wird eine Kiste mit new int[4]; erzeugt. Damit wir mit der Kiste arbeiten können, weisen wir diese neue Kiste noch einer Variablen zu:
Java:
int[] kiste = new int[4];

Jetzt hast Du ein "Lager" (Variablen kisten - mit n am Ende) und wir sagen einmal, wir möchten die eben erzeugte Kiste an Position 15 im Lager einlagern, dann können wir schreiben:
Java:
kisten[15] = kiste;
Das ist jetzt der Grund, warum man die "Zeilen" zuerst angibt. Würdest Du kisten mit new int[4][75] erzeugen, könntest Du nicht direkt auf die 15. Kiste zugreifen - bei new int[75][4] schon. Es wird aber noch besser: die zweite Angabe kannst Du Dir sparen, weil in Java ein zweidimensionales Array einfach ein Array von Arays ist: kisten = new int[75][]; reicht also aus, um zu sagen: ich will ein Array, das Platz für 75 int-Arrays hat.

Verstanden?
Danke@mihe7
wir wollten es 2D machen wegen den angaben: Höhe, Länge, Breite. Somit hätten 75 Kisten mit je 3 Angaben bezüglich der Kistenmasse.
 
Es ist nach wie vor 2D und ob drei oder vier Angaben, ist völlig egal. Eine einzelne Kiste ist eine Zeile in diesem Array.
Zur Verdeutlichung, noch einmal zurück zu einem der früheren Beiträge, wo du das schön sehen kannst:
Code:
             id   b    l    h
Kiste 1    |    |    |    |    |
Kiste 2    |    |    |    |    |
...
Kiste 75   |    |    |    |    |
Eine Kiste ist ein Array von drei (oder vier) Werten. Und davon hast du 75.
 

Zurück
Oben