Übungen¶

Übungsblätter (wochenweise)¶

Übung 0

Installieren Sie sich - falls noch nicht geschehen - eine Java-Entwicklungsumgebung (siehe Java).
Installieren Sie sich die IDE Ihrer Wahl (siehe IDE). In den Vorlesungen und Übungen verwende ich Eclipse und beschreibe die Schritte auch für Eclipse.
Starten Sie Eclipse durch Doppelklick auf das Programmsymbol.
Erstellen Sie einen Workspace (Arbeitsbereich) in einem gewünschten Ordner (z. B. Prog1) im Dateisystem. Achten Sie darauf, dass Sie Schreibrechte in diesem Ordner besitzen.
Anlegen eines Projektordners:
- Auswahl im Menü File-->New-->Java Project.
- Eingabe des Project name: Name des Projektes (z.B. WiSe25). Klicken auf den Button Finish.
- Das Fenster New module-info.java können Sie einfach mit Create bestätigen.
Erstellen eines neuen Packages (Paketes):
- Öffnen der Projektmappe im Package Explorer.
- Auswahl des Ordners src mit der rechten Maustaste.
- Auswahl des Menüpunktes New --> Package.
- Geben Sie folgenden Paketnamen ein (Paketnamen werden kleingeschrieben) uebungen.uebung0 (Achten Sie auf den Punkt und dass Sie alles zusammen schreiben).
Erstellen einer neuen Klasse:
- Öffnen der Projektmappe im Package Explorer.
- Auswahl des Paketes (uebungen.uebung0) mit der rechten Maustaste.
- Auswahl des Menüpunktes New --> Class.
- Eingabe des Namens, der gleichzeitig der Klassen- und Dateiname ist: Uebung0. Klassennamen werden immer groß geschrieben.
- Setzen des Häkchens bei public static void main(). (Sollten Sie vergessen haben, das Häkchen zu setzen, dann ist die Klasse, nachdem Sie Finish gedrückt haben, leer. Setzen Sie dann den Cursor zwischen die beiden geschweiften Klammern { }, geben dann main ein und drücken die Ctrl+Leer-Tasten und anschließend Enter. Dann erscheint die main()-Methode)
- Klicken auf den Button Finish.
In die main()-Methode (zwischen die geschweiften Klammern { und } geben Sie ein: System.out.println("Uebung 0"));.
Drücken Sie dann entweder auf den -Button oder wählen Sie aus dem Menü Run --> Run oder drücken Sie shift+command+f11. In der Console in Ihrer IDE (in Eclipse unten) erscheint Uebung 0.

Uebung0.java

package uebungen.uebung0;

public class Uebung0
{
    public static void main(String[] args)
    {
        System.out.println("Uebung 0");
    }
}

uebung0

Success

Fertig! Ihre Entwicklungsumgebung ist bereit! Wir können loslegen.

Übung 1

Erstellen Sie ein package uebungen.uebung1.
Erstellen Sie in diesem package eine Klasse Uebung1 mit main()-Methode.

Deklarieren und initialisieren Sie in der main()-Methode jeweils eine Variable mit dem Datentyp int, long, char, byte, short, float, double, boolean und String. Geben Sie alle Werte einzeln durch Aufruf der println()-Methode aus. Erzeugen Sie dabei folgende Ausgabe (Werte nur Beispiele):

Wert vom Typ int        :   123
Wert vom Typ long       :   456789
Wert vom Typ char       :   a
Wert vom Typ byte       :   127
Wert vom Typ short      :   32767
Wert vom Typ float      :   4.23
Wert vom Typ double     :   6.98
Wert vom Typ boolean    :   true
Wert vom Typ String     :   Hallo!

Setzen Sie den Wert Ihrer int-Variablen auf 2147483647. Geben Sie den Wert auf der Konsole aus, z.B.:
```
Wert von i  :   2147483647
```
Versuchen Sie nun den Wert auf 2147483648 zu setzen. Was passiert? Warum?
Wiederholen Sie das gleiche mit einer long-Variablen.
Weisen Sie Ihrer char-Variablen den Wert 65 zu. Geben Sie den Wert Ihrer char-Variablen aus. Was passiert? Warum?

Gegeben ist die folgende Klasse:

public class PrinterClass 
{

    public static void main(String[] args) 
    {
        System.out.print("answer=");
        System.out.println(42);
    }
}

Was wird auf der Konsole ausgegeben?
a)

answer=42

b)

answer=
42

c)

answer
=
42

Eine mögliche Lösung für Übung 1

package uebungen.uebung1;

public class Uebung1
{
    public static void main(String[] args)
    {
        int in = 123;
        long lo = 456789;
        char ch = 'a';
        byte by = 127;
        short sh = 32767;
        float fl = 4.23f;       // f notwendig
        double d1 = 6.98;
        boolean b1 = true;
        String s1 = "Hallo!";

        System.out.println(" --- Aufgabe 3 -------");
        System.out.println();
        System.out.print("Wert vom Typ int     : ");
        System.out.println(in);
        System.out.print("Wert vom Typ long    : ");
        System.out.println(lo);
        System.out.print("Wert vom Typ char    : ");
        System.out.println(ch);
        System.out.print("Wert vom Typ byte    : ");
        System.out.println(by);
        System.out.print("Wert vom Typ short   : ");
        System.out.println(sh);
        System.out.print("Wert vom Typ float   : ");
        System.out.println(fl);
        System.out.print("Wert vom Typ double  : ");
        System.out.println(d1);
        System.out.print("Wert vom Typ boolean : ");
        System.out.println(b1);
        System.out.print("Wert vom Typ String  : ");
        System.out.println(s1);

        System.out.println();
        System.out.println(" --- Aufgabe 4 -------");
        System.out.println();
        in = 2147483647;
        System.out.println("Wert vom Typ int     : " + in );
        //in = 2147483648;      // Compilerfehler out of range

        System.out.println();
        System.out.println(" --- Aufgabe 5 -------");
        System.out.println();
        lo = 2147483647;    
        System.out.println("Wert vom Typ long    : " + lo );
        lo = 2147483648L;       // L notwendig, da 2147483648 kein int  
        System.out.println("Wert vom Typ long    : " + lo );

        System.out.println();
        System.out.println(" --- Aufgabe 6 -------");
        System.out.println();
        ch = 65;
        System.out.println(ch);     // A

        // 7 a)     
    }

}

Übung 2

Erstellen Sie ein package uebungen.uebung2.
Erstellen Sie in diesem package eine Klasse Uebung2 mit main()-Methode.
Deklarieren Sie in main() 2 int-Variablen und geben Sie Ihnen Werte (die folgenden Werte 17 und 4 sind nur Beispiele). Erzeugen Sie nun unter Verwendung dieser Variablen folgende Ausgabe (bei anderen Werten natürlich entsprechend anders):
```
17 geteilt durch 4 ergibt 4. Es bleibt ein Rest von 1
```
Erzeugen Sie nun stattdessen folgende Ausgabe:
```
17/4 = 4
17 mod 4 = 1
```
Beachten Sie, dass Sie den Wert für den Quotienten und für den Rest für 3. und 4. nur einmal ermitteln sollen.
Deklarieren Sie sich eine boolean-Variable. Der Wert der Variablen soll true sein, wenn das Produkt der beiden int-Variablen aus 3. gerade ist und false, wenn es ungerade ist.
Probieren Sie die Division 100/3 in den folgenden Datentypen: int, float, double. Was stellen Sie fest?
Prüfen Sie, ob die letzte Ziffer von 2 int-Variablen gleich ist (dann true, sonst false).
Zusatz: Gegeben sei eine Anzahl von Stunden. Geben Sie aus, wieviel ganze Tage in dieser Anzahl enthalten sind, z.B.
```
In 34567 Stunden sind 1440 ganze Tage enthalten.
```
Wieviele Stunden bleiben übrig?
```
Zieht man von den 34567 Stunden die 1440 Tage ab, bleiben 7 Stunden übrig.
```

Eine mögliche Lösung für Übung 2

