12 Okt

For, While, Do-While: Schleifen für die Android-Programmierung

In diesem Post zeige ich euch, wie for-, while- und do-while-Schleifen verwendet werden können. Außerdem erfahrt ihr, worin die Unterschiede und Gemeinsamkeiten dieser drei Loops liegen.

For, While, Do While- Schleifen für die Android-Programmierung

 

 

Die hier gezeigte App hat nur einen Sinn: Die Eigenheiten der Schleifen verdeutlichen. Sie hat, anders als meine anderen Tutorial-Apps, keinen weiteren Mehrwert. 😉

 

Die activity_main.xml der Loop-App

Die activity_main.xml der Loops-App: 7 TextViews.

Die activity_main.xml der Loops-App: 7 TextViews.

Ich habe mich hier für ein absolut simples Layout entschieden: 7 TextViews. Kein Button, kein EditText. (Die Methoden werden alle beim App-Start aufgerufen.) Welche Art von Layout ihr verwendet, ist eigentlich egal. Meine TextViews von oben nach unten:

  • Leeres TextView [tX]: Hier wird später die Zahl der Schleifen-Durchläufe (=x) ausgegeben.
  • Beschriftungs-TextView „For-Loop“.
  • Leeres TextView [tFor]. Für die Ausgabe der For-Schleife.
  • Beschriftungs-TextView „For-Loop“.
  • Leeres TextView [tWhile]. Für die Ausgabe der While-Schleife.
  • Beschriftungs-TextView „Do-While-Loop“.
  • Leeres TextView [tDoWhile]. Für die Ausgabe der Do-While-Schleife.

Wichtig sind eindeutige IDs für die noch leeren Ergebnis-/Ausgabe-TextViews. Das verkürzt die Suchdauer. 😉

 

MainActivity: onCreate

In die onCreate-Methode gehören (nach super.onCreate(savedInstanceState); und setContentView(R.layout.activity_main);) zunächst die folgenden Zeilen:

// Integer x = Durchlaufanzahl der Loops.
Integer x = 5;
// TextView für Ausgabe von x festlegen.
TextView tX = (TextView) findViewById(R.id.tX);
// Wert von x ausgeben.
tX.setText("x="+String.valueOf(x));

Dann werden, für einen besseren Überblick, drei Funktionen aufgerufen:

// Loops aufrufen.
forLoop(x);
whileLoop(x);
doWhileLoop(x);

Die Funktionen müssen wir der App erst noch hinzufügen. Deshalb werden sie von Android Studio rot dargestellt. (Links in der Seitenleiste seht ihr eine rote Glühbirne mit einem Ausrufungszeichen. Klickt erst darauf (oder drückt Alt + Enter) und dann auf „Create method“, um Android Studio das Grundgerüst erstellen zu lassen.)

Nun zum eigentlichen Programmier-Teil – und den Erklärungen. 😉

 

For-Loop

So sieht meine Methode forLoop(x) aus:

private void forLoop(Integer x) {
    // TextView für Ausgabe der For-Schleife festlegen.
    TextView tFor = (TextView) findViewById(R.id.tFor);

    // Zähler, Bedingung, Erhöhung angeben.
    for (int i=0; i<x; i++) {
        // Wert von i an Inhalt des TextViews anhängen.
        tFor.append(String.valueOf(i));
    }
}

Wichtig: „(Integer x)“ in der ersten Zeile bedeutet, dass dieser Funktion beim Aufruf (s.o.) der Wert von „x“ übergeben wird. In der Methode selbst muss das richtige TextView für die Ausgabe festgelegt sein.

Dann kommt die eigentliche Schleife. Direkt zu Anfang werden der Zähler, die Bedingung für das Ausführen der Schleife und der Intervall für das Erhöhen des Zählers festgelegt.

 for (int i=0; i<x; i++) { 
    // Inhalt der Schleife 
}

Dafür wird zunächst ein Integer i mit dem Wert 0 definiert. Die Ausführbedingung ist, dass i kleiner als x sein muss. Die Angabe „i++“ bedeutet, dass i bei jedem Durchlauf um 1 erhöht wird. (Dort könnte genauso „i+1“ stehen.)

Der Code in der Schleife bewirkt, dass der aktuelle Wert von i an den Inhalt des (zu Beginn noch leeren) TextViews tFor angehängt wird. Weil i zu Beginn den Wert 0 hat, wird in der 1. Runde eine 0 ins TextView tFor geschrieben, in der 2. Runde eine 1 daran angehängt, usw.

 

 

While-Loop

Dies hier ist die Methode whileLoop(x):

private void whileLoop(Integer x) {
    // TextView für Ausgabe der While-Schleife festlegen.
    TextView tWhile = (TextView) findViewById(R.id.tWhile);

    // Integer i als Zähler
    int i=0;
    // Bedingung
    while (i<x) {
        // Wert von i an Inhalt des TextViews anhängen.
        tWhile.append(String.valueOf(i));
        // Zähler erhöhen.
        i++;
    }
}

Die ersten paar Zeilen in whileLoop(x) entsprechen denen der Methode forLoop(x). Aber anders als bei der For-Schleife müssen Zähler und Zählererhöhung extra definiert werden. Teil der Schleife ist lediglich die Abfrage der Bedingung:

// i Wert zuweisen
while (i<x) {
// Inhalt der Schleife, Erhöhung des Zählers
}

Der Variablen i muss vor der Schleife ein Wert zugewiesen werden. Außerdem muss sie an einem beliebigen Punkt innerhalb der Schleife um eins erhöht werden. Ansonsten würde die Abbruchbedingung nie erreicht – es gäbe also eine Dauerschleife.

Im Beispiel wird bei jedem Durchlauf der aktuelle Wert von i an den Inhalt des TextViews (hier: tWhile) angehängt. Sinnvollerweise erfolgt die Erhöhung des Zählers erst nach dem Anhängen, um die korrekte „Runde“ auszugeben. 😉

 

Do-While-Loop

Meine Methode doWhileLoop(x) enthält folgenden Code:

private void doWhileLoop(Integer x) {
    // TextView für Ausgabe der Do-While-Schleife festlegen.
    TextView tDoWhile = (TextView) findViewById(R.id.tDoWhile);
    // Integer i (Zähler) auf 0 setzen.
    int i=0;
    do {
        // Wert von i an Inhalt des TextViews anhängen.
        tDoWhile.append(String.valueOf(i));
        // Zähler erhöhen.
        i++;
        // Bedingung.
    } while (i<x);
}

Wie beim While-Loop muss auch beim Do-While-Loop der Zähler vor Beginn der eigentlichen Schleife definiert werden. Der Zähler wird ebenfalls innerhalb der Schleife erhöht. Anders als bei den anderen beiden Loops erfolgt die Überprüfung der Abbruchbedingung nicht am Anfang, sondern erst am Ende:

// i Wert zuweisen
do { 
// Inhalt der Schleife, Erhöhung des Zählers. 
} while (i<x);

Der angegebene Code wird also zumindest einmal durchgeführt, unabhängig davon, ob die Abbruchbedingung zutrifft oder nicht.

Weil auch in diesem Fall der Wert von i an ein TextView (tDoWhile) angehängt wird, sollte die Zählererhöhung auch hier danach erfolgen. Prinzipiell ist aber egal, wo innerhalb der Schleife der Zähler erhöht wird. (Nicht-Erhöhung führt zur Dauerschleife.)

 

Loops in Aktion

Für das anfangs vorgestellte Code-Beispiel gilt x=5. Alle Schleifen haben die Abbruchbedingung i<x, wobei der Wert des Zählers i zu Beginn 0 ist. Das Resultat, also die App, sieht so aus:

Loops für x=5 mit Bedingung i<x.

Loops für x=5 mit Bedingung i<x.

Alle drei Loops liefern, trotz unterschiedlichem Aufbau, dasselbe Ergebnis. Sie laufen x-mal (=5-mal) durch, bevor die Abbruchbedingung i<x „erreicht“ wird. Alle drei führen denselben Code aus, nämlich „i an TextView anhängen“. In diesem Fall spielt keine Rolle, ob der Zähler zu Beginn erhöht und überprüft wurde oder erst am Ende der Schleife. Selbst bei der Do-While-Schleife wird der Zähler direkt vor der Überprüfung erhöht, sodass es zu keinem weiteren Durchlauf kommt.

Was aber, wenn die Abbruchbedingung von Anfang an erfüllt ist? In diesem Beispiel wäre das gegeben, sobald i größer oder gleich x ist. Wenn ich in der onCreate-Methode x=0 setze, dann passiert Folgendes:

Loops für x=0 mit Bedingung i<x.

Loops für x=0 mit Bedingung i<x.

Wie ihr seht, wurde der Code in der Schleife (also das Anhängen von i an den Inhalt des TextViews) weder beim For- noch beim While-Loop ausgeführt. Beide prüfen sofort zu Beginn die Abbruchbedingung. Und i=0 ist nicht kleiner als x=0. 😉

Die Do-While-Schleife führt den Code dennoch genau einmal aus. Dazu gehört auch die Erhöhung von i (i hat dann den Wert 1). Die Abbruchbedingung i<x bleibt erfüllt; einen zweiten Durchlauf gibt es nicht.

 



🙂 Klick hier für Bücher zum Thema Android-Programmierung!* 🙂

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.