# Schleifen



## Captain_Blaubär (25. Jan 2021)

Hallo liebe Community,

Meine Aufgabe ist es ein kleines Programm, das ein Menü simuliert, zu programmieren. Dabei sollen folgende Funktionen benutzt werden:

Name eingeben
Name löschen
Name ausgeben
Programm beenden (System.exit(0); beendet das Programm)
Leider komme ich nicht wirklich weiter, weshalb ich um eure Hilfe bitten muss. 

Vielen Dank


----------



## mihe7 (26. Jan 2021)

Was hast Du bisher als Code? Wobei kommst Du nicht weiter?


----------



## Captain_Blaubär (28. Jan 2021)

Das ist jetzt mein Ansatz:

import java.util.Scanner;

    public class Men {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            String name = "";

            for(int i = 0;i < 100 ; i = i) {


            System.out.println("Hallo! Wähle einen Ounkt aus. ")
            System.out.println("Name eingeben = 1");
            System.out.println("Name ausgeben = 2");
            System.out.println("Name löschen  = 3");
            System.out.println("Verlassen = 4");

                Scanner scn = new Scanner(System.in);

            int eing = scn.nextInt();



ich hätte gerne, dass die Schleife jetzt mit dem Switch Befehl fortgeführt wird, da komme ich leider nicht mehr weiter.
Mit freundlichen Grüßen!


----------



## kneitzel (28. Jan 2021)

Also irgendwie klingt das nicht gut durchdacht. Du hast eine Zählschleife, die nicht zählt? Wenn Du nicht zählen willst, dann nimm doch eine eine while Schleife..


```
boolean sollBeenden = false;
while (!sollBeenden) {
    // Was auch immer ...
}
```

Du hast doch jetzt die Eingabe in der Variablen eing gespeichert. Also ein switch wäre einfach so zu realisieren:

```
switch(eing) {
    case 1:
        // whatever
        break;
        
    case 2:
        // whatever
        break;
        
    case 3:
        // whatever
        break;
        
    case 4:
        // whatever
        break;
        
    default:
        // whatever
}
```


----------



## Lustig-Peter (29. Jan 2021)

Servus Kneitzel, ich kenne mich in dem Thema leider so gar nicht aus, könntest den Switch vielleicht mal in das Script integrieren so wie du das machen würdest damit ich mal eine Vorlage habe.


----------



## Lustig-Peter (29. Jan 2021)

kneitzel hat gesagt.:


> Also irgendwie klingt das nicht gut durchdacht. Du hast eine Zählschleife, die nicht zählt? Wenn Du nicht zählen willst, dann nimm doch eine eine while Schleife..
> 
> 
> ```
> ...


----------



## mihe7 (29. Jan 2021)

Lustig-Peter hat gesagt.:


> Servus Kneitzel, ich kenne mich in dem Thema leider so gar nicht aus, könntest den Switch vielleicht mal in das Script integrieren so wie du das machen würdest damit ich mal eine Vorlage habe.


Du hast doch schon eine Vorlage: die while-Schleife von @kneitzel. Da kannst Du z. B. die Zeilen von @Captain_Blaubär integrieren, die nach der Zeile mit dem for kommen sowie den Switch von @kneitzel. 

Bei case 4 setzt Du einfach sollBeenden auf true.


----------



## kneitzel (29. Jan 2021)

Ich überlege gerade, wo das Verständnisproblem ist. Die Bausteine sind ja in sich relativ einfach und daher sehe ich gerade keinen Ansatzpunkt.

Evtl. hilft es, das man die Problematik besser unterteilt. In Java arbeitet man in der Regel Objektorientiert, aber wir können da erst einmal rein prozedural vorgehen:

Also gehen wir langsam vor:
Das Programm soll in einer Schleife immer wieder etwas machen:

```
public static void main(String[] args) {
    while (true) {
        doSomething();
    }
}
public static void doSomething() {}
```

Heya - ersten Teil abgehakt. Wir haben jetzt im Programm eine Schleife die immer etwas macht. Da ihr wisst, was da gemacht werden soll, solltet ihr doSomething so benennen, dass es etwas sinnvolles ausgibt. doMenuWithAction oder so. Da könnt ihr euch was frei ausdenken.
Die Methode selbst ist noch leer - das ist aber auch ok, denn das ist noch nicht Bestandteil! Da kann man maximal ein Kommentar a.la. "TODO must be filled" oder so rein geschrieben werden.

Nun kommt die nächste Anforderung: Das soll so lange laufen, bis es abgebrochen wird. Der Anwender soll es beenden können. Also brauchen wir ein Ende Flag. Somit ändert sich der Rückgabe-Typ der Methode und wir erhalten:

```
public static void main(String[] args) {
    boolean continue = true
    while (continue) {
        continue = doSomething();
    }
}

public static boolean doSomething() {
    // TODO Content must still be written.
    return false;
}
```

Nun ist die Frage, was soll denn gemacht werden? Es soll etwas eingegeben werden und dann soll etwas passieren:

```
public static void main(String[] args) {
    boolean continue = true
    while (continue) {
        continue = showMenuAndHandleInput();
    }
}

public static boolean showMenuAndHandleInput() {
    int input = showMenuAndGetUserChoice();
    return handleUserInput(input);
}

public static int showMenuAndGetUserChoice() {
    // TODO
    return 0;
}

public boolean handleUserInput(int input) {
    // TODO
    return false;
}
```

So unterteilt ihr die Problematik. Und der Code ist lesbar - so ihr aussagekräftige Namen verwendet.

Und die Frage, wo Code hin gehört, ist auch einfacher zu beantworten. Der Switch Konstrukt soll ja die User-Eingabe auswerten. Also gehört das in handleUserInput:

```
public boolean handleUserInput(int input) {
    switch(input) {
        case 1: return doChoose1();
        case 2: return doChoose2();
        case 3: return doChoose3();
        default:
            printWrongUserChoice();
            return true;
    }
}
```

doChooseX muss natürlich was sinnvolles sein. Also enterName, deleteName, ... Die Methoden bekommen Namen, die klar aussagen, was diese machen!

Das wäre dann eine Aufgliederung, die man als ersten Schritt machen kann, um Daten vernünftig vorzuhalten.

Ich habe jetzt alles static gelassen. Das ist noch extrem unschön, aber wenn man noch nicht objektorientiert arbeitet, dann wäre das ein erster Schritt. Aber auch Objektorientiert bleibt es so. Da muss man ansonsten nur die "Player" identifizieren. Ich sehe eine UI (Also Eingabe/Ausgabe und auch die Hauptschleife), ich sehe die Verwaltung der Namen (neue hinzufügen, löschen, ....) Je nachdem, was die Anforderung ist, kann man das ebenso aufnehmen - aber das generelle Vorgehen ist eine Art Divide and Conquer. Und das ist auch prinzipiell ähnlich bei TDD, nur dass jetzt halt die Tests fehlten


----------



## mihe7 (29. Jan 2021)

kneitzel hat gesagt.:


> continue


Keyword alarm


----------



## kneitzel (29. Jan 2021)

mihe7 hat gesagt.:


> Keyword alarm


Jo, das ist richtig. Da war ich irgendwie auf andere Dinge konzentriert. Ist auch ein blöder Name, denn es sagt nicht so viel aus - also doppelt schlecht. shouldContinue wäre evtl. besser ...


----------



## mihe7 (29. Jan 2021)

Ich mach bei sowas:

```
boolean done = false;
while (!done) {
....
}
```


----------

