# Lagerverwaltung



## thor_norsk (30. Sep 2021)

Guten Tag,
ich habe eine Aufgabe zur Lagerverwaltung erhalten, habe versucht zu programmieren, allerdings funktioniert noch nicht richtig.

*Aufgabe)*
Erstellen Sie eine „Lagerverwaltung“, die folgende Daten für Kisten speichern kann:

•eine eindeutige Nummer zur Identifikation jeder einzelnen Kiste,

•die Breite, Länge und Höhe jeder Kiste.

Die Nummer zur Identifikation der Kiste können Sie nach einem beliebigen Schema selbst vergeben. Stellen Sie aber durch geeignete Verfahren sicher, dass bei der Eingabe einer neuen Kiste nicht eine bereits vergebene Nummer benutzt wird.

Das Programm soll die Daten der Kisten lediglich zur Laufzeit speichern – also nur so lange, wie das Programm arbeitet. Es sollen maximal Daten von 95 Kisten verwaltet werden können.

Das Programm soll folgende Funktionen anbieten:

•Eingabe einer neuen Kiste,

•Löschen der Daten einer vorhandenen Kiste,

•Ändern der Daten einer vorhandenen Kiste,

•Anzeigen der Daten einer vorhandenen Kiste und

•eine Listenfunktion, die die Daten aller vorhandenen Kisten anzeigt.

Beim Löschen, Ändern und Anzeigen soll der Zugriff auf die Daten der Kiste über die Nummer der Kiste erfolgen.

Für die Umsetzung gelten folgende Vorgaben:

•Speichern Sie die Daten in einem mehrdimensionalen Array. Erstellen Sie dieses Array *lokal* in der Methode main(). Verwenden Sie bitte keine Klassenvariable für das Array.

•Stellen Sie sicher, dass beim Zugriff auf die Daten der Kisten die Grenzen des Arrays nicht verlassen werden.

•Erstellen Sie für das Eingeben, Löschen, Ändern, Anzeigen und Auflisten jeweils eigene Methoden.

•Sorgen Sie dafür, dass beim Löschen, Ändern, Anzeigen und Auflisten nur auf Einträge zugegriffen werden kann, für die bereits Daten erfasst wurden. Dazu können Sie zum Beispiel überprüfen, ob die Nummer der Kiste noch den Wert 0 hat, der beim Anlegen des Arrays automatisch zugewiesen wird. Um eine Kiste zu löschen, reicht es dann, die Nummer der Kiste wieder auf den Wert 0 zu setzen.

•Erstellen Sie in der Methode main() ein Auswahlmenü für den Zugriff auf die einzelnen Funktionen der Lagerverwaltung.

•Kommentieren Sie sowohl die verwendeten Variablen als auch die Methoden. Geben Sie bei den Methoden bitte eine kurze Beschreibung der Funktionsweise, der verwendeten Argumente und eines eventuellen Rückgabewerts an.

*Mein Vorschlag:*


```
package lagerverwaltung;
import javax.swing.*;
import java.util.Arrays;


public class Lagerverwaltung {

    // Eingabe: Eine neue Kiste
   
            static void eingabe(int [][] argEingabe) {  
           
                int nummer;
                int breite, laenge, hoehe;
               
                //Kistennummer eingeben.
           
                do { nummer = Integer.parseInt(JOptionPane.showInputDialog(" Bitte geben Sie eine Kistennummer (1-95)."));
                   
                //Überprüfung der Kistennumer, ob vergeben ist! (Äußere Array zur Überprüfung der Kistennummer!)
               
                if (nummer>0 && nummer<argEingabe.length)  // Überprüfe ob kleiner als eingabe(95) ? & grösser als 0 sonst endet!
                    // [nummer-1][0] == 0 , 2 Array muss [0] sein, sonst ist die Kiste nicht frei und
                    //somit Eingabe nicht gültig!
                    if (argEingabe[nummer-1][0]==0) {       
                           argEingabe[nummer-1][0] = nummer;   // nummer-1, da der Index mit 0 beginnt!
                        //werte einlesen                   
                       
                        breite = Integer.parseInt(JOptionPane.showInputDialog("Bitte geben Sie die Breite der Kiste ein."));
                            argEingabe[nummer-1][1] = breite;
                        laenge = Integer.parseInt(JOptionPane.showInputDialog("Bitte geben Sie die Länge der Kiste ein."));
                            argEingabe[nummer-1][2] = laenge;
                        hoehe = Integer.parseInt(JOptionPane.showInputDialog("Bitte geben Sie die Höhe der Kiste ein."));  
                            argEingabe[nummer-1][3] = hoehe;
                    }
                    else {
                        System.out.println("\n Die Kistennummer ist ungültig oder schon vergeben");
                    }
                }
                    while (nummer <=0 || nummer > argEingabe.length); // Eingegebe Kistennummer zwischen [1-95] dann Wiederholung
                // der Schleife nicht notwendig, wenn man z.b. 98 eintippe , muss man die Eingabe wiederhollen bis es Passt und
                // vor Allem die Nummer noch frei ist!
            }
           
            // Löschen eine Kiste
           
            static void loeschen(int [][] argLoeschen) {
               
                int nummer;
                //Kistennummer eingeben
                do { nummer = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie bitte die löschende Kistennummer ein."));
                // Kontrolle ob die eingegebene Kistennumer einer bereits gespeicherten Kiste entspricht.
                if(nummer>0 && nummer<=argLoeschen.length) {
                    argLoeschen[0][0] = nummer;
                }
                else {
                    System.out.println("\n Die Kistennummer"+nummer+"ist nicht bekannt");
                }
            }
                while (nummer <= 0 || nummer > argLoeschen.length);
        }
               
            // Ändern einer Kiste
           
            static void aendern(int [][] argAendern) {
               
                int nummer;
                int breite, laenge, hoehe;              
               
                // Kistennummer eingeben.
               
                do { nummer = Integer.parseInt(JOptionPane.showInputDialog("Bitte geben Sie neue Kistennummer ein.(1-95)"));
                // Wenn Kistennummer gültig und noch nicht vergeben
               
                if (nummer>0 && nummer<=argAendern.length)
                    if(argAendern[nummer-1][0] !=0) {
               
                    //Werte einlesen
                    breite = Integer.parseInt(JOptionPane.showInputDialog("kistenbreite"));
                        argAendern[nummer-1][1] = breite;
                    laenge = Integer.parseInt(JOptionPane.showInputDialog("kistenbreite"));
                        argAendern[nummer-1][2] = laenge;
                    hoehe = Integer.parseInt(JOptionPane.showInputDialog("kistenbreite"));
                        argAendern[nummer-1][3] = hoehe;  
                }
                else {
                        System.out.println("\n Die Kistennumer ist ungültig oder noch nicht vergeben");
                }
            }
                while(nummer<=0 || nummer<argAendern.length);
        }
           
            // Eine Kiste anzeigen
           
            static void anzeigen(int [][] argAnzeigen) {
           
                int nummer;    // nummer wird jedes Mal neue vereinbart, da nur innerhalb der Methode gültig ist (lokale Variable)?
                nummer = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie eine vorhandene Kistennummer ein"));
                for ( int i=0; i<argAnzeigen.length; i++) {
                    if(nummer>0 && nummer<=argAnzeigen.length && argAnzeigen[0] == nummer) {
                        System.out.println("\n Die Daten der Kiste sind t:\t"+Arrays.toString(argAnzeigen));
                        return;
                    }
                }
            }
            
            
        public static void main(String[] args) {
            //Vereinbarung des Arrays
            
            int [][] kistenArray = new int [95][4];
            // Auswahl der Funktion
            String functionEinlesen;
            char function;
            
            System.out.println("Folgende Funktionen stehen Ihnen zur Auswahl: \n");
            System.out.println("A \t Eingabe einer neuen Kiste");
            System.out.println("B \t Löschen einer Kiste");
            System.out.println("C \t Ändern einer Kiste");
            System.out.println("D \t Daten einer Kiste anzeigen");
            System.out.println("E \t Daten aller Kisten anzeigen");
            
            functionEinlesen = JOptionPane.showInputDialog("Wählen Sie eine Funktion");
            function = funktionEinlesen.charAt(0);
            // Auswahl auswerten
            
            switch(function) {
            
            case 'a':
            case 'A':
                System.out.println("\n Sie haben Eingabe einer neuen Kiste gewählt.");
                eingabe(kistenArray);
                break;
                    
            case 'b':
            case 'B':
                System.out.println("\n Sie haben Löschen einer Kiste ausgewählt.");
                loeschen(kistenArray);
                break;
    
            case 'c':
            case 'C':
                System.out.println("\n Sie haben Ändern einer Kiste ausgewählt.");
                aendern(kistenArray);
                break;
            
            case 'd':
            case 'D':
                System.out.println("\n Sie haben Daten einer Kiste anzeigen gewählt.");
                anzeigen(kistenArray);
                break;
                
            case 'e':
            case 'E':
                System.out.println("\n Sie haben Daten aller Kisten anzeigen gewählt.");
                System.out.println(Arrays.toString(kistenArray));
                
            }
            System.exit(0);
    }
}
```