package uebungen.uebung2;

public class Uebung2
{

    public static void main(String[] args)
    {
        System.out.println();
        System.out.println("-------------------- 3. -------------------------");
        System.out.println();
        int i1 = 77;
        int i2 = 5;
        int quotient = i1/i2;
        int rest = i1%i2;

        System.out.print(i1 + " geteilt durch " + i2 + " ergibt " + quotient + ". ");
        System.out.println("Es bleibt ein Rest von " + rest + ".");

        System.out.println();
        System.out.println("-------------------- 4. -------------------------");
        System.out.println();

        System.out.println(i1 + "/" + i2 + " = " + quotient);
        System.out.println(i1 + " mod " + i2 + " = " + rest);

        System.out.println();
        System.out.println("-------------------- 6. -------------------------");
        System.out.println();

        int product = i1 * i2;
        boolean productIsEven = product % 2 == 0;
        boolean productIsOdd = !productIsEven;      // product % 2 == 1

        System.out.println(product + " ist gerade   ? " + productIsEven);
        System.out.println(product + " ist ungerade ? " + productIsOdd);


        System.out.println();
        System.out.println("-------------------- 7. -------------------------");
        System.out.println();

        System.out.println("int    : " + 100/3);        // int

        System.out.println("float  : " + 100.0f/3.0f);  // float
        System.out.println("float  : " + 100f/3f);      // float

        System.out.println("double : " + 100.0/3.0);    // double
        System.out.println("double : " + 100.0/3);      // double
        System.out.println("double : " + 100/3.0);      // double

        System.out.println();
        System.out.println("-------------------- 8. -------------------------");
        System.out.println();

        int lastDigitOfi1 = i1 % 10;
        int lastDigitOfi2 = i2 % 10;
        boolean lastDigitsAreEqual = (lastDigitOfi1 == lastDigitOfi2);

        System.out.println();
        System.out.println("-------------------- 9. -------------------------");
        System.out.println();

        int hours = 34567;
        final int HOURS_ONE_DAY = 24;   // Konstante
        int days = hours/HOURS_ONE_DAY;

        System.out.println("In " + hours + " Stunden sind " + days + " ganze Tage enthalten.");
        System.out.println("Zieht man von den " + hours + " Stunden die " + days + " Tage ab, "
                + "bleiben " + hours%oneDay + " Stunden übrig.");

    }

}

Übung 2a

Verwenden Sie erneut die Klasse Uebung2 aus dem Paket uebungen.uebung2 (oder Sie erstellen sich ein Paket uebungen.uebung2.a und darin eine Klasse Uebung2a).

Schreiben Sie eine Methode

public static void printIntDivision(int nr1, int nr2) 
{
}

Diese Methode soll folgende Ausgabe auf die Konsole erzeugen, z.B. für printIntDivision(7, 4); die Ausgabe

7 geteilt durch 4 ergibt 1. Es bleibt ein Rest von 3

z.B. für printIntDivision(17, 4); die Ausgabe

17 geteilt durch 4 ergibt 4. Es bleibt ein Rest von 1

Schreiben Sie zwei Methoden
```
public static int getQuotient(int nr1, int nr2) {} // und 
public static int getRemainder(int nr1, int nr2) {}
```
Rufen Sie diese Methoden in der main()-Methode auf generieren mit den Aufrufen und unter Verwendung der println()-Methode folgende Ausgaben:
```
17/4 = 4
17 mod 4 = 1
```
Besitzen die folgende Methodenaufrufe einem Wert? Wenn ja, welcher?
- printIntDivision(17, 4);
- getQuotient(17,4);
- getRemainder(17,4);
Können wir die Methoden getQuotient(int nr1, int nr2) und getRemainder(int nr1, int nr2) auch in der printIntDivision(int nr1, int nr2)-Methode verwenden/aufrufen? Wenn ja, wie?
Schreiben Sie eine Methode lastDigitsAreEqual(int nr1, int nr2), die ein true zurückgibt, wenn nr1 und nr2 dieselbe letzte Ziffer haben und false sonst.
Schreiben Sie eine Methode isEven(int nr1), die ein true zurückgibt, wenn nr1 eine gerade Zahl ist. Schreiben Sie eine Methode isOdd(int nr1), die ein true zurückgibt, wenn nr1 eine ungerade Zahl ist. Verwenden Sie in isOdd(int nr1) die Methode isEven(int nr1).
Schreiben Sie eine Methode getDays(int hours), die für eine gegebene Stundenanzahl hours zurückgibt, wieviele ganze Tage diese Stunden entsprechen. Schreiben Sie eine Methode getRemainingHours(int hours), die für eine gegebene Stundenanzahl hours zurückgibt, wieviele Stunden noch verbleiben, wenn man die ganzen Tage darin abzieht. Erstellen Sie in main() mit diesen Methoden und der println()-Methode folgende Ausgaben auf der Konsole (Beispielwerte):
```
In 34567 Stunden sind 1440 ganze Tage enthalten.
```
Wieviele Stunden bleiben übrig?
```
Zieht man von den 34567 Stunden die 1440 Tage ab, bleiben 7 Stunden übrig.
```

Eine mögliche Lösung für Übung 2a

package uebungen.uebung2a;

public class Uebung2a
{

    public static void printIntDivision(int nr1, int nr2) 
    {       
        // int quotient = nr1 / nr2;
        int quotient = getQuotient(nr1, nr2);
        // int rest = nr1 % nr2;
        int rest = getRemainder(nr1, nr2);

        System.out.print(nr1 + " geteilt durch " + nr2 + " ergibt " + quotient + ".");
        System.out.println(" Es bleibt ein Rest von " + rest + ".");

    }

    public static int getQuotient(int nr1, int nr2)
    {
        return nr1 / nr2;
    }

    public static int getRemainder(int nr1, int nr2)
    {
        return nr1 % nr2;
    }

    public static boolean lastDigitsAreEqual(int nr1, int nr2)
    {
        int lastDigitOfNr1 = nr1 % 10;
        int lastDigitOfNr2 = nr2 % 10;
        return (lastDigitOfNr1 == lastDigitOfNr2) ||
               (lastDigitOfNr1 == -lastDigitOfNr2);
    }

    public static boolean isEven(int nr)
    {
        return nr % 2 == 0;
    }

    public static boolean isOdd(int nr)
    {
        return !isEven(nr);
    }

    public static int getDays(int hours)
    {
        final int HOURS_ONE_DAY = 24;
        return hours / HOURS_ONE_DAY;
    }

    public static int getRemainingHours(int hours)
    {
        final int HOURS_ONE_DAY = 24;
        return hours % HOURS_ONE_DAY;
    }


    public static void main(String[] args)
    {
        System.out.println();
        System.out.println("--------------- 2. ----------------");
        System.out.println();

        printIntDivision(17, 4);
        printIntDivision(16, 4);
        printIntDivision(16, 17);

        System.out.println();
        System.out.println("--------------- 3. ----------------");
        System.out.println();

        int nr1 = 17;
        int nr2 = 4;
        System.out.println(nr1 + "/" + nr2 + " = " + getQuotient(nr1, nr2));
        System.out.println(nr1 + " mod " + nr2 + " = " + getRemainder(nr1, nr2));

        nr1 = 15;
        nr2 = 5;
        System.out.println(nr1 + "/" + nr2 + " = " + getQuotient(nr1, nr2));
        System.out.println(nr1 + " mod " + nr2 + " = " + getRemainder(nr1, nr2));


        System.out.println();
        System.out.println("--------------- 6. ----------------");
        System.out.println();

        System.out.println(nr1 + ", " + nr2 + " ? " + lastDigitsAreEqual(nr1, nr2));
        nr1 = 123;
        nr2 = 3;
        System.out.println(nr1 + ", " + nr2 + " ? " + lastDigitsAreEqual(nr1, nr2));
        nr1 = 123;
        nr2 = -3;
        System.out.println(nr1 + ", " + nr2 + " ? " + lastDigitsAreEqual(nr1, nr2));
        nr1 = -123;
        nr2 = 3;
        System.out.println(nr1 + ", " + nr2 + " ? " + lastDigitsAreEqual(nr1, nr2));
        nr1 = -12;
        nr2 = 3;
        System.out.println(nr1 + ", " + nr2 + " ? " + lastDigitsAreEqual(nr1, nr2));

        System.out.println();
        System.out.println("--------------- 7. ----------------");
        System.out.println();

        int hours = 34567;
        // hours = 22;
        int days = getDays(hours);
        int remainingHours = getRemainingHours(hours);

        System.out.println("In " + hours + " Stunden sind " + days 
                + " ganze Tage enthalten.");
        System.out.println("Zieht man von den " + hours + " Stunden die " 
                + days + " Tage ab, bleiben " + remainingHours + " Stunden übrig.");

    }
}

