Gegeben ist das folgende Javaprogramm:

public class Main2 {
   static short k;
   public static void main(String[] args) {
      short i, k;
      short imax = 10;
      for (i = 1; i < imax; i++) {
         for (k = 1; k < imax; k++) {
            if ((k == i) || (k == (imax - i))) {
               System.out.print("*");
            }
            else { System.out.print(" "); // ein Leerzeichen
            }
         } // for k
         switch (i) {
            case 1:
            case 2:
            case 3:
            case 4:
               System.out.println("LINKS");
               break;
            case 6:
            case 7:
            case 8:
            case 9:
               System.out.println("RECHTS");
               break;
            default:
               System.out.println("MITTE");
         } // switch
      } // for i
   } // main
}

Was druckt dieses Programm aus?

Ersetzen Sie die switch Anweisung durch if bzw. if-else Anweisungen. Das Programm soll mit den if Anweisungen die gleichen Ausgaben wie mit der switch Anweisung erzeugen.

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Wandeln Sie die do-while-Schleife in der Methode doWhile() um.
a.) Reimplementieren Sie den vorgebenen Multiplikationsalgorithmus der Methode doWhile() mit Hilfe einer while-Schleife in der Methode nurWhile()
b.) Reimplementieren den vorgebenen Multiplikationsalgorithmus der Methode doWhile() mit einer for-Schleife in der Methode nurFor().

Hinweise:

• Die Lösungen sollen nur in Bereiche mit weißem Hintergrund eingetragen werden
• Der Multiplikationsalgorithmus muss nur für positive Werte korrekte Ergebnisse liefern

public class Schleifen { 
   public static void main(String[] args) { 
      int a = 3; 
      int b = 4; 
      int c; 
      if ((a>=1) && (b>=1)) { 
         c = doWhile(a,b); System.out.println(c);
         c = nurWhile(a,b);System.out.println(c);
         c = nurFor(a,b);  System.out.println(c);
      }                                          
   } // Ende main                                
    public static int doWhile(int a, int b) {    
int i = 0;                                
       int ergebnis = 0;                         
          do {                                   
             ergebnis += a;                      
             i++;                                
          } while (i < b);                       
       return ergebnis;                          
   }                                             
   public static int nurWhile(int a, int b) {    
       int i = 0;                                
       int ergebnis = 0;                         
       // Hier Lösung eintragen
      return ergebnis;                           
    } // Ende nurWhile                           
public static int nurFor(int a, int b) {      
       int ergebnis = 0;                         
       int ergebnis = 0;
// Hier Lösung eintragen
       return ergebnis;                           
    } // Ende Methode nurFor                     
}

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu 1: Codetransformation

Konsolenausgabe:

*       *LINKS
 *     * LINKS
  *   *  LINKS
   * *   LINKS
    *    MITTE
   * *   RECHTS
  *   *  RECHTS
 *     * RECHTS
*       *RECHTS

Codetransformation:

if (i <5)
   System.out.println("Links");
else if (i==5)
   System.out.println("Mitte");
else
   System.out.println("Rechts");

Wandeln Sie die Switch-case Verzweigung der Methode caseVerzweigung() um in if-Verzweigungen. Benutzen Sie hierzu den Rumpf der Methode ifVerzweigung(). Beide Methoden sollen die gleichen Ausgaben mit der Methode drucke() erzeugen.

public class Transformation {
   public static void main(String[] args) {
      caseVerzweigung(3);
      ifVerzweigung(3);
   }

   public static void drucke(String st) { System.out.println(st);}
   
   public static void caseVerzweigung(int s) {
      switch (s) {
         case 2:
         case 4:
            drucke("gerade");
            break;
         case 1:
            drucke("eins");
            break;
        case 3:
            drucke("drei");
            break;
       default:
            drucke("unbekannt");
      } // End switch
   } //Ende Methode caseVerzweigung
   