----------



## kneitzel (30. Sep 2021)

thor_norsk hat gesagt.:


> allerdings funktioniert noch nicht richtig.


Da wäre immer wichtig zu erfahren:
Was funktioniert denn noch nicht?
Wie verhält sich der Code und was wäre die Erwartung?

Ein Hinweis: Bei eingabe prüfst Du, ob ein Platz frei ist. Beim Löschen musst Du also etwas machen, dass danach die Prüfung bei eingabe für die Kistennummer ergibt: Platz ist frei. Du kannst also die Prüfung und Deine Zuweisung direkt vergleichen.

Generell ist bei sowas immer hilfreich, wenn Du Dir mit Stift und Zettel alles aufmalst. Dann kannst Du mit Stift und Papier nachvollziehen, was Du jeweils machst und so auch Fehler finden.


----------



## Jw456 (30. Sep 2021)

das wird auch nicht das erfüllen was es soll

```
if(nummer>0 && nummer<=argLoeschen.length) {
                    argLoeschen[0][0] = nummer;
```
eine Kiste löschen.


```
argLoeschen[nummer][0] = 0;
```


----------



## thor_norsk (30. Sep 2021)

funktioniert immer noch nicht


----------



## Jw456 (30. Sep 2021)

thor_norsk hat gesagt.:


> funktioniert immer noch nicht


Und was genau. Wir können nicht hellsehen.


----------



## thor_norsk (30. Sep 2021)

Wenn ich zum Beispiel aus der Auswahlliste ''A'' auswähle und im Anschluss für Kistennummer 10 eintippe, Länge,Breite, Hohe  auf 10 setze.
Jetzt möchte ich natürlich Daten einer Kiste (D) zeigen lassen, um zum Beispiel zu setzen was ich eingetippt habe.
Als Nächtes habe ich aus der Auswahlliste "D" gewählt , und das Programm fragt nach Kistennummer, ich 10 eingetippt, da ich vorher unter Auswahl "A" Kiste 10 gespeichert habe Samt Länge, Breite, Höhe.
Ich bekomme nur folgende Ausgabe:    *Sie haben Daten einer Kiste anzeigen gewählt. *Nur die Werte fehlen!!! Länge,Breite,Höhe....


----------



## mihe7 (30. Sep 2021)

Zu viel Java-Forum schadet der Gesundheit: man bekommt das Gefühl, Dinge wie Aufgaben wiederholen sich praktisch ständig... und täglich grüßt das Murmeltier.


----------



## thor_norsk (30. Sep 2021)

Vertippt! setzen = sehen


----------



## Jw456 (30. Sep 2021)

Überlege doch mal was du in der main Methode machst. Du fragst den User welche Fuktion er ausführen will. Gehst dann in dein switch rufst die Methode auf.
Was passiert wenn du aus der Methode raus kommst.
Dein Programm ist beendet. Deine Daten im Array sind weg.
Was müsstest du zb in deiner main machen?

Ich verstehe auch nicht den Sinn warum du für das zb Eingeben Löschen... in der Methode eine Schleife machst. Da sehe ich keinen sinn.


----------



## thor_norsk (1. Okt 2021)

Die Schleifen dienen zur Überprüfung, sonst kann jemand zum Beispiel Kistennummer 100 eingeben, und ist laut Aufgabestellung nicht erwünscht!


----------



## mihe7 (1. Okt 2021)

An Deiner Stelle würde ich die Eingabe selbst in einer eigenen Methode behandeln, etwas wie

```
/** liest eine Ganzzahl im angegebenen Bereich ein.
 * @param von  untere Grenze (inkl.) der einzulesenden Zahl
 * @param bis  obere Grenze (inkl.) der einzulesenden Zahl
 * @returns Integer x mit von <= x <= bis oder null, falls der Vorgang abgebrochen wurde.
 */
public static Integer liesZahl(int von, int bis) {
  // Dein Code mit Schleife und Fehlerbehandlung
}
```

Natürlich kann man die Parameter um z. B. ein Prompt erweitern. Dein restlicher Code vereinfacht sich durch eine solche Methode in drastischer Weise.


----------



## thor_norsk (5. Okt 2021)

Guten Abend,
ich vermute durch break  - Anweisung  in meiner Switch gehen meine Daten verloren? Habe mein Code erweitert und wenn ich listenfunktion aufrufe sind alle Werte auf ,,Null'' gesetzt. 