Übung 3

Erstellen Sie ein package uebungen.uebung3.
Erstellen Sie in diesem package eine Klasse Uebung3 mit main()-Methode.

Schreiben Sie eine Methode public static void printTimesTables(int nr1, int nr2). Bei Aufruf der Methode z.B. für printTimesTables(10,10); soll das kleine Ein-Mal-Eins in der folgenden Form ausgegeben werden:

Ausgabe für printTimesTables(10,10);

1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
1 * 4 = 4
1 * 5 = 5
1 * 6 = 6
1 * 7 = 7
1 * 8 = 8
1 * 9 = 9
1 * 10 = 10

2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
2 * 10 = 20

3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
3 * 10 = 30

4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
4 * 7 = 28
4 * 8 = 32
4 * 9 = 36
4 * 10 = 40

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

6 * 1 = 6
6 * 2 = 12
6 * 3 = 18
6 * 4 = 24
6 * 5 = 30
6 * 6 = 36
6 * 7 = 42
6 * 8 = 48
6 * 9 = 54
6 * 10 = 60

7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63
7 * 10 = 70

8 * 1 = 8
8 * 2 = 16
8 * 3 = 24
8 * 4 = 32
8 * 5 = 40
8 * 6 = 48
8 * 7 = 56
8 * 8 = 64
8 * 9 = 72
8 * 10 = 80

9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45
9 * 6 = 54
9 * 7 = 63
9 * 8 = 72
9 * 9 = 81
9 * 10 = 90

10 * 1 = 10
10 * 2 = 20
10 * 3 = 30
10 * 4 = 40
10 * 5 = 50
10 * 6 = 60
10 * 7 = 70
10 * 8 = 80
10 * 9 = 90
10 * 10 = 100

Ausgabe für printTimesTables(3,7);

Schreiben Sie eine Methode public static void printTimesMatrix(int nr1, int nr2). Bei Aufruf der Methode z.B. für printTimesMatrix(10,10) soll das kleine Ein-Mal-Eins in der folgenden Form ausgegeben werden:

Ausgabe für printTimesMatrix(10,10);

 1  2  3  4  5  6  7  8  9  10 
 2  4  6  8  10  12  14  16  18  20 
 3  6  9  12  15  18  21  24  27  30 
 4  8  12  16  20  24  28  32  36  40 
 5  10  15  20  25  30  35  40  45  50 
 6  12  18  24  30  36  42  48  54  60 
 7  14  21  28  35  42  49  56  63  70 
 8  16  24  32  40  48  56  64  72  80 
 9  18  27  36  45  54  63  72  81  90 
 10  20  30  40  50  60  70  80  90  100

Ausgabe für printTimesMatrix(3,7);

 1  2  3  4  5  6  7   
 2  4  6  8  10  12  14   
 3  6  9  12  15  18  21

Schreiben Sie eine Methode public static void printTriangleUp(int height). Bei Aufruf der Methode z.B. für printTriangleUp(7) soll folgende Ausgabe erscheinen:
```
*******
******
*****
****
***
**
*
```
Geben Sie alle möglichen Kombinationen für 3 ganze Zahlen x, y und z aus, für die gilt:
```
x <= y <= z und
x * y * z = 36
```
Genügt bis hierher. Ab hier Zusatz nur für diejenigen, die bereits früher fertig sind.

Zusatz Schreiben Sie eine Umrechnung für eine gegebene Anzahl von Sekunden (printSeconds(int seconds)), z.B. printSeconds(3456789):

3456789 Sekunden sind 40 Tage, 13 Minuten, 9 Sekunden.

Aber z.B. printSeconds(2345678):

2345678 Sekunden sind 27 Tage, 3 Stunden, 34 Minuten, 38 Sekunden.

Aber z.B. printSeconds(123456):

123456 Sekunden sind 1 Tag, 10 Stunden, 17 Minuten, 36 Sekunden.

Aber z.B. printSeconds(12345):

12345 Sekunden sind 3 Stunden, 25 Minuten, 45 Sekunden.

Eine mögliche Lösung für Übung 3

package uebungen.uebung3;

public class Uebung3
{
    public static void printTimesTables(int nr1, int nr2)
    {
        for(int factor1 = 1; factor1 <= nr1; factor1++)
        {
            //System.out.println();
            //System.out.println("factor1 : " + factor1);
            //System.out.println("--> vor innerer Schleife");

            for(int factor2 = 1; factor2 <= nr2; factor2++)
            {
                //System.out.println("            factor2 : " + factor2);
                int product = factor1 * factor2;
                System.out.println(factor1 + " * " + factor2 + " = " + product);
            }

            //System.out.println("--> nach innerer Schleife");
            System.out.println();
        }
    }