   public static void ifVerzweigung(int s) {
     // Lösung hier eintragen
   } // Ende Methode ifVerzweigung
}// Ende Klasse Transformation

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 2: Codetransformation

public class Schleifen {
   public static void main(String[] args) { 
      int a = 3; 
      int b = 4; 
      int c; 
      if ((a>=1) && (b>=1)) { 
         c = doWhile(a,b); System.out.println(c);
         c = nurWhile(a,b);System.out.println(c);
         c = nurFor(a,b);  System.out.println(c);
      }                                          
   } // Ende main                                
    public static int doWhile(int a, int b) {    
       int i = 0;                                
       int ergebnis = 0;                         
          do {                                   
             ergebnis += a;                      
             i++;                                
          } while (i < b);                       
       return ergebnis;                          
   }                                             
   public static int nurWhile(int a, int b) {    
       int i = 0;                                
       int ergebnis = 0;                         
       // Lösung        
       ergebnis += a;
       i++;
       while (i < b) {
           ergebnis += a;
           i++;       } // Ende while Schleife
      return ergebnis;                           
    } // Ende nurWhile                           

public static int nurFor(int a, int b) {
int ergebnis = a;
// Lösung
for (int i = 1; i < b; i++) {
ergebnis += a;
}
return ergebnis;
} // Ende Methode nurFor
}

Die Methode forSchleife(int a) implementiert eine arithmetische Reihe, die für die Eingaben 0 bis 4 die folgenden Ausgaben erzeugt:
Eingabe: 0 1 2 3 4
Ausgabe:

• 0
• 1=1
• 3=1+2
• 6=1+2+3
• 10=1+2+3+4

public class ArithmetischeReihe {

 public static void main(String[] args) {// nur zum Testen
 int c;
 for (int a = 0; a <= 5; a++) {
   c = forSchleife(a);
   System.out.println(a + ":" + c);
   c = whileSchleife(a);
   System.out.println(a + ":" + c);
   } // Ende for
 } // Ende Methode main

 public static int forSchleife(int a) {//Vorgabe
   int ergebnis = 0;
   for (int i = 1; i <= a; i++) {
       ergebnis += i;
    }
   return ergebnis;
  }
}

Transformieren Sie die Methode forSchleife(int a) in eine gleichwertige Methode whileSchleife(int a) die, die gleichen Ergebnisse mit einer while Schleife erzeugt. Nutzen Sie den folgenden Quellcode:

public static int whileSchleife(int a) {
   int ergebnis = 0;

   return ergebnis;
}

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 3: Codetransformation switch-case

public class Transformation {
     public static void main(String[] args) { 
        caseVerzweigung(3); 
        ifVerzweigung(3); 
   }

   public static void drucke(String st) { System.out.println(st);}
   
   public static void caseVerzweigung(int s) {
      switch (s) {
         case 2:
         case 4:
            drucke("gerade");
            break;
         case 1:
            drucke("eins");
            break;
        case 3:
            drucke("drei");
            break;
       default:
            drucke("unbekannt");
      } // End switch
   } //Ende Methode caseVerzweigung
   
   public static void ifVerzweigung(int s) {
     // Lösung hier eintragen  
     for (s = 0; s < 6; s++) { //for Schleife nur zum Testen
        if ((s == 2) || (s==4)) drucke("gerade");
           else if (s==1) drucke("eins");
           else if (s==3) drucke ("drei");
           else drucke("unbekannt");
       	}
   } // Ende Methode ifVerzweigung
}// Ende Klasse Transformation

Die Methode forSchleife(int a) implementiert eine arithmetische Reihe, die für die Eingaben 1 bis 5 die folgenden Ausgaben erzeugt:

Eingabe: 1 2 3 4
Ausgabe:

• 1=1
• 3=1+2
• 6=1+2+3
• 10=1+2+3+4
• 15= 1+2+3+4+5

public class ArithmetischeReihe {

public static void main(String[] args) {// nur zum Testen
int c;
for (int a = 1; a <= 5; a++) {
   c = forSchleife(a);
   System.out.println(a + ":" + c);
   c = doWhileSchleife(a);
   System.out.println(a + ":" + c);
   } // Ende for
} // Ende Methode main

public static int forSchleife(int a) {//Vorgabe
   int ergebnis = 0;
   for (int i = 1; i <= a; i++) {
      ergebnis += i;
   }
   return ergebnis;
}

Transformieren Sie die Methode forSchleife(int a) in eine gleichwertige Methode doWhileSchleife(int a) die, die gleichen Ergebnisse mit einer dowhile Schleife erzeugt. Nutzen Sie den folgenden Quellcode:

public static int doWhileSchleife(int a) {
   int ergebnis = 0;
   // Code hier einfügen
   return ergebnis;
}

} // Ende der Klasse

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 4: Codetransformation (while Schleife)

public static int whileSchleife(int a) {
   int ergebnis = 0;

   int i = 1;
   while (i <= a) {
      ergebnis += i;
      i++;
   }
   return ergebnis;
}

Die Methode forSchleife(int a) implementiert eine arithmetische Reihe, die für die Eingaben 0 bis 4 die folgenden Ausgaben erzeugt:

public class ArithmetischeReihe {

public static void main(String[] args) {// nur zum Testen
int c;
for (int a = 0; a <= 5; a++) {
   c = forSchleife(a);
   System.out.println(a + ":" + c);
   c = caseVerzweigung(a);
   System.out.println(a + ":" + c);
   } // Ende for
} // Ende Methode main

public static int forSchleife(int a) {//Vorgabe
   int ergebnis = 0;
   for (int i = 1; i <= a; i++) {
 ergebnis += i;
   }
   return ergebnis;
}

Transformieren Sie die Methode forSchleife(int a) in eine gleichwertige Methode caseVerzeigung(int a) die, die gleichen Ergebnisse mit einer case Verzweigung erzeugt. In der case Verzweigung kann jeweils das Endergebnis aus der Tabelle oben zurückgegeben werden. Nutzen Sie den folgenden Quellcode:

public static int caseVerzweigung(int a) {
        int ergebnis = 0;
// Hier Lösung implementieren
        return ergebnis;
    } // Ende switch
}
} // Ende der Klasse

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 5: Codetransformation (do-while Schleife)

public static int doWhileSchleife(int a) {
   int ergebnis = 0;
   int i = 1;
   do {
      ergebnis += i;
      i++;
   } while (i <= a);
   return ergebnis;
}

Implementieren Sie eine for-Schleife die eine Variable i vom Wert 10 bis 20 hoch zählt.

Benutzen Sie den Aufruf System.out.println(i); um den Zählvorgang auf der Konsole auszudrucken.

Achten Sie darauf, dass alle benutzen Variablen deklariert sind!

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 6: Codetransformation (switch-case Bedingung)

public static int caseVerzweigung(int a) {
   int ergebnis = 0;
   switch (a) {
      case 0:
         ergebnis = 0;
         break;
      case 1:
         ergebnis = 1;
         break;
      case 2:
         ergebnis = 3;
         break;
      case 3:
         ergebnis = 6;
         break;
      case 4:
         ergebnis = 10;
         break;
      default:
         ergebnis = -1;
         break;
   }
   return ergebnis;
} // Ende switch

Nennen Sie die drei Teile des Kopfs einer for-Schleife in der Reihenfolge des Auftretens. Geben Sie eine kurze Erklärung für jeden Bereich

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 7: Implementieren einer for-Schleife

for (int i=10;i<=20; i++) {
   System.out.println(i);
   }

Was unterscheidet eine do-while Schleifen von while- und for-Schleifen?

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 8: Syntax einer for-Schleife

1. Identifikation und Initialisierung der (Lauf)variable mit der Möglichkeit zur Deklaration der Laufvariable
2. Definition eines Kriterium (logisches Ausdruck) welches bestimmt ob der Schleifenblock ausgeführt
3. Ausdruck der in der Regel zur Modifikation der Laufvariable benutzt wird nachdem der Block der for-Schleife einmal durchlaufen wird.

Kommentar: Java erlaubt es in allen drei Teilen des Kopfes Ausdrücke zu programmieren die nichts miteinander zu tun haben! Dies ist exotisch, in der Regel kontraproduktiv aber syntaktisch und semantisch möglich.

Transformieren sie die do-while Schleife der Methode in gleichwertige while-Schleifen und for-Schleifen.
Die main(), nurWhile() und forSchleife() Methoden erlauben Ihnen das Testen der Lösung

public class CodeTrans1 {
    /**
     * main Methode ist die Testinfrastruktur. Sie ist nicht direkt relevant zum
     * lösen der Aufgabe
     *
     * @param args Optionen werden nicht benutzt
     */
public static void main(String[] args) {
        int b = 3;
        System.out.println("Erster Durchlauf");
        System.out.println("Vorgabe:");
        doWhile(b);
        System.out.println("nurWhile():");
        nurWhile(b);
        System.out.println("forSchleife():");
        forSchleife(b);

        System.out.println("Zweiter Durchlauf");
        b = 0;
        System.out.println("Vorgabe:");
        doWhile(b);
        System.out.println("nurWhile():");
        nurWhile(b);
        System.out.println("forSchleife():");
        forSchleife(b);
    }
    /**
     * Die Vorgabe der Aufgabe
     * @param b 
     */
    public static void doWhile(int b) {
        int i = 0;
        String s;
        if (b >= 0) { // b ist immer gößer Null!
do {
                int k = i * 5;
                s = (i % 2 == 0) ? "gerade" : "ungerade";
                System.out.println("start():" + k + " ist " + s);
                i++; // Schleifeninkrement
            } while (i < b);
        }
    }
    public static void nurWhile(int b) {
        int i = 0;
        String s;

        if (b >= 0) { // b ist immer gößer Null!
// Hier die while Schleife implementieren
            }
    }
    public static void forSchleife(int b) {
        int i = 0;
        String s;

        if (b >= 0) { // b ist immer gößer Null!
// Hier die for Schleife implementieren
        }
    }
}

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu Frage 9: Unterschiede zwischen dowhile-Schleifen und for-, while-Schleifen

Eine do-while Schleife wird immer mindestens einmal durchlaufen. Sie ist keine abweisende Schleife.

Gegeben sei das folgende Programm:

package s1.block3;

public class AufgabeSwitchCase {
    static short k;

    public static void main(String[] args) {
        short i, k;
        short imax = 10;
        for (i = 1; i < imax; i++) {
            for (k = 1; k < imax; k++) {
                if ((k == i) || (k == (imax - i))) {
                    System.out.print("*");
                }
                else { System.out.print(" "); // ein Leerzeichen
                }
            } // for k
            switch (i) {
                case 1:
                case 2:
                case 3:
                case 4:
                    System.out.print("LINKS");
                    break;
                case 6:
                case 7:
                case 8:
                case 9:
                    System.out.print("RECHTS");
                    break;
                default:
                    System.out.print("MITTE");
            } // switch
            System.out.println(); //Neue Zeile
        } // for i
    } // main
}

• Markieren Sie alle Schlüsselwörter
• Arbeiten Sie jetzt das Programm ab und tragen Sie die Konsolenausgaben von oben nach unten auf ein (kariertes) Blatt Papier ein.

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Die Antwort ist bei der nächsten Frage zu finden (URL rechts unten)

Antwort zu 10: Codetransformation

public class CodeTrans1 {
    public static void main(String[] args) {
        int b = 3;
        System.out.println("Erster Durchlauf");
        System.out.println("Vorgabe:");
        doWhile(b);
        System.out.println("nurWhile():");
        nurWhile(b);
        System.out.println("forSchleife():");
        forSchleife(b);
        // Zweite Testrunde
        System.out.println("Zweiter Durchlauf");
        b = 0;
        System.out.println("Vorgabe:");
        doWhile(b);
        System.out.println("nurWhile():");
        nurWhile(b);
        System.out.println("forSchleife():");
        forSchleife(b);
    }
    /**
     * Die Vorgabe der Aufgabe
     * @param b 
     */
    public static void doWhile(int b) {
        int i = 0;
        String s;
        if (b >= 0) { // b ist immer gößer Null!
            do {
                int k = i * 5;
                s = (i % 2 == 0) ? "gerade" : "ungerade";
                System.out.println("start():" + k + " ist " + s);
                i++; // Schleifeninkrement
            } while (i < b);
        }
    }
    public static void nurWhile(int b) {
        int i = 0;
        String s;
        if (b >= 0) { // b ist immer gößer Null!
            int k = i * 5;
            s = (i % 2 == 0) ? "gerade" : "ungerade";
            System.out.println("start():" + k + " ist " + s);
            i++; // Schleifeninkrement
            while (i < b) {
                k = i * 5;
                s = (i % 2 == 0) ? "gerade" : "ungerade";
                System.out.println("start():" + k + " ist " + s);
                i++; // Schleifeninkrement
            }
        }
    }
    public static void forSchleife(int b) {
        int i = 0;
        String s;
        if (b >= 0) { // b ist immer gößer Null!
            int k = i * 5;
            s = (i % 2 == 0) ? "gerade" : "ungerade";
            System.out.println("start():" + k + " ist " + s);
            for (i = 1; i < b; i++) {
                k = i * 5;
                s = (i % 2 == 0) ? "gerade" : "ungerade";
                System.out.println("start():" + k + " ist " + s);
            }
        }
    }
}

Ergibt die folgende Ausgabe:

Erster Durchlauf
Vorgabe:
start():0 ist gerade
start():5 ist ungerade
start():10 ist gerade
nurWhile():
start():0 ist gerade
start():5 ist ungerade
start():10 ist gerade
forSchleife():
start():0 ist gerade
start():5 ist ungerade
start():10 ist gerade
Zweiter Durchlauf
Vorgabe:
start():0 ist gerade
nurWhile():
start():0 ist gerade
forSchleife():
start():0 ist gerade

Warum kann man nicht so einfach die folgende for-Schleife in eine enhanced-for Schleife umwandeln?

public static int forSchleife(int a) {//Vorgabe
       int ergebnis = 0;
       for (int i = 1; i <= a; i++) {
          ergebnis += i;
       }
    return ergebnis;
    }

Antwort zu Frage 11: Programmablauf

Schlüsselwörter im Programm:

public class Main2 {
   static short k;    

   public static void main(String[] args) {
     short i, k;
     short imax = 10;
     for (i = 1; i < imax; i++) {
       for (k = 1; k < imax; k++) {
           if ((k == i) || (k == (imax - i))) {
              System.out.print("*");
                } 
            else { System.out.print(" "); // ein Leerzeichen 
                 }
       } // for k
       switch (i) {
          case 1:
          case 2:
          case 3:
          case 4:
              System.out.println("LINKS");
              break;
          case 6:
          case 7:
          case 8:
          case 9:
              System.out.println("RECHTS");
              break;
          default:
              System.out.println("MITTE");
       } // switch
     } // for i
    } // main
}

Konsolenausgaben des Programms

*       *LINKS
 *     * LINKS
  *   *  LINKS
   * *   LINKS
    *    MITTE
   * *   RECHTS
  *   *  RECHTS
 *     * RECHTS
*       *RECHTS

Antwort zu Frage 12:

Die variable i wird im Block der For-Schleife verwendet. In der Enhanced-For-Schleife gibt es aber keine Zählvariable die man verwenden könnte.