[CODE lang="java" title="Lagerverwaltung"]static void listenFunktion(int [][] argListenFunktion) {

                for (int iA=0; iA<2; iA++)   
                    for (int il=0; il<4; il++)
                        System.out.println("Der Wert des Elements \t"+iA+"\t"+il+"\t ist \t"+argListenFunktion[iA][il]);[/CODE]

Im Anschluss in Switch eingebaut.

[CODE lang="java" title="Lagerverwaltung"]switch(function) {

            case 'A':
            case 'a':
                System.out.println("\n Sie haben Eingabe einer neuen Kiste gewählt.");
                eingabe(kistenArray);
                break;

            case 'B':
            case 'b':
                System.out.println("\n Sie haben Löschen einer Kiste ausgewählt.");
                loeschen(kistenArray);
                break;

            case 'C':
            case 'c':
                System.out.println("\n Sie haben Ändern einer Kiste ausgewählt.");
                aendern(kistenArray);
                break;

            case 'D':
            case 'd':
                System.out.println("\n Sie haben Daten einer Kiste anzeigen gewählt.");
                anzeigen(kistenArray);
                break;

            case 'E':
            case 'e':
                System.out.println("\n Sie haben Daten aller Kisten anzeigen gewählt.");
                listenFunktion(kistenArray);
                break;
            }[/CODE]

Ich überlege die ganze Zeit, ob es eine Möglichkeit gibt Switch durch While - Schleife zu ersetzen, um das Problem mit der break - Anweisung zu umgehen? Falls ich JW456 richtig verstanden habe, deutet er auf meine break - Anweisung hin, womit meine gespeicherte Werte verloren gehen?


----------



## kneitzel (6. Okt 2021)

Die break; / deine switch Anweisung ist so in Ordnung. 

Das Problem ist nur, dass Du nach jeder Auswahl das Programm sofort beendest. Bei jedem Start sind natürlich wieder alle Variablen neu initialisiert und Eingaben sind weg.

Das was @Jw456 meinte: Du musst um Deine switch Anweisung noch eine Schleife drumherum bauen. Du könntest Da z.B. einfach ein

```
while(true) {
    // Hier deine switch Anweisung!
}
```
um deine switch Anweisung bauen.

Und damit Du das Programm beenden kannst, kannst Du noch ein Menupunkt Beenden einbauen - in dem wäre dann das System.exit(0); enthalten.


----------



## Jw456 (6. Okt 2021)

An den TE genau ich dachte du kommst selber auf die Idee eine Schleife zu benutzen.


----------



## thor_norsk (7. Okt 2021)

Guten Tag, die Aufgabe macht keinen Spaß mehr! Jetzt habe ich eine endlose Schleife Programmiert . 
Ob ich jetzt A, E,... wähle, habe ich an der Stelle eine endlose Schleife.


----------



## thor_norsk (7. Okt 2021)

Habe vergessen....Code anzugeben.

[CODE lang="java" title="Lagerverwaltung"]public static void main(String[] args) {
            //Vereinbarung des Arrays

            int [][] kistenArray = new int [75][4];   // [75][4] dient als Arument für die Methoden zur Überprüfung (Grenze 75 Kisten / 4 länge,..
            // Auswahl der Funktion                         

            do {

            String einlesen;
            char wahl;

            System.out.println("Folgende Funktionen stehen Ihnen zur Auswahl: \n");
            System.out.println("A \t Eingabe einer neuen Kiste");
            System.out.println("B \t Löschen einer Kiste");
            System.out.println("C \t Ändern einer Kiste");
            System.out.println("D \t Daten einer Kiste anzeigen");
            System.out.println("E \t Daten aller Kisten anzeigen");

            einlesen = JOptionPane.showInputDialog("Wählen Sie eine Funktion");
            wahl = einlesen.charAt(0);
            // Auswahl auswerten


            switch(wahl) {

            case 'A':
            case 'a':
                System.out.println("\n Sie haben Eingabe einer neuen Kiste gewählt.");
                eingabe(kistenArray);
                break;

            case 'B':
            case 'b':
                System.out.println("\n Sie haben Löschen einer Kiste ausgewählt.");
                loeschen(kistenArray);
                break;

            case 'C':
            case 'c':
                System.out.println("\n Sie haben Ändern einer Kiste ausgewählt.");
                aendern(kistenArray);
                break;

            case 'D':
            case 'd':
                System.out.println("\n Sie haben Daten einer Kiste anzeigen gewählt.");
                anzeigen(kistenArray);
                break;

            case 'E':
            case 'e':
                System.out.println("\n Sie haben Daten aller Kisten anzeigen gewählt.");
                listenFunktion(kistenArray);
                break;

            }
        }
        while(true);   
    }[/CODE]


----------



## kneitzel (7. Okt 2021)

Ja, und was ist jetzt das genaue Problem? Kannst Du Kisten eingeben und diese dann anzeigen?


----------



## thor_norsk (7. Okt 2021)

nein , meine Eingabe wiederholt sich immer wieder. Also wenn ich zum Beispiel A wähle, dann tippe ich Alles ein und sobald ich mit der Eingabe fertig bin, dann wird die Eingabe erneuert wiederholt.


----------



## thor_norsk (7. Okt 2021)

Im Internet hat jemand gleiches Problem wie ich. Ich habe etwas gefunden, allerdings verstehe nicht wie ich es umsetzen soll ???

[CODE lang="java" title="Lagerverwaltung"]boolean run = true;
while(run) { /** do it  */
//...
case 'e':
run = false;
break;
}[/CODE]


----------



## thor_norsk (7. Okt 2021)

Mit do {} while(); Schleife verstehe das Prinzip. Allerdings habe ich noch mit Switch kombiniert. Ich werde Jetzt den Code ausprobieren.

[CODE lang="java" title="Lagerverwaltung"]boolean run = true;
while(run) {
switch(wahl) {

            case 'A':
            case 'a':
                System.out.println("\n Sie haben Eingabe einer neuen Kiste gewählt.");
                eingabe(kistenArray);
                run = false;
                break;

            case 'B':
            case 'b':
                System.out.println("\n Sie haben Löschen einer Kiste ausgewählt.");
                loeschen(kistenArray);
                run = false;
                break;

            case 'C':
            case 'c':
                System.out.println("\n Sie haben Ändern einer Kiste ausgewählt.");
                aendern(kistenArray);
                run = false;
                break;

            case 'D':
            case 'd':
                System.out.println("\n Sie haben Daten einer Kiste anzeigen gewählt.");
                anzeigen(kistenArray);
                run = false;
                break;

            case 'E':
            case 'e':
                System.out.println("\n Sie haben Daten aller Kisten anzeigen gewählt.");
                listenFunktion(kistenArray);
                run = false;
                break;
}[/CODE]


----------



## kneitzel (7. Okt 2021)

Nein, das ist nicht das Problem.

Schau Dir Deinen Code an:
- wo liest Du die EIngabe vom User?
- Was umfasst Deine Schleife?

An der Stelle auch noch einmal den Tipp, den ich regelmäßig gebe:
Unterteile es in mehr Methoden! Gerade am Anfang hat man nun einmal Probleme, längere Codes zu überblicken und den Ablauf auf Anhieb zu erkennen. Daher ist es existenziell, Code immer möglichst kurz und einfach zu halten. (Etwas, das auch erfahrene Software Entwickler machen!)


----------



## thor_norsk (7. Okt 2021)

Über die Methode ,, static void eingabe(int [][] argEingabe)'' werden die Werte eingegeben und in Arrays gespeichert.
Die Schleife ist sinnlos, da immer true ist, und somit wird eine endlose Schleife erzeugt!


----------



## Jw456 (7. Okt 2021)

Endlos Schleife ja richtig. Deshalb sagte dir ja kneitzel auch gleich das du einen menue punk zum beenden deines Programms und somit auch der Schleife hinzufügen sollst. 
Der dann das System.exit  aufruft. 
Zb der Buchstabe q wie quit. 
Der dann auch in dein case mit dem exit ist.


----------



## kneitzel (7. Okt 2021)

Nicht die Eingabe von Arrays. Es geht um die Eingabe für die Menuauswahl!

Und der Fehlende Punkt zum Beenden ist erst einmal egal!


----------



## Jw456 (7. Okt 2021)

Seine do while Variante war besser. 
Da hatte er die User Eingabe in der Schleife. Nur kein sinnvolles beenden der Schleife.


----------



## kneitzel (7. Okt 2021)

Ich zeige Dir einmal auf, wie der Code aussehen würde, wenn Du ihn mehr in Methoden unterteilst:


```
wahl = getMenuAuswahl();
while (true) {
    verarbeiteAuswahl(wahl);
}
```

Wird hier das Problem deutlich?

Ich habe ja immer wieder gerne Beispiele wie etwas im echten Leben aussehen würde:
Variablen sind dann Zettel, auf denen etwas steht.

Das wäre dann jetzt etwas wie:
- Du fragst Deine Eltern, was Du für diese machen kannst.
- Die Eltern sagen: Geh und kaufe Butter.
- Das schreibst Du Dir auf einen Zettel
- Nun machst Du ein einer Endlosschleife:
--> Du schaust auf den Zettel: Butter kaufen -> also ab, Butter wird gekauft

Und Deine Eltern freuen sich, denn Du machst den Ganzen Tag ja, was Deine Eltern wollten. Ok, irgendwann ist alle Butter in der Umgebung aufgekauft, aber egal ...


----------



## thor_norsk (7. Okt 2021)

Normale Weise müsste ich System.exit(0); noch am Ende der Switch / Case einbauen.


----------



## kneitzel (7. Okt 2021)

Jw456 hat gesagt.:


> Seine do while Variante war besser.
> Da hatte er die User Eingabe in der Schleife. Nur kein sinnvolles beenden der Schleife.


Das sind doch alles Feinheiten, die egal sind. Wenn es auf ein System.exit Aufruf hinaus laufen sollte, dann spielt es keine Rolle, denn dann hat er ein while(true) und da ist es efal ob while oder do/while.


----------



## kneitzel (7. Okt 2021)

thor_norsk hat gesagt.:


> Normale Weise müsste ich System.exit(0); noch am Ende der Switch / Case einbauen.


NEIN!

Du solltest dich erst einmal hinsetzen und in Worten formulieren, was das Programm machen soll.


----------



## Jw456 (7. Okt 2021)

Neu


thor_norsk hat gesagt.:


> Normale Weise müsste ich System.exit(0); noch am Ende der Switch / Case einbauen.


Nein das muß ein eigener Menü pukt mit case sein


----------



## Jw456 (7. Okt 2021)

kneitzel hat gesagt.:


> Das sind doch alles Feinheiten, die egal sind. Wenn es auf ein System.exit Aufruf hinaus laufen sollte, dann spielt es keine Rolle, denn dann hat er ein while(true) und da ist es efal ob while oder do/while.


Da geht es wie du selber sagtest um die User Eingabe die in die Schleife gehört. Die er da hatte. 
Nicht um das Thema do oder nicht do. 
Das war nicht das Thema.


----------



## kneitzel (7. Okt 2021)

Jw456 hat gesagt.:


> Da geht es wie du selber sagtest um die User Eingabe die in die Schleife gehört. Die er da hatte.
> Nicht um das Thema do oder nicht do.
> Das war nicht das Thema.


Ok, da hatte ich Dich missverstanden, sorry.


----------



## thor_norsk (7. Okt 2021)

Für jeden Mist findet man im Internet Musterlösung aber nicht für diese Aufgabe. Habe paar Übungsbücher bestellt mit Musterlösung.
Außerdem muss ich mich an die Aufgabestellung richten


----------



## kneitzel (7. Okt 2021)

Dann einfach noch einmal ganz ausführlich:

Ursprüngliches Problem: Du hattest keine Schleife. Bei jedem Aufruf hast Du mit einem leeren Array dagestanden. Die main erstellt halt das Leere Array:
`int [][] kistenArray = new int [95][4];`

Du hast in Deinem Programm zwei Teile, die ursprünglich nacheinander ausgeführt wurden:
a) Die Eingabe einer Auswahl, das ist dann etwas wie:

```
// Einige System.out.println
            einlesen = JOptionPane.showInputDialog("Wählen Sie eine Funktion");
            wahl = einlesen.charAt(0);
```
Da hast Du dann eine Eingabe in wahl bekommen.

b) die Verarbeitung der Auswahl:

```
switch(wahl) {
        // ...
}
```

In #20 hattest Du aber jetzt die Schleife nur um die Verarbeitung gemacht, d.h. der Anwender hat einmal eine Auswahl eingegeben und diese wurde dann ständig verarbeitet.

Aber die erneute Eingabe wird doch auch immer wieder benötigt, d.h. die Schleife muss auch die Eingabe mit umfassen.

Das hattest Du in #16 bereits richtig gehabt. Und ja - das ist eine Endlosschleife. Aber das liegt einfach, dass Du dem Benutzer keine Möglichkeit gibst, das Programm zu beenden.

Daher der Hinweis, dass Du da einfach eben eine solche Möglichkeit einbauen sollst.

Wenn dies von der Aufgabe nicht vorgesehen ist, dann musst Du uns die genaue Aufgabe zeigen. Denn noch kennen wir diese nicht.


----------



## Jw456 (7. Okt 2021)

Irgent eine Lösung zum beenden deines Programms muss in der Aufgabenstellung vorhanden sein.


----------



## Jw456 (7. Okt 2021)

Wenn du dir diesen Thread anschaust was deinr Aufgabe entspricht. Siehst du das sie da auch schon von Anfang an einen Menuepunkt zu beenden hat. "Q" beenden.



			https://www.java-forum.org/thema/lagerverwaltung-erstellen-mehrdimensionale-arrays.192721/
		


Nur ist da im ersten post noch keine Action beim beenden vorhaben aber du weißt ja jetzt wie du aus der Schleife raus kommst und dein Programm beendet.

Wo ist nun dein Problem?


----------



## thor_norsk (8. Okt 2021)

Zuerst möchte ich mich bedanken für eure Unterstützung. Habe mein Programm bis auf ,,C'' korrigiert und getestet. Werde jetzt versuchen letzter Puzzle Teil auch zu lösen, wenn nicht melde mich am Sonntag, da ich bis Sonntag arbeiten muss. Werde auch wenn erwünscht meine Fortschritte am Sonntag Nachmittag präsentieren. Nochmals vielen Dank und wünsche euch schönes Wochenende.


----------



## slipkorn (21. Okt 2021)

Hallo zusammen,
bevor ich jetzt auch schon wieder ein neues "KistenThema" erstelle pack ich das einfach mal hier mit rein. In der Hoffnung nicht zu sehr damit zu nerven.

Ich habe natürlich die Selbe Aufgabenstellung und irgendwie auch nahezu die selben Probleme.
(Offensichtlich ein gängiges Thema bei uns "Neueinsteigern") 

Bedeutet beim Löschen einer Kiste werden lediglich die Inhalte entfernt...der Index bleibt jedoch erhalten.
Warum finde ich meinen Fehler nicht?

Des weiteren scheint die Anzeige aller Kisten grundsätzlich zu funktionieren...allerdings wird mir immer nur eine der gespeicherten Kisten angezeigt. (das Muster dieses "bugs" erschließt sich mir auch nicht recht)

Wunderschön wäre es natürlich auch noch wenn ich bei der Ausgabe der Kisten den Index "ausblenden/auslassen" könnte.
Nach meinem Verständnis wäre das mit einer for-each schleife machbar....leider seh ich mich noch nicht in der lage das für meinen fall zu adaptieren.

Ich bedanke mich im vor raus für Denkanstöße und/oder Hilfestellungen.


[CODE lang="java" title="Lagerverwaltung"]public class Lagerverwaltung {

    // Neue Kiste

    static void eingabe(int[][] Eingabe) {

        int nummer;
        int breite, laenge, hoehe;

        // Kistennummer eingeben
        do {
            nummer = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie bitte eine Kistennummer ein (1 -75)"));

            // Wenn Kistennummer gültig und noch nicht vergeben
            if (nummer > 0 && nummer <= Eingabe.length)
                if (Eingabe[nummer - 1][0] == 0) {

                    // Nummer der Kiste zuweisen
                    Eingabe[nummer - 1][0] = nummer;

                    // Werte Einlesen
                    breite = Integer.parseInt(JOptionPane.showInputDialog("Kistenbreite"));
                    Eingabe[nummer - 1][1] = breite;

                    laenge = Integer.parseInt(JOptionPane.showInputDialog("Kistenlänge"));
                    Eingabe[nummer - 1][2] = laenge;

                    hoehe = Integer.parseInt(JOptionPane.showInputDialog("Kistenhöhe"));
                    Eingabe[nummer - 1][3] = hoehe;

                }

                else {
                    System.out.println("\nDie Kiste " + nummer + " ist ungültig oder schon vergeben");
                }
        } while (nummer <= 0 || nummer > Eingabe.length);

    }

    // Kiste Löschen

    static void loeschen(int[][] Loeschen) {

        int nummer;

        // Kistennummer eingeben
        do {
            nummer = Integer.parseInt(JOptionPane.showInputDialog("Welche Kiste möchten Sie löschen?"));

            // Kontrolle ob die eingegebene Kistennummer einer bereits gespeicherten Kiste entspricht
            if (nummer > 0 && nummer <= Loeschen.length)
                if (Loeschen[nummer - 1][0] == nummer) {

                    Loeschen[0] [0] = nummer;
                }
                else {
                    System.out.println("\nDie Kiste " + nummer + " ist nicht bekannt und kann somit nicht gelöscht werden.");
                }
        } while (nummer <= 0 || nummer > Loeschen.length);
    }

    // Kiste ändern

    static void aendern(int[][] Aendern) {

        int nummer;
        int breite, laenge, hoehe;

        // Kistennummer eingeben
        do {
            nummer = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie bitte eine Kistennummer ein (1 -75)"));

            // Wenn Kistennummer gültig und noch nicht vergeben
            if (nummer > 0 && nummer <= Aendern.length)
                if (Aendern[nummer - 1][0] != 0) {

                    // Werte Einlesen
                    breite = Integer.parseInt(JOptionPane.showInputDialog("Kistenbreite"));
                    Aendern[nummer - 1][1] = breite;

                    laenge = Integer.parseInt(JOptionPane.showInputDialog("Kistenlänge"));
                    Aendern[nummer - 1][2] = laenge;

                    hoehe = Integer.parseInt(JOptionPane.showInputDialog("Kistenhöhe"));
                    Aendern[nummer - 1][3] = hoehe;

                }

                else {
                    System.out.println("\nDie Kiste " + nummer +" ist ungültig oder noch nicht vergeben");
                }
        } while (nummer <= 0 || nummer > Aendern.length);

    }

    // Anzeigen einer Kiste
    static void anzeigen(int[][] Anzeigen) {
        int nummer;
        nummer = Integer.parseInt(JOptionPane.showInputDialog("Welche Kiste möchten Sie anzeigen?"));
        for (int i = 0; i < Anzeigen.length; i++) {
            if (nummer > 0 && nummer <= Anzeigen.length && Anzeigen_[0] == nummer) {
                System.out.println("\nDie Daten der Kiste sind:\t" + Arrays.toString(Anzeigen));
                return;
            }
        }
        System.out.println("\nDie Kiste " + nummer + " ist nicht bekannt");
    }

    //    Anzeigen aller Kisten
        static void alleKisten (int[][] AlleKisten) {
            for(int i = 0; i < AlleKisten.length; i++) {
                if(AlleKisten[0] == 0) {
                    continue;}
                {               
            System.out.print("\nKiste Nr" +(i+1)+":\t"+Arrays.toString(AlleKisten));       

                    }         
        return;
        }
        }

    public static void main(String[] args) {

        // Vereinbarung des Arrays
        int[][] kistenArray = new int[75][4];

        // Auswahl der Funktion

        String Einlesen;

        int funktion;

        System.out.println("Folgende Funktionen stehen Ihnen zur Auswahl: \n");
        System.out.println("1 \t Eingabe einer neuen Kiste");
        System.out.println("2 \t Löschen einer Kiste");
        System.out.println("3 \t Ändern einer Kiste");
        System.out.println("4 \t Daten einer Kiste anzeigen");
        System.out.println("5 \t Daten aller Kisten anzeigen");
        System.out.println("0 \t Programm beenden");


        // Auswahl auswerten

        boolean abbruch =false;
        while (abbruch == false) {

        Einlesen = JOptionPane.showInputDialog("Wählen Sie eine Funktion");
        funktion = Einlesen.charAt(0);
        switch (funktion) {       

        case '1':
            System.out.println("\nSie haben Eingabe einer neuen Kiste gewählt");
            eingabe(kistenArray);
            break;

        case '2':
            System.out.println("\nSie haben Löschen einer Kiste gewählt");
            loeschen(kistenArray);
            break;

        case '3':
            System.out.println("\nSie haben Ändern einer Kiste gewählt");
            aendern(kistenArray);
            break;

        case '4':
            System.out.println("\nSie haben Daten einer Kiste anzeigen gewählt");
            anzeigen(kistenArray);;
            break;

        case '5':
            System.out.println("\nDie Werte aller Kisten sind:");
            alleKisten(kistenArray);
            break;
        case '0':
            abbruch = true;
            System.out.println("\nSie haben das Programm beendet.");
            break;
        }
        }

        System.exit(0);
    }

}
[/CODE]_


----------



## kneitzel (21. Okt 2021)

Bitte beschreibe doch erst einmal exakt in Worten, was Du da genau machen willst beim Löschen.

Evtl. hilft es Dir auch, wenn Du erst einmal die Datenstruktur erläuterst: Was speichert du wie und was für eine Bedeutung soll es haben?

Am Anfang steht und fällt alles mit genau diesem Verständnis! Mal es Dir zur Not auf einen Zettel auf um es bildlich zu sehen. Das zweidimensionale Array ist dann eine Tabelle mit Zeilen und Spalten. Und dann spiel genau durch, was Du beim Eintragen und Löschen machen willst. 

Und auch die Methode anzeigen hat einen Fehler! Das solltest Du also auch einmal prüfen. Aber ich denke, Du solltest erst einmal dieses Durchspielen machen, ehe wir auf konkrete Fehler in Deinem Code zu sprechen kommen.


----------



## mihe7 (21. Okt 2021)

slipkorn hat gesagt.:


> Bedeutet beim Löschen einer Kiste werden lediglich die Inhalte entfernt...der Index bleibt jedoch erhalten.


Das ist eine Möglichkeit. Stell Dir einfach ein Regal mit n Fächern vor, die man natürlich durchnummerieren kann - wir fangen, wie es sich gehört, bei 0 an. Die Fächer bilden Dein Array der Größe n. Und jetzt kannst Du ein beliebiges Fach mit Inhalt füllen oder es auch leeren. "Löschen" kann nun z. B. einfach nur leeren des Fachs bedeuten oder z. B. auch, dass die dadurch entstehende Lücke dahingehend geschlossen wird, dass die Inhalte der folgenden Fächer nach vorne geschoben werden.



slipkorn hat gesagt.:


> Des weiteren scheint die Anzeige aller Kisten grundsätzlich zu funktionieren...allerdings wird mir immer nur eine der gespeicherten Kisten angezeigt. (das Muster dieses "bugs" erschließt sich mir auch nicht recht)


Formatiere mal Deinen Code richtig, dann wirst Du den Bug gleich sehen


----------



## slipkorn (21. Okt 2021)

Vielen Dank für die Antworten.

Ich möchte in dem Array bis zu 75 "Kisten" speichern.
Diese haben jeweils einen Wert für breite, laenge und hoehe.
Also

Kisten Nr.breitelaengehoehe1121365220101534020604104035
usw...

Beim löschen möchte ich grundsätzlich Diese werte wieder auf "0" setzen (also das Entsprechende Fach leeren)....das klappt für breite, laenge und hoehe auch...leider bleibt jedoch die Kisten Nr, gespeichert und somit weiterhin als Eintrag im Array bestehen.
Ich bin irgendwie zu Bräsig eben den Ersten Wert (Index?!) anzufassen.

Ein Fehler in der Methode anzeigen() fällt mir tatsächlich (noch) nicht auf .



> mihe7 hat gesagt.:
> 
> 
> > Formatiere mal Deinen Code richtig, dann wirst Du den Bug gleich sehen
> ...


Ich bastel bereits jetzt den Dritten Tag an dieser vermeintlich lächerlichen Aufgabe und sehe hoffentlich einfach nur den Wald vor lauter Bäumen nicht...


----------



## Jw456 (21. Okt 2021)

Die Aufgabe sagt eigentlich das du nur die Kisten NR auf 0 setzen musst.


Loeschen[nummer-1] [0] = 0;

Loeschen die este Klammer ist die Schubblade  von (0-74) die zweite das Fach von (0-3)


----------



## kneitzel (21. Okt 2021)

Also Du solltest das wirklich viel mehr durchspielen. Du hast also eine Tabelle - da kann man die Indices dranschreiben und am Anfang ist alles auf 0.

Dann trägst Du bei Feld (nummer-1)[0] die Nummer ein .. und noch ein bisschen mehr das jetzt nicht interessiert...

Dann beim Löschen:
Schaust Du, ob in Feld (nummer-1)(0) die Nummer drin steht. Wenn das der Fall ist, dann trägst Du die Nummer der zu löschenden Kiste bei der allerersten Kiste ein:


```
if (Loeschen[nummer - 1][0] == nummer) {
                    Loeschen[0][0] = nummer;
                }
```

In welchem Feld willst Du denn was eintragen? ==> Daher durchspielen, damit Dir sowas wirklich bewusst wird. Du trägst beim Löschen die nummer der Kiste doch nirgends ein! Du radierst die Nummer der Kiste aus und trägst doch wieder eine 0 ein!


----------



## kneitzel (21. Okt 2021)

Dann bezüglich Anzeigen:
a) Angenommen, du zählst von 1 bis 10 -> Macht es dann Sinn zu prüfen, ob die Zahl kleiner 1 oder größer 10 ist? Das kann doch nie eintreten!
Und sollte die Grenze nicht ganz stimmig sein, dann kannst du ja die for Schleife anpassen. (Wobei die Schleife ok ist, aber die unnötige Prüfung ist schlicht falsch) ==> Da hilft aus meiner Sicht wirklich, den besseren Überblick zu bekommen, also auf dem Zettel die Indices mit notieren um dann so auch ein Gefühl bezüglich der Indices zu bekommen. Das ist nun einmal Übung und die könnte man durch so Übungen bekommen....

b) Schau an, was Du machst, wenn eine erste Kiste gefunden wurde: Du gibst diese aus und was machst Du dann?

```
if (nummer > 0 && nummer <= Anzeigen.length && Anzeigen[i][0] == nummer) {
                System.out.println("\nDie Daten der Kiste sind:\t" + Arrays.toString(Anzeigen[i]));
                return;
            }
```


----------



## mihe7 (21. Okt 2021)

slipkorn hat gesagt.:


> Ich bastel bereits jetzt den Dritten Tag an dieser vermeintlich lächerlichen Aufgabe und sehe hoffentlich einfach nur den Wald vor lauter Bäumen nicht...


Das return steht bei Dir in der Schleife.


----------



## slipkorn (21. Okt 2021)

mihe7 hat gesagt.:


> Das return steht bei Dir in der Schleife.


😂 tatsache...was so eine klammer an der falschen stelle alles auslösen kann.



kneitzel hat gesagt.:


> Dann bezüglich Anzeigen:
> a) Angenommen, du zählst von 1 bis 10 -> Macht es dann Sinn zu prüfen, ob die Zahl kleiner 1 oder größer 10 ist? Das kann doch nie eintreten!
> Und sollte die Grenze nicht ganz stimmig sein, dann kannst du ja die for Schleife anpassen. (Wobei die Schleife ok ist, aber die unnötige Prüfung ist schlicht falsch) ==> Da hilft aus meiner Sicht wirklich, den besseren Überblick zu bekommen, also auf dem Zettel die Indices mit notieren um dann so auch ein Gefühl bezüglich der Indices zu bekommen. Das ist nun einmal Übung und die könnte man durch so Übungen bekommen....


Das ist wirklich absolut überflüssig...Die Abfrage habe ich rausgeworfen.
Rein zum Verständnis: Es war falsch weil einfach nur überflüssig oder kann sowas auch zu ernsthaften Problemen führen?



Jw456 hat gesagt.:


> Die Aufgabe sagt eigentlich das du nur die Kisten NR auf 0 setzen musst.
> 
> 
> Loeschen[nummer-1] [0] = 0;
> ...


Ich hatte irgendwie den Ansporn alles "Löschen" zu wollen...und mich dabei wohl stark verrannt.


Ihr drei habt mir auf jeden fall in ein Paar Minuten sehr weiter geholfen.
Der Code macht jetzt das was er Soll und ich hab schon wieder was gelernt.
Den Zetteltrick bzw. das Intensive durchspielen werde ich in Zukunft beherzigen.

Vielen lieben Dank für eure Geduld und Top Tipps.


----------



## kneitzel (21. Okt 2021)

slipkorn hat gesagt.:


> Rein zum Verständnis: Es war falsch weil einfach nur überflüssig oder kann sowas auch zu ernsthaften Problemen führen?


Ok, ich sehe gerade, dass ich den Code nicht gut genug gelesen hatte. Ich hatte nicht gesehen, dass Du erst eine anzuzeigende Nummer abfragst und dann in die Schleife über alle Kisten gehst. Die Schleifenvariable bei dir war i und die Variable nummer war die eingegebene Nummer.

Ich hatte zuerst gelesen, dass Du die Schleifenvariable erneut geprüft hättest und das wäre dann falsch gewesen, denn die Schleife würde von 0 bis length-1 laufen und Dein Check aber auf 1 ... length prüfen (die Kiste mit index 0 wäre dann nicht angezeigt worden).

Somit war meine Aussage so natürlich nicht ganz korrekt - sorry dafür.

Du hast da zwei Lösung in eine gepackt: Du fragst nach einer Kiste aber läufst dennoch in einer Schleife durch alle Kisten durch. Da Du ja nur eine Kiste anzeigen lassen willst und Du auch weisst, wo die Kiste sein muss, kannst Du die ohne Schleife direkt anzeigen.
Die for Schleife kann also ganz weg, die Prüfung der Grenzen muss genau so bleiben, wie es war und lediglich das i musst Du ersetzen mit dem index der Kiste mit Nummer number. (Die Umwandlung sollte ja klar sein - hattest Du ja schon an mehreren Stellen.)


----------



## Jw456 (21. Okt 2021)

kneitzel hat gesagt.:


> Du hast da zwei Lösung in eine gepackt: Du fragst nach einer Kiste aber läufst dennoch in einer Schleife durch alle Kisten durch. Da Du ja nur eine Kiste anzeigen lassen willst und Du auch weisst, wo die Kiste sein muss, kannst Du die ohne Schleife direkt anzeigen.
> Die for Schleife kann also ganz weg, die Prüfung der Grenzen muss genau so bleiben, wie es war und lediglich das i musst Du ersetzen mit dem index der Kiste mit Nummer number. (Die Umwandlung sollte ja klar sein - hattest Du ja schon an mehreren Stellen.)


richtig aber nummer-1 sonnst hast du die falsche Kiste.

System.out.println("\nDie Daten der Kiste sind:\t" + Arrays.toString(Anzeigen[nummer-1]));


----------



## kneitzel (21. Okt 2021)

Deshalb habe ich doch klar gesagt: "das i musst Du ersetzen mit dem index der Kiste mit Nummer number." zusammen mit dem Hinweis auf eine "Umwandlung".


----------



## cocosch (1. Mai 2022)

Hallo,
Also ich habe das gleiche Problem wie die meisten die mit dieser Aufgabe zu kämpfen haben.
Ich habe meinen Code geändert, aber ich kann einen Kiste nicht aufrufen, mir wird immer angezeigt, das die Kiste nicht bekannt ist.
Ich kann eine neue Kiste eingeben, auch die breite, länge und höhe, aber ich kann sie dann nicht aufrufen oder bzw., findet das Programm die Kiste nicht oder ist nicht bekannt. 

```
public class Lagerverwaltung {

    //EINGABE EINE NEUEN KISTE
    
      static void eingabe(int[][]Eingabe){

            int nummer;
            int  breite, laenge, hoehe;
            
          //Kistennummer eingeben
          do {
           nummer=Integer.parseInt(JOptionPane.showInputDialog("Geben Sie bitte eine Kistennummer ein (1 -75)"));
                
           //Wenn Kistennummer gültig und noch nicht vergeben
           if(nummer > 0 && nummer <= Eingabe.length)
            if(Eingabe[nummer - 1][0] == 0){
                      
            //Nummer der Kiste zuweisen
           Eingabe[nummer-1][0]=nummer;
                        
           //Werte Einlesen
            breite=Integer.parseInt(JOptionPane.showInputDialog("Kistenbreite"));
            Eingabe[nummer-1][1]=breite;
                        
            laenge=Integer.parseInt(JOptionPane.showInputDialog("Kistenlaenge"));
            Eingabe[nummer-1][2]=laenge;
                        
             hoehe=Integer.parseInt(JOptionPane.showInputDialog("Kistenhoehe"));
             Eingabe[nummer-1][3]=hoehe;                   
                      
             }
                    
              else {
              System.out.println("\nDie Kistennummer ist ungültig oder schon vergeben");
             }
         }
            while(nummer <=0 || nummer > Eingabe.length);
                  
      }
        
      //LÖSCHEN EINER KISTE   
      static void loeschen(int[][] Loeschen) {
          
      int nummer;
      
      //Kistennummer eingeben
        do {
        nummer=Integer.parseInt(JOptionPane.showInputDialog("Geben Sie bitte die zu löschende Kistennummer ein"));
            
         //Kontrolle ob die eingegebene Kistnnummer einer bereits gespeicherten Kiste entspricht
        if(nummer > 0 && nummer <= Loeschen.length)
         if(Loeschen[nummer-1][0] == nummer){               
          Loeschen[0] [0] = 0;             
        }           
          else {
          System.out.println("\nDie Kistennummer " + nummer + " ist nicht bekannt");
           }
        }
            while(nummer <= 0 || nummer > Loeschen.length); 
            }
                                  
      //ÄNDERN EINER KISTE   
      static void aendern(int[][] Aendern) {
    
            int nummer;
            int breite, laenge, hoehe;
            
             //Kistennummer eingeben
            do {
             nummer = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie bitte eine Kistennummer ein (1 -75)"));
                
             //Wenn Kistennummer gültig und noch nicht vergeben
             if(nummer > 0 && nummer <= Aendern.length)
             if(Aendern[nummer-1][0] != 0){
        
            //Werte Einlesen
           breite=Integer.parseInt(JOptionPane.showInputDialog("Kistenbreite"));
           Aendern[nummer-1][1]=breite;
                        
           laenge=Integer.parseInt(JOptionPane.showInputDialog("Kistenlaenge"));
           Aendern[nummer-1][2]=laenge;
                        
           hoehe=Integer.parseInt(JOptionPane.showInputDialog("Kistenhoehe"));
           Aendern[nummer-1][3]=hoehe;
                        
             }
              else {
              System.out.println("\nDie Kistennummer ist ungültig oder noch nicht vergeben");
              }             
            }   
            
            while(nummer<=0 || nummer > Aendern.length);       
    }
    
    //ANZEIGEN EINER KISTE   
     static void anzeigen(int[][] Anzeigen){
            int nummer;
            nummer=Integer.parseInt(JOptionPane.showInputDialog("Geben Sie eine vorhandene Kistennummer ein"));
            for(int i = 0; i < Anzeigen.length; i++){
             if(nummer > 0 && nummer <= Anzeigen.length && Anzeigen[i][0] == nummer){
             System.out.println("\nDie Daten der Kiste sind t:\t"+ Arrays.toString(Anzeigen[i]));
             return;
                }
            }
            System.out.println("\n Die Kistennummer " + nummer + " ist nicht bekannt");
              
        }
    
    // Anzeigen aller Kisten
     static void alleKisten (int[][] AlleKisten) {
          for(int i = 0; i < AlleKisten.length; i++) {
          if(AlleKisten[0][0] == 0) {
           continue;}
     {
     System.out.print("\nKiste Nr" + (i+1) +":\t" + Arrays.toString(AlleKisten));

     }
    
     }
     }
    
    public static void main(String[] args) {
        
        //Vereinbarung des Arrays
        int[][] kistenArray = new int[75][4];
        
        //Auswahl der Funktion
        
        String funktionEinlesen;
        
        char funktion;
        
        System.out.println("Folgende Funktionen stehen Ihnen zur Auswahl: \n");
        System.out.println("A \t Eingabe einer neuen Kiste");
        System.out.println("B \t Löschen einer Kiste");
        System.out.println("C \t Ändern einer Kiste");
        System.out.println("D \t Daten einer Kiste anzeigen");
        System.out.println("E \t Daten aller Kisten anzeigen");
        
        funktionEinlesen=JOptionPane.showInputDialog("Wählen Sie eine Funktion");
        funktion = funktionEinlesen.charAt(0);
        
      //Auswahl auswerten       
        switch(funktion) {
        
        case 'a':
        case 'A':
            System.out.println("\nSie haben Eingabe einer neuen Kiste gewählt");
            eingabe(kistenArray);
            break;
            
        case 'b':
        case 'B':
            System.out.println("\nSie haben Löschen einer Kiste gewählt");
            loeschen(kistenArray);
            break;
        
        case 'c':
        case 'C':
            System.out.println("\nSie haben Ändern einer Kiste gewählt");
            aendern(kistenArray);
            break;
        
        case 'd':
        case 'D':
            System.out.println("\nSie haben Daten einer Kiste anzeigen gewählt");
            anzeigen(kistenArray);
            break;
    
        }
                                                
        System.exit(0);
    }

}
```


----------



## cocosch (1. Mai 2022)




----------



## KonradN (1. Mai 2022)

Du musst mit den Indices aufpassen - wo greifst Du denn immer zu?

Beispiel:

```
if(Loeschen[nummer-1][0] == nummer){               
          Loeschen[0] [0] = 0;             
        }
```

Wenn also im Array an Platz nummer-1 etwas gespeichert ist, dann löschst Du die Kiste an Platz 0?

Ist natürlich bei anzeigen ähnlich. Wenn die erste Kiste (Platz 0) nicht gesetzt ist, dann zeigt er gar nichts an. Und wenn da eine Kiste sein sollte, dann wird er vermutlich nur Müll ausgeben.

Daher wäre aus meiern Sicht wichtig:
a) Den Algorithmus immer genau überlegen. Dazu ist eine Formulierung in einer gut verständlichen Sprache gut.
b) Dann den Algorithmus mit guten Bezeichnern schreiben.

- Variablen fangen mit kleinen Buchstaben an.
- Sinnvolle Namen vergeben! Wird bei eingabe eine Eingabe übergeben? Das ist doch der Kistenstapel und keine Eingabe!


----------



## mihe7 (1. Mai 2022)

@cocosch, es geht ja vermutlich um den folgenden Code:

```
static void anzeigen(int[][] Anzeigen){
            int nummer;
            nummer=Integer.parseInt(JOptionPane.showInputDialog("Geben Sie eine vorhandene Kistennummer ein"));
            for(int i = 0; i < Anzeigen.length; i++){
             if(nummer > 0 && nummer <= Anzeigen.length && Anzeigen[i][0] == nummer){
             System.out.println("\nDie Daten der Kiste sind t:\t"+ Arrays.toString(Anzeigen[i]));
             return;
                }
            }
            System.out.println("\n Die Kistennummer " + nummer + " ist nicht bekannt");
              
        }
```
Der ist natürlich totaler Quatsch, denn Du willst hier eine bestimmte Kiste anzeigen, nämlich die mit der eingegebenen Kistennummer. Was willst Du da mit einer Schleife?

Mach die Schleife raus, überleg Dir, wann die Eingabe gültig ist (steht ja schon im Code) und dann zeigst Du einfach eine entsprechende Ausgabe an.


----------



## JohnnyNa (8. Sep 2022)

Ich habe tatsächlich bei meiner Lösungsvariante auch eine schleife und sogar zusätzlich noch ein try catch statement verwendet.



```
private static void anzeigen(int[][] argArray) {
        int kistenId;
        kistenId = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie eine vorhandene Kisten-ID ein: "));
       
        try {
        for(int i = 0; i <= argArray.length; i++) {
            if (kistenId > 0 && kistenId <= argArray.length && argArray[i][0] == kistenId) {
                System.out.println("Die Maße der Kiste " + kistenId + " ist " + Arrays.toString(argArray[i]));
                return;
            }
               
        }  
        }catch (Exception e) {
            System.out.println("Die gewaehlte ID ist noch nicht vergeben.");
        }
    }
```

es erfüllt seinen zweck insofern, als dass das entsprechende array nur angezeigt werden kann, wenn es auch vorhanden ist. Das catch hilft dabei die exception Meldung zu verarbeiten, so kann auch wenn man anzeigen lässt und die kistenID noch nicht vergeben ist, weiter machen ohne dass das Programm abstürzt. Allerdings ist meine Lösung offensichtlich unnötig und sinnlos, wenn ich @mihe7 richtig verstehe?


----------



## mihe7 (11. Sep 2022)

JohnnyNa hat gesagt.:


> Allerdings ist meine Lösung offensichtlich unnötig und sinnlos, wenn ich @mihe7 richtig verstehe?


Das kommt darauf an, wie der Rest des Codes aussieht. Wenn sich die Kistennummer auf den Index eindeutig abbilden lässt, dann muss man natürlich nicht über eine Schleife die richtige Kiste raussuchen.

Die Aufgabe taucht hier nicht das erste Mal auf und soweit ich mich entsinne, sollten immer n Kisten mit den Nummern 1 bis n in einem Array der Länge n verwaltet werden, d. h. der Index ist einfach die Kistennummer - 1. Ist die Kistennummer aber unabhängig davon, musst Du natürlich mit Hilfe einer Schleife (besser wäre natürlich eine geeignete Datenstruktur wie z. B. eine Map) die richtige Kiste raussuchen.


----------