    public static void printTimesMatrix(int nr1, int nr2)
    {
        for(int factor1 = 1; factor1 <= nr1; factor1++)
        {
            for(int factor2 = 1; factor2 <= nr2; factor2++)
            {
                System.out.print(factor1 * factor2 + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    public static void printTriangleUp(int height)
    {
        for(int row = 0; row < height; row++)
        {
            System.out.print(" Zeile " + row + " : ");
            for(int stars = 1; stars <= height-row; stars++)
            {
                System.out.print("* ");
            }
            System.out.println();
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        System.out.println();
        System.out.println("----------------- 3. --------------------");
        System.out.println();
        printTimesTables(10,10);
        printTimesTables(3,7);

        System.out.println();
        System.out.println("----------------- 4. --------------------");
        System.out.println();
        printTimesMatrix(10,10);
        printTimesMatrix(3,7);

        System.out.println();
        System.out.println("----------------- 5. --------------------");
        System.out.println();
        printTriangleUp(9);
        printTriangleUp(4);


        System.out.println();
        System.out.println("----------------- 6. --------------------");
        System.out.println();

        for(int x = -36; x <= 36; x++)
        {
            for(int y = x; y <= 36; y++)
            {
                for(int z = y; z <= 36; z++)
                {
                    int product = x * y * z;
                    //if(product == 36 && x <= y && y <= z)
                    if(product == 36)
                    {
                        System.out.println(x + " * " + y + " * " + z + " = " + product );
                    }
                }
            }
        }
    }

}

Übung 4

Erstellen Sie ein package uebungen.uebung4.
Erstellen Sie in diesem package eine Klasse Uebung4 mit main()-Methode.
Implementieren Sie folgende Methoden:
- public static boolean isPrime(int number) – diese Methode prüft, ob die als Parameter übergebene number eine Primzahl ist. Die Methode gibt ein true zurück, wenn number eine Primzahl ist und false sonst.
- public static void printPrimeNumbers(int maximum) – diese Methode gibt alle Primzahlen von 1 bis einschließlich maximum wie folgt auf der Konsole aus (Bsp. für maximum=61):
```
Zahl : 61
.2 3 .5 .7 ...11 .13 ...17 .19 ...23 .....29 .31 .....37 ...41 .43 ...47 .....53 .....59 .61
```
  d.h. es werden die Zahlen, die Primzahlen sind, ausgegeben und für die anderen Zahlen erscheint nur ein Punkt. Verwenden Sie in der Methode printPrimenumbers(int) die Methode isPrime(int).
- public static int getSmallestDivider(int number) – diese Methode gibt den kleinsten Teiler zurück, der number ganzzahlig teilt. Ist number eine Primzahl, wird number zurückgegeben. Für den Fall, dass number kleiner als 2 ist, geben Sie ebenfalls number zurück.
- public static String createStringOfPrimeFactorization(int number) – diese Methode gibt einen String in folgender Form zurück (Bsp. für number=632060):
```
" 2 * 2 * 5 * 11 * 13 * 13 * 17 = 632060 "
```
  d.h. alle kleinsten Teiler werden mit dem Multiplikationszeichen verbunden und am Ende erscheint = Wert von number.
- Testen Sie alle Methoden. Rufen Sie insbesondere printPrimenumbers(int) und createStringOfPrimeFactorization(int) in der main()-Methode auf.
- Zusatz Schreiben Sie eine Methode, die für eine natürliche Zahl deren Quersumme ausgibt, z.B.: crossSum(12345678)
```
Die Quersumme von 12345678 ist 36.
```

Übung 5

Erstellen Sie ein package uebungen.uebung5.
Erstellen Sie in diesem package eine Klasse Konto (ohne main()-Methode!)
Erstellen Sie in diesem package eine Klasse Testklasse mit main()-Methode
Erstellen Sie in der Klasse Konto zwei Objektvariablen
- guthaben vom Typ double → nur in der Klasse sichtbar!
- pin vom Typ int → ebenfalls nur in der Klasse sichtbar!
Erstellen Sie in der Klasse Konto einen Konstruktor für Konto
- diesem Konstruktor wird als Parameter int pin übergeben
- mit dem Wert des Parameters wird innerhalb des Konstruktors der Wert von pin initialisiert
- Initialisieren Sie im Konstruktor auch die Objektvariable guthaben. Sie bekommt den Wert 0.0 (hierfür haben wir also keinen Parameter, wir setzen den initialen Wert einfach generell auf 0.0)
Erstellen Sie in der Klasse Konto eine Objektmethode einzahlen(double betrag)
- diese Objektmethode ist public und gibt nichts zurück
- in dieser Methode wird der Wert der Objektvariablen guthaben um den Wert von betrag erhöht
- erzeugen Sie in dieser Methode außerdem eine Ausgabe in der Form:
```
Es wurden 100,00 Euro eingezahlt.
```
  falls der betrag den Wert 100.0 hatte. (Optional: Verwenden Sie am besten die printf()-Methode, um stets genau 2 Stellen nach dem Komma des Betrages auszugeben (siehe hier).

Geben Sie in der main()-Methode der Testklasse ein:

Konto k1 = new Konto(1234);

k1.einzahlen(100.0);
k1.einzahlen(50.0);
k1.einzahlen(150.0);

und führen Sie die Testklasse aus. Es sollten folgende Ausgaben erzeugt werden (falls printf() verwendet wird, ansonsten ist die Ausgabe z.B. 100.0 Euro):

Es wurden 100,00 Euro eingezahlt.
Es wurden 50,00 Euro eingezahlt.
Es wurden 150,00 Euro eingezahlt.

Erstellen Sie in der Klasse Konto eine Objektmethode kontoauszug(int pin)
- diese Objektmethode ist public und gibt nichts zurück
- einen kontoauszug(int pin) können Sie nur "ziehen", wenn der Parameterwert von pin mit dem Wert der Objektvariablen pin übereinstimmt
- wird der richtige Wert für die pin übergeben, geben Sie das guthaben in der folgenden Form aus:
```
Ihr aktuelles Guthaben betraegt 300,00 Euro.
```
  falls guthaben den Wert von 300.0 hat.
- wird ein falscher Wert für die pin übergeben, geben Sie folgende Ausgabe aus:
```
Falsche PIN!
```
Erweitern Sie die main()-Methode der Testklasse um folgende Anweisungen:
```
k1.kontoauszug(1235);       // Falsche PIN!
k1.kontoauszug(1234);   
```
und führen Sie die Testklasse aus. Es sollten folgende (weitere) Ausgaben erzeugt werden:
```
Falsche PIN!
Ihr aktuelles Guthaben betraegt 300,00 Euro.
```
Erstellen Sie in der Klasse Konto eine Objektmethode auszahlen(int pin, double betrag)
- diese Objektmethode ist public und gibt nichts zurück
- es kann nur etwas ausgezahlt werden, wenn der Parameterwert von pin mit dem Wert der Objektvariablen pin übereinstimmt
- stimmen die Werte nicht überein, geben Sie erneut
```
Falsche PIN!
```
  aus.
- stimmt der pin-Wert, dann müssen Sie prüfen, ob das guthaben reicht, um betrag auszuzahlen. Ist nicht genug guthaben vorhanden, dann geben Sie aus
```
Ihr Guthaben reicht nicht, um 400,00 Euro auszuzahlen.
```
  falls betrag den Wert 400.0 hatte.
- wenn der pin-Wert stimmt und genug guthaben vorhanden ist, um den betrag auszuzahlen, dann reduzieren Sie guthaben um den entsprechenden betrag und geben aus
```
Es wurden 100,00 Euro ausgezahlt.
```
  falls der betrag den Wert 100.0 hatte.

Erweitern Sie die main()-Methode der Testklasse um folgende Anweisungen:

k1.auszahlen(1235, 100.0);  // Falsche PIN!
k1.auszahlen(1234, 100.0);  
k1.kontoauszug(1234);       
k1.auszahlen(1234, 300.0);  // Guthaben reicht nicht
k1.auszahlen(1234, 200.0);  
k1.kontoauszug(1234);

und führen Sie die Testklasse aus. Es sollten folgende (weitere) Ausgaben erzeugt werden:

Falsche PIN!
Es wurden 100,00 Euro ausgezahlt.
Ihr aktuelles Guthaben betraegt 200,00 Euro.
Ihr Guthaben reicht nicht, um 300,00 Euro auszuzahlen.
Es wurden 200,00 Euro ausgezahlt.
Ihr aktuelles Guthaben betraegt 0,00 Euro.

Zusatz:

Erweitern Sie die Klasse um eine weitere Objektvariable private double dispogrenze
Initialisieren Sie diese Variable innerhalb des Konstruktors (ohne weiteren Parmeter) auf den Wert -1000.0. Sie dürfen somit Ihr Konto um 1000.00 Euro überziehen.
Passen Sie die auszahlen()-Methode entsprechend an, so dass es auch möglich ist, einen betrag auszuzahlen, so lange man nicht unter die dispogrenze fällt.
Erstellen Sie eine Methode public void zinsenZahlen().
- Erstellen Sie in dieser Methode zwei Konstanten
  - DISPOZINSEN vom Typ double bekommt den Wert 12.0 (soll 12% entsprechen) und
  - GUTHABENZINSEN vom Typ double bekommt den Wert 0.5 (soll 0.5% entsprechen)
- Berechnen Sie innerhalb der Methode die Zinsen für das Konto
  - DISPOZINSEN werden fällig (werden von guthaben abgezogen), falls guthaben negativ ist
  - GUTHABENZINSEN werden gewährt (werden zu guthaben addiert), falls guthaben positiv ist
  - passen Sie den Wert von guthaben entsprechend an
  - erzeugen Sie entsprechende Ausgaben, z.B.
```
Ihnen wurden 18,00 Euro Zinsen abgebucht.
```
    bzw.
```
Ihnen wurden 4,16 Euro Zinsen gutgeschrieben.
```

Angenommen, die gesamte main()-Methode sieht jetzt so aus:

public static void main(String[] args)
{
    Konto k1 = new Konto(1234);

    k1.einzahlen(100.0);
    k1.einzahlen(50.0);
    k1.einzahlen(150.0);

    k1.kontoauszug(1235);       // Falsche PIN!
    k1.kontoauszug(1234);       

    k1.auszahlen(1235, 100.0);  // Falsche PIN!
    k1.auszahlen(1234, 100.0);  
    k1.kontoauszug(1234);       
    k1.auszahlen(1234, 300.0);  
    k1.auszahlen(1234, 200.0);  
    k1.kontoauszug(1234); 

    k1.einzahlen(150.0);
    k1.kontoauszug(1234);       
    k1.zinsenZahlen();
    k1.kontoauszug(1234);       
    k1.einzahlen(1000.0);
    k1.kontoauszug(1234);       
    k1.zinsenZahlen();
    k1.kontoauszug(1234); 
}

dann sollten Sie folgende Ausgabe erzeugen (gilt nur für Zusatz!):

Es wurden 100,00 Euro eingezahlt.
Es wurden 50,00 Euro eingezahlt.
Es wurden 150,00 Euro eingezahlt.
Falsche PIN!
Ihr aktuelles Guthaben betraegt 300,00 Euro.
Falsche PIN!
Es wurden 100,00 Euro ausgezahlt.
Ihr aktuelles Guthaben betraegt 200,00 Euro.
Es wurden 300,00 Euro ausgezahlt.
Es wurden 200,00 Euro ausgezahlt.
Ihr aktuelles Guthaben betraegt -300,00 Euro.
Es wurden 150,00 Euro eingezahlt.
Ihr aktuelles Guthaben betraegt -150,00 Euro.
Ihnen wurden 18,00 Euro Zinsen abgebucht.
Ihr aktuelles Guthaben betraegt -168,00 Euro.
Es wurden 1000,00 Euro eingezahlt.
Ihr aktuelles Guthaben betraegt 832,00 Euro.
Ihnen wurden 4,16 Euro Zinsen gutgeschrieben.
Ihr aktuelles Guthaben betraegt 836,16 Euro.

Übung 6

Erstellen Sie ein package uebungen.uebung6.
Erstellen Sie in diesem package eine Klasse Rectangle (ohne main()-Methode!)
Erstellen Sie in diesem package eine Klasse Testklasse mit main()-Methode
Erstellen Sie in der Klasse Rectangle zwei Objektvariablen
- a vom Typ int → nur in der Klasse sichtbar!
- b vom Typ int → ebenfalls nur in der Klasse sichtbar!
a und b sollen die Seiten des Rechtecks sein.
Implementieren Sie einen parameterlosen Konstruktor Rectangle(), der für die Seite a den Wert 10 und für die Seite b den Wert 20 setzt.
Implementieren Sie einen parametrisierten Konstruktor Rectangle(int a, int b), der die Parameterwerte zum Initialisieren der Seiten verwendet.
Implementieren Sie eine Objektmethode public int area(), die den Flächeninhalt des Rechtecks zurückgibt.
Implementieren Sie eine Objektmethode public int perimeter(), die den Umfang des Rechtecks zurückgibt.
Implementieren Sie eine Objektmethode public String toString(), die einen String mit allen Informationen des Rechtecks in der folgenden Form
```
Rectangle : ( a=10, b=20, area=200, perimeter=60 )
```
zurückgibt.
Implementieren Sie eine Objektmethode public void print(), die den durch toString() erzeugten String auf die Konsole ausgibt.

Geben Sie in der main()-Methode der Testklasse ein:

// Objekte erzeugen
Rectangle r1 = new Rectangle();
Rectangle r2 = new Rectangle(12, 18);
Rectangle r3 = new Rectangle(40, 5);
Rectangle r4 = new Rectangle(20, 10);
Rectangle r5 = new Rectangle(11, 21);

System.out.printf("%n%n--------------- print()-Methode -----------------%n%n");
r1.print();
r2.print();
r3.print();
r4.print();
r5.print();

und führen Sie die Testklasse aus. Es sollten folgende Ausgaben erzeugt werden:

--------------- print()-Methode -----------------

Rectangle : ( a=10, b=20, area=200, perimeter=60 )
Rectangle : ( a=12, b=18, area=216, perimeter=60 )
Rectangle : ( a=40, b= 5, area=200, perimeter=90 )
Rectangle : ( a=20, b=10, area=200, perimeter=60 )
Rectangle : ( a=11, b=21, area=231, perimeter=64 )

Implementieren Sie eine Objektmethode public boolean sidesAreEqual(Rectangle r), die ein true zurückgibt, wenn die Seiten des aufrufenden Objektes gleich den Seiten des Rectangle r sind. Beachten Sie, dass das Rechteck auch gedreht noch gleiche Seiten haben soll, also a=10, b=20 ist nicht nur mit a=10, b=20 gleich, sondern auch mit a=20, b=10. Wenn die Seiten ungleich sind, gibt die Methode ein false zurück.
Implementieren Sie eine Objektmethode public boolean areasAreEqual(Rectangle r), die ein true zurückgibt, wenn die Flächeninhalte des aufrufenden Objektes und des Rectangle r gleich sind. Ansonsten false.
Implementieren Sie eine Objektmethode public boolean perimetersAreEqual(Rectangle r), die ein true zurückgibt, wenn die Umfänge des aufrufenden Objektes und des Rectangle r gleich sind. Ansonsten false.
Implementieren Sie eine Objektmethode public void printComparison(Rectangle r), die die Vergleiche mit r in der unten dargestellten Form ausgibt. Rufen Sie in der Methode die Methoden print() (oder toString()), sidesAreEqual(), areasAreEqual() und perimetersAreEqual() auf.

Fügen Sie in der main()-Methode der Testklasse folgende Anweisungen hinzu:

System.out.printf("%n%n---------- printComparison()-Methode ------------%n%n");
r1.printComparison(r2);
r1.printComparison(r3);
r1.printComparison(r4);
r1.printComparison(r5);

und führen Sie die Testklasse aus. Es sollten folgende zusätzliche Ausgaben erzeugt werden:

---------- printComparison()-Methode ------------

this      Rectangle : ( a=10, b=20, area=200, perimeter=60 ) 
the other Rectangle : ( a=12, b=18, area=216, perimeter=60 ) 
sides are not equal 
areas are not equal 
perimeters are equal 

this      Rectangle : ( a=10, b=20, area=200, perimeter=60 ) 
the other Rectangle : ( a=40, b= 5, area=200, perimeter=90 ) 
sides are not equal 
areas are equal 
perimeters are not equal 

this      Rectangle : ( a=10, b=20, area=200, perimeter=60 ) 
the other Rectangle : ( a=20, b=10, area=200, perimeter=60 ) 
sides are equal 
areas are equal 
perimeters are equal 

this      Rectangle : ( a=10, b=20, area=200, perimeter=60 ) 
the other Rectangle : ( a=11, b=21, area=231, perimeter=64 ) 
sides are not equal 
areas are not equal 
perimeters are not equal

Zusatz:

Implementieren Sie eine Objektmethode public double diagonal(), die die Länge einer Diagonalen des Rechtecks zurückgibt.

Erweitern Sie die toString()-Methode um die Ausgabe dieser Länge wie folgt:

Rectangle : ( a=10, b=20, area=200, perimeter=60, diagonal=22,361 )
Rectangle : ( a=12, b=18, area=216, perimeter=60, diagonal=21,633 )
Rectangle : ( a=40, b= 5, area=200, perimeter=90, diagonal=40,311 )
Rectangle : ( a=20, b=10, area=200, perimeter=60, diagonal=22,361 )
Rectangle : ( a=11, b=21, area=231, perimeter=64, diagonal=23,707 )

Implementieren Sie eine Objektmethode public void scale(int factor). Diese Methode "skaliert" (vergrößert oder verkleinert) das Rechteck um den Faktor factor, genauer gesagt, wird der Flächeninhalt um diesen Faktor skaliert (vergrößert oder verkleinert). Die neuen Seiten sollen das gleiche Verhältnis zueinander haben, wie die alten Seiten. Geben Sie die neuen Seitenlängen in der folgenden Form auf die Konsole aus (siehe nächsten Punkt main()).

Fügen Sie in der main()-Methode der Testklasse folgende Anweisungen hinzu:

System.out.printf("%n%n--------------- scale()-Methode -----------------%n%n");
r1.scale(2);
r2.scale(2);
r3.scale(2);
r4.scale(2);
r5.scale(2);
r1.scale(10);
r2.scale(10);
r3.scale(10);
r4.scale(10);
r5.scale(10);

und führen Sie die Testklasse aus. Es sollten folgende zusätzliche Ausgaben erzeugt werden:

--------------- scale()-Methode -----------------

newArea=  400,00 newA= 14,14 newB= 28,28 check (newA*newB)= 400,00
newArea=  432,00 newA= 16,97 newB= 25,46 check (newA*newB)= 432,00
newArea=  400,00 newA= 56,57 newB=  7,07 check (newA*newB)= 400,00
newArea=  400,00 newA= 28,28 newB= 14,14 check (newA*newB)= 400,00
newArea=  462,00 newA= 15,56 newB= 29,70 check (newA*newB)= 462,00
newArea= 2000,00 newA= 31,62 newB= 63,25 check (newA*newB)=2000,00
newArea= 2160,00 newA= 37,95 newB= 56,92 check (newA*newB)=2160,00
newArea= 2000,00 newA=126,49 newB= 15,81 check (newA*newB)=2000,00
newArea= 2000,00 newA= 63,25 newB= 31,62 check (newA*newB)=2000,00
newArea= 2310,00 newA= 34,79 newB= 66,41 check (newA*newB)=2310,00

Sollte die scale()-Methode besser ein neues Rectangle-Objekt zurückgeben? Wenn ja, dann implementieren Sie es so.

Übung 7

Info: Wir erstellen uns zwei neue Datentypen Counter und Clock. Die Idee der Klasse Counter soll sein, einen counter bis zu einem bestimmten limit hochzuzählen. Bevor der counter das limit erreicht, wird er wieder auf 0 gesetzt. Angenommen also das limit ist 60 und der counter hat den aktuellen Wert 59 und soll erhöht werden, dann ist der nächste Wert von counter wieder 0, da das limit erreicht wurde. Die Klasse Clock verwendet zwei Counter-Objekte, eins für hours und das andere für minutes.

Erstellen Sie ein package uebungen.uebung7.
Erstellen Sie in diesem package eine Klasse Counter (ohne main()-Methode!)
Erstellen Sie in diesem package eine Klasse Programmklasse mit main()-Methode
Erstellen Sie in der Klasse Counter zwei Objektvariablen
- counter vom Typ int → nur in der Klasse sichtbar!
- limit vom Typ int → ebenfalls nur in der Klasse sichtbar!
Erstellen Sie einen parametrisierten Konstruktor public Counter(int limit), der den counter auf 0 initialisiert und das limit auf den Parameterwert.
Implementieren Sie eine Methode public boolean increase(). Diese Methode soll den Wert von counter um 1 erhöhen. Es muss jedoch geprüft werden, ob eventuell das limit erreicht wurde. Sollte dies der Fall sein, wird der Wert von counter wieder auf 0 gesetzt. Wird der counter tatsächlich um 1 erhöht, gibt die Methode ein true zurück, wurde der Wert von counter jedoch auf 0 gesetzt, gibt die Methode false zurück. Beispiel:
- Angenommen counter hat den Wert 58 und das limit ist 60. Dann ist der neue Wert von counter 59 und die Methode gibt true zurück.
- Angenommen counter hat den Wert 59 und das limit ist 60. Dann ist der neue Wert von counter 0 und die Methode gibt false zurück.
Überschreiben Sie die Methode public String toString(). Diese Methode gibt den Wert von counter als zweistelligen String zurück. Beachten Sie
- Ist der Wert von counter einstellig, z.B. 5, dann soll der String "05" zurückgegeben werden.
Implementieren Sie eine Methode public void print(). Diese Methode gibt den aktuellen Wert von counter unter Verwendung der Methode toString() auf die Konsole aus.

Geben Sie in der main()-Methode der Programmklasse ein:

System.out.printf("%n---------------- Test Counter -----------%n%n");

Counter counter = new Counter(60);
for(int i=0; i<120; i++)
{
    counter.increase();
    System.out.printf("%3d : ", i);
    counter.print();
}

und führen Sie die Testklasse aus. Es sollten folgende Ausgaben erzeugt werden:

Ausgabe auf der Konsole

---------------- Test Counter -----------

  0 : 01
  1 : 02
  2 : 03
  3 : 04
  4 : 05
  5 : 06
  6 : 07
  7 : 08
  8 : 09
  9 : 10
 10 : 11
 11 : 12
 12 : 13
 13 : 14
 14 : 15
 15 : 16
 16 : 17
 17 : 18
 18 : 19
 19 : 20
 20 : 21
 21 : 22
 22 : 23
 23 : 24
 24 : 25
 25 : 26
 26 : 27
 27 : 28
 28 : 29
 29 : 30
 30 : 31
 31 : 32
 32 : 33
 33 : 34
 34 : 35
 35 : 36
 36 : 37
 37 : 38
 38 : 39
 39 : 40
 40 : 41
 41 : 42
 42 : 43
 43 : 44
 44 : 45
 45 : 46
 46 : 47
 47 : 48
 48 : 49
 49 : 50
 50 : 51
 51 : 52
 52 : 53
 53 : 54
 54 : 55
 55 : 56
 56 : 57
 57 : 58
 58 : 59
 59 : 00
 60 : 01
 61 : 02
 62 : 03
 63 : 04
 64 : 05
 65 : 06
 66 : 07
 67 : 08
 68 : 09
 69 : 10
 70 : 11
 71 : 12
 72 : 13
 73 : 14
 74 : 15
 75 : 16
 76 : 17
 77 : 18
 78 : 19
 79 : 20
 80 : 21
 81 : 22
 82 : 23
 83 : 24
 84 : 25
 85 : 26
 86 : 27
 87 : 28
 88 : 29
 89 : 30
 90 : 31
 91 : 32
 92 : 33
 93 : 34
 94 : 35
 95 : 36
 96 : 37
 97 : 38
 98 : 39
 99 : 40
100 : 41
101 : 42
102 : 43
103 : 44
104 : 45
105 : 46
106 : 47
107 : 48
108 : 49
109 : 50
110 : 51
111 : 52
112 : 53
113 : 54
114 : 55
115 : 56
116 : 57
117 : 58
118 : 59
119 : 00

Erstellen Sie im package eine weitere Klasse Clock. In der Klasse Clock verwenden Sie zwei Counter. Der eine Counter zählt die minutes und hat das limit 60 und der andere Counter zählt die hours und hat das limit 24.
In der Klasse Clock erstellen Sie zwei Objektvariablen minutes und hours, jeweils vom Typ Counter (beide nur in der Klasse sichtbar).
Erstellen Sie einen parameterlosen Konstruktor public Clock(). Darin erzeugen Sie für minutes das Counter-Objekt mit dem limit 60 und für hours das Counter-Objekt mit dem limit 24.
Implementieren Sie eine Methode public void increase(). Diese Methode soll den Wert von minutes um 1 erhöhen. Sollte jedoch das limit von minutes erreicht sein, wird auch hours um 1 erhöht. Nutzen Sie die increase()-Methode von Counter!
Überschreiben Sie die Methode public String toString(). Diese Methode gibt die Werte von minutes und hours in der Form hh:mmals String zurück, also z.B. "23:59" oder "01:09". Nutzen Sie die toString()-Methode von Counter!
Implementieren Sie eine Methode public void print(). Diese Methode gibt den aktuellen Wert von Clock unter Verwendung der Methode toString() auf die Konsole aus.

Fügen Sie in der main()-Methode der Programmklasse folgende Anweisungen hinzu:

System.out.printf("%n----------------- Test Clock ------------%n%n");

Clock clock = new Clock();
for(int i=0; i<1600; i++)
{
    clock.increase();
    if(i%50==0)
    {
        System.out.printf("%4d : ", i);
        clock.print();
    }
}

und führen Sie die Programmklasse aus. Es sollten folgende zusätzliche Ausgaben erzeugt werden:

Ausgabe auf der Konsole

----------------- Test Clock ------------

   0 : 00:01
  50 : 00:51
 100 : 01:41
 150 : 02:31
 200 : 03:21
 250 : 04:11
 300 : 05:01
 350 : 05:51
 400 : 06:41
 450 : 07:31
 500 : 08:21
 550 : 09:11
 600 : 10:01
 650 : 10:51
 700 : 11:41
 750 : 12:31
 800 : 13:21
 850 : 14:11
 900 : 15:01
 950 : 15:51
1000 : 16:41
1050 : 17:31
1100 : 18:21
1150 : 19:11
1200 : 20:01
1250 : 20:51
1300 : 21:41
1350 : 22:31
1400 : 23:21
1450 : 00:11
1500 : 01:01
1550 : 01:51

Übung 8

Erstellen Sie ein package uebungen.uebung8.
Erstellen Sie in diesem package eine Klasse Uebung8 mit main()-Methode.
Implementieren Sie eine public static void print(char[] ca)-Methode, so dass das char[] ca auf die Konsole ausgegeben wird. Achten Sie darauf, dass hinter dem letzten Element kein Komma steht. Testen Sie Ihre Methode auch für ein leeres Array.
Bsp: print(['a', 'b', 'c', 'a', 'c', 'a', 'b', 'c'])
Ausgabe auf Konsole: [a, b, c, a, c, a, b, c]
Kopieren Sie die print-Methode vollständig und ändern Sie den Typ des Parameters von char[] in int[]. (Die Methode ist jetzt überladen und print() kann jetzt entweder ein char[] oder ein int[] übergeben werden, welches auf die Konsole ausgegeben wird.)
Bsp: print([4, 2, 8, 1, 6, 2, 4, 1, 8])
Ausgabe auf Konsole: [8, 1, 4, 2, 6, 1, 8, 2, 4]
Implementieren Sie eine Methode public static char[] stringToCharArray(String s). Diese Methode wandelt einen String in ein char[] um, so dass jedes Zeichen des Strings im char[] enthalten ist. Das char[] wird zurückgegeben. Tipps: die Länge eines Strings wird mit der Objektmethode length() ermittelt. Die einzelnen Zeichen eines Strings können mithilfe der charAt(index)-Objektmethode von Strings ermittelt werden. Siehe String
Bsp.: stringToCharArray("hallo!") → ['h','a','l','l','o','!']
Implementieren Sie eine Methode public static int[] minAndMax(int[] iarr), der ein int-Array als Parameter übergeben wird und die ein zweielementiges Array zurückgibt. Das erste Element des zurückgegeben Arrays ist das Minimum des als Parameter übergebenen Arrays und das zweite Element ist das Maximum.
Bsp.: minAndMax([4,2,8,1,6,2,4,1,8]) → [1,8]
minAndMax([4]) → [4,4]
Implementieren Sie eine Methode public static int[] reverse(int[] iarr), der ein int-Array übergeben wird und die die Reihenfolge der Elemente des Arrays umdreht (das letzte zuerst usw.) Das neuerstellte Array wird zurückgegeben.
Bsp.: reverse([4,2,8,1,6,2,4,1,8]) → [8,1,4,2,6,1,8,2,4]
reverse([4]) → [4]
Zusatz:
- Implementieren Sie eine Methode public static char[] filter(char[] carr, char filter), der als Parameter ein char-Array und ein char übergeben wird. Die Methode soll ein char-Array zurückgeben, das dem als Parameter übergeben Array entspricht, außer dass jedes Vorkommen des als Parameter übergeben carr entfernt wurde
  Bsp: filter(['a', 'b', 'c', 'a', 'c', 'a', 'b', 'c'], 'c') → ['a', 'b', 'a', 'a', 'b']
- Implementieren Sie eine Methode public static boolean containsDoublets(char[] ca) die ein true zurückgibt, wenn mindestens ein Wert in ca mindestens zwei Mal vorkommt (wenn Sie schon dabei sind, können Sie sich auch überlegen, wenn genau ein Wert genau zwei Mal vorkommt - oder mindestens ein Wert genau zwei Mal - oder genau ein Wert mindestens zwei Mal) und false sonst.

Übung 9

Erstellen Sie ein package uebungen.uebung9.
Erstellen Sie in diesem package eine Klasse Uebung9 mit main()-Methode.
Vorabinformation:
- Wir implementieren Würfe eines Würfels. Alle Würfe werden in einem Array statistics gespeichert. Das Array hat die Länge 6 und beschreibt, wie oft eine 1, wie oft eine 2, ..., wie oft eine 6 gewürfelt wurde.
Erstellen Sie sich in der main()-Methode zunächst das statistics-Array. Alle Elemente des Arrays sind vom Typ int und es hat die Länge 6.

Implementieren Sie folgende Methoden:

Implementieren Sie eine public static int throwDice()-Methode, die eine Zufallszahl aus dem Wertebereich [1, ... , 6] erzeugt und zurückgibt.
Implementieren Sie eine Methode public static void printThrow(int cast), die den Wert des übergebenen Wurfes (cast) wie folgt ausgibt (Beispiel cast==5):
```
Es wurde eine 5 gewuerfelt
```

Testen Sie beide Methoden, indem Sie in der main()-Methode eingeben:

System.out.printf("%n%n------------------- Test throwDice and printThrow -------------------%n%n");
for(int index=0; index<10; index++)
{
    int cast = throwDice();
    printThrow(cast);
}

Sie sollten eine Ausgabe in folgender Form bekommen (Zufallszahlen):

------------------- Test throwDice and printThrow -------------------

Es wurde eine 5 gewuerfelt
Es wurde eine 4 gewuerfelt
Es wurde eine 6 gewuerfelt
Es wurde eine 5 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 4 gewuerfelt
Es wurde eine 1 gewuerfelt
Es wurde eine 5 gewuerfelt
Es wurde eine 6 gewuerfelt
Es wurde eine 6 gewuerfelt

Implementieren Sie eine Methode public static void insertIntoStatistics(int[] statistics, int cast). Das statistics-Array wird als Parameter übergeben und auch der gewürfelte cast. Im statistics-Array wird der Wert an der Stelle um 1 erhöht, der dem Wurf cast entspricht. D.h. wurde eine 1 gewürfelt, wird der Wert im Index 0 um 1 erhöht, wurde eine 2 gewürfelt, der Wert im Index 1 usw. (siehe auch oben die Abbildung zu statistics)
Implementieren Sie eine Methode public static void printStatistics(int[] statistics), die das statistics-Array wie folgt auf die Konsole ausgibt.

Angenommen, das statistics-Array ist so befüllt: [ 3,8,4,5,8,2 ], dann ist die Ausgabe auf der Konsole:
```
[ (3 x 1), (8 x 2), (4 x 3), (5 x 4), (8 x 5), (2 x 6) ]
```

Testen Sie beide Methoden, indem Sie in der main()-Methode eingeben:

System.out.printf("%n%n------------------ Test insert- and printStatistics -----------------%n%n");
for(int index=0; index<100; index++)
{
    int cast = throwDice();
    insertIntoStatistics(statistics, cast);
}
printStatistics(statistics);

Es wird angenommen, dass Sie das statistics-Array bereits gleich am Anfang in der main() erzeugt haben - wenn nicht, können Sie das auch hier machen.

Sie sollten eine Ausgabe in folgender Form bekommen (Zufallszahlen):

------------------ Test insert- and printStatistics -----------------

[  (20 x 1), (13 x 2), (16 x 3), (15 x 4), (19 x 5), (17 x 6) ]

Implementieren Sie eine Methode public static int sumOfStatistics(int[] statistics), die eine Summe über alle Werte im statistics-Array wie folgt berechnet:

Beispiel: Angenommen, das Array ist so befüllt: [ 3,8,4,5,8,2 ], dann ist die Summe: 3x1 + 8x2 + 4x3 + 5x4 + 8x5 + 2x6 = 3 + 16 + 12 + 20 + 40 + 12 = 103. Die Summe 103 wird zurückgegeben.

Testen Sie die Methode, indem Sie in der main()-Methode eingeben:

System.out.printf("%n%n--------------------- Test sumOfStatistics --------------------------%n%n");
printStatistics(statistics);
int sumTest = sumOfStatistics(statistics);
System.out.println("Summe = " + sumTest);

Das statistics-Array ist ja bereits oben befüllt worden, das müssen wir hier also nicht mehr machen. Sie sollten eine Ausgabe in folgender Form bekommen (Zufallszahlen):

--------------------- Test sumOfStatistics --------------------------

[  (14 x 1), (15 x 2), (11 x 3), (16 x 4), (27 x 5), (17 x 6) ]
Summe = 378

Zusatz: Implementieren Sie eine Methode public static int throwDiceUntilTarget(int target, int[] statistics), die so lange einen Würfel würfelt, bis als Summe der Augen das target erreicht ist. Die Anzahl der Würfe wird zurückgegeben. In dieser Methode erfolgen folgende Aufrufe:
- nach jedem Wurf (throwDice()) wird der Wurf ausgegeben (printThrow())
- jeder Wurf wird in das statistics-Array eingetragen (insertIntoStatistics())
- nach jedem Wurf wird die Summme aller Augen aller bisherigen Würfe ermittelt (sumOfStatistics()).
- so lange die Summe kleiner ist als das target, wird weiter gewürfelt

Testen Sie die Methode, indem Sie in der main()-Methode eingeben:

System.out.printf("%n%n------------------- Test throwDiceUntilTarget -----------------------%n%n");
statistics = new int[6];    // altes Array war schon befuellt 
final int TARGET = 100;
int tries = throwDiceUntilTarget(TARGET, statistics);
printStatistics(statistics);
int sum = sumOfStatistics(statistics);
System.out.println("Es wurden " + tries + " Versuche benötigt, um " + sum + " Punkte zu erzielen.");

Da das statistics-Array zuvor bereits befüllt war, erstellen wir es für das Testen dieser Methode nochmal neu. Sie sollten eine Ausgabe in folgender Form bekommen (Zufallszahlen):

------------------- Test throwDiceUntilTarget -----------------------

Es wurde eine 5 gewuerfelt
Es wurde eine 1 gewuerfelt
Es wurde eine 5 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 5 gewuerfelt
Es wurde eine 2 gewuerfelt
Es wurde eine 5 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 4 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 1 gewuerfelt
Es wurde eine 1 gewuerfelt
Es wurde eine 2 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 6 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 2 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 2 gewuerfelt
Es wurde eine 6 gewuerfelt
Es wurde eine 4 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 1 gewuerfelt
Es wurde eine 4 gewuerfelt
Es wurde eine 3 gewuerfelt
Es wurde eine 4 gewuerfelt
Es wurde eine 1 gewuerfelt
Es wurde eine 6 gewuerfelt
[  (5 x 1), (4 x 2), (11 x 3), (4 x 4), (4 x 5), (3 x 6) ]
Es wurden 31 Versuche benötigt, um 100 Punkte zu erzielen.

Es muss das target nicht exakt getroffen werden, das ist Zufall. Es stoppt, sobald 100 oder mehr Punkte erreicht wurden.

Übung 10

Erstellen Sie ein package uebungen.uebung10.
Erstellen Sie in diesem package eine Klasse Lottery mit
- der privaten Objektvariablen drawingResults vom Typ int[].
  Information: Lottery steht für eine Lotterie, bei der aus 9 Zahlen (1..9) 5 Zahlen zufällig gelost werden (5 aus 9). Das Array drawingResults dient zum Speichern der gezogenen 5 Zahlen.
- Schreiben Sie für die Klasse Lottery einen parameterlosen Konstruktor. In diesem Konstruktor wird das Array drawingResults mit der Länge 5 erzeugt.
- Schreiben Sie eine Objektmethode contains(int number). Diese Methode gibt ein true zurück, wenn number in drawingResults enthalten ist und false sonst.
- Schreiben Sie eine Objektmethode drawing(). In dieser Methode werden die 5 Zufallszahlen gezogen (5 aus 9). Sie benötigen dafür ein Objekt der Klasse Random (Random muss aus java.util importiert werden). „Ziehen“ Sie nun zufällig 5 Zufallszahlen aus dem Bereich 1..9 (1 und 9 inklusive) und speichern Sie diese im Array drawingResults.
  Achtung: Die gleiche Zahl darf nicht doppelt gezogen (gespeichert) werden! D.h. die 5 im Array gespeicherten Zufallszahlen müssen sich voneinander unterscheiden!
- Schreiben Sie eine Objektmethode sort(). Diese Methode sortiert das Array drawingResults aufsteigend (von klein nach groß).
- Überschreiben Sie die Objektmethode toString(), die das drawingResult-Array als String in folgender Form zurückgibt (Beispielwerte für den Fall, dass 1, 3, 5, 6, 7 gezogen wurden):
```
( 1 - 3 - 5 6 7 - - )
```
  1. das dawingResult-Array wird zunächst sortiert
  2. ist die Zahl im Array enthalten, wird sie als Wert angezeigt
  3. ist die Zahl nicht enthalten, wird ein - angezeigt
  4. d.h. es werden immer die 5 gezogenen Zahlen ausgegeben und 4 Striche.
- Schreiben Sie eine Objektmethode print(), die den von toString()zurückgegebenen String auf der Konsole ausgibt.

Erstellen Sie im gleichen package eine Klasse Programmklasse mit main()-Methode.

Erzeugen Sie in der main()-Methode in einer Schleife 10 Objekte der Klasse Lottery und rufen (auch in der Schleife) jeweils die drawing() und die print()-Methode auf. Es entsteht folgende Ausgabe (Beispielwerte sind zufällig und unterscheiden sich!):

( 1 - 3 - 5 6 7 - - )
( 1 2 3 - 5 - 7 - - )
( 1 - 3 - - 6 7 8 - )
( - - 3 4 5 6 - - 9 )
( 1 2 3 4 - - - - 9 )
( 1 2 - 4 - 6 - 8 - )
( - 2 3 - - - 7 8 9 )
( 1 2 3 - - 6 - - 9 )
( 1 - - 4 5 - 7 8 - )
( - 2 3 - 5 - - 8 9 )

Zusatz::
- Implementieren Sie in der Klasse Lottery eine Objektmethode isEqual(Lottery other), die ein true zurückgibt, wenn das aufrufende Objekt das gleiche drawingResults-Array enthält, wie other (also die Werte darin jeweils gleich sind).
  Tipp: Implementieren Sie die Methode am einfachsten so, dass Sie die beiden drawingResult-Arrays erst sortieren und dann die sortierten Arrays elementweise miteinander vergleichen.
- Erzeugen Sie ein Objekt von Lottery und rufen für dieses Objekt die drawing()-Methode auf. Erzeugen Sie in einer Schleife so lange ein weiteres Objekt von Lottery und rufen dafür die drawing()-Methode auf, bis die beiden Objekte die gleichen gezogenen Zahlen enthalten, d.h. laut isEqual()-Methode gleich sind. Geben Sie dann beide Objekte mithilfe der print()-Methode aus. Es entsteht folgende Ausgabe (zufällige Beispielwerte):
```
( 1 - 3 - - 6 - 8 9 )
( 1 - 3 - - 6 - 8 9 )
```

Übung 11

Übung 11 (pdf)

Übung 12

Implementieren Sie eine Methode, die überprüft, ob ein gegebener String doppelte Zeichen enthält. Von der String-Klasse dürfen nur die Methoden length() und charAt(int) verwendet werden.

Was ist Ihre algorithmische Idee?
Welche Hilfsmethoden benötigen Sie?

Zusatz (Es dürfen weiterhin nur die Methoden length() und charAt(int) von der Klasse String verwendet werden)

Wie oben, aber Groß-und Kleinschreibung wird ignoriert.
Implementieren Sie die startsWith()-Methode der Klasse String nach.
Implementieren Sie die replace(char, char)-Methode der Klasse String nach.
Implementieren Sie die split(char)-Methode der Klasse String nach.