Programmieren II

Herzlich willkommen zur Programmieren II-Veranstaltung! Wir haben in Programmieren I unter Verwendung der Programmiersprache Java bereits wesentliche Konzepte kennengelernt, die für das Verständnis moderner Programmierens notwendig sind. Diese Kenntnisse wollen wir nun erweitern und vertiefen. Wir werden Git kennenlernen, Exceptions, Wrapper-Klassen, Interfaces und Collections. Wir beschäftigen uns intensiv mit dem Testen von Programmen und erzeugen uns eigene Nutzeroberflächen. Hier einige Tipps, damit Sie die Veranstaltung erfolgreich durchführen und Sie dabei auch Spaß haben:

1. Lösen Sie alle Übungsaufgaben selbständig! Es ist kein Problem, wenn Sie für das Bewältigen der Übungen etwas länger benötigen. Sollten Sie es gar nicht alleine schaffen, ist das auch kein Problem. Wichtig ist dann, dass Sie sich die Lösung anschauen und es erneut selbständig versuchen. Hören Sie nicht auf, bis Sie es geschafft haben!
2. Sie können die Hausaufgaben zu zweit lösen. Achten Sie aber darauf, dass Sie Ihre gemeinsame Lösung vollständig verstanden haben und dass Sie sie danach auch alleine erstellen können. Sie können beim Lösen der Hausaufgaben beliebig kreativ sein! Die Aufgabenstellung gibt Ihnen Anhaltspunkte für eine eventuelle Lösung. Sie können es aber auch ganz anders machen!
3. Die Klausurvorbereitung beginnt mit Beginn der Veranstaltung. Es ist nicht möglich, die Klausur am Ende des Semesters zu bestehen, wenn Sie nicht das ganze Semester über intensiv programmieren. Die Übungsaufgaben sind "kleine" Aufgaben, um das in der Vorlesung vermittelte Wissen direkt anzuwenden. Für die Lösung der Hausaufgaben ist bereits ein gewisses Abstraktionsniveau erforderlich, um zu erkennen, dass das in der Vorlesung vermittelte Wissen dafür ausreichend ist.
4. Programmieren lernt man nur durch Programmieren. Sie müssen es tun. Das Lesen von Büchern oder das "Anschauen" von Code genügt nicht. Eine Sprache lernt man auch nur durch Sprechen. Sie müssen programmieren, programmieren, programmieren...
5. Lassen Sie sich durch Fehler nicht verunsichern, sondern analysieren Sie Ihre Fehler. Bis zur Klausur sollten Sie alle Fehler einmal gemacht haben. Wenn Sie sich überlegen, warum das jeweils ein Fehler war, dann werden Sie diesen Fehler nicht wiederholen und haben durch die Reflektion eine Menge gelernt. Fehler zu machen (und darüber zu reflektieren) gehört zu den besten Lernmethoden des Programmierens.
6. Haben Sie Spaß! Je mehr Sie das Programmieren lernen, je mehr Spaß werden Sie haben. Wir versuchen, dass Sie das ganze Semester über Spaß am Programmieren haben werden. Sollte es Ihnen zwischendurch keinen Spaß mehr machen, geben Sie mir sofort Bescheid!

Viel Erfolg! Und viel Spaß!

Organisatorisches

Der Plan zur Durchführung der Veranstaltung ist derzeit wie folgt:

• Themen werden ausführlich in diesem Skript beschrieben und in den Vorlesungen eingeführt und verdeutlicht.
• Die Veranstaltungen finden in Präsenz statt. Es werden keine Videos erstellt.
• Das Skript wird für die jeweils kommende Woche freitags hochgeladen.
• Mit dem Skript wird sowohl die Übung für die kommende Woche als auch die neue Aufgabe hochgeladen.
• Sie können frei wählen, welche der beiden Übungen Sie besuchen.
• Die Veranstaltung wird durch ein Tutorium unterstützt. Der Termin für das Tutorium wird noch bekanntgegeben.
• Sollten Sie Wünsche haben, diesen Plan zu ändern, kommen Sie gerne auf mich zu

Zur erfolgreichen Durchführung der Veranstaltung sollten Sie die Aufgaben lösen und zu den jeweiligen Fristen auf Moodle hochladen. Es werden insgesamt wahrscheinlich 10 Aufgaben sein, die Sie selbständig lösen und hochladen. Sie können die Aufgaben auch zu zweit lösen. Am Ende des Semesters schreiben wir eine Klausur (am Rechner). Diese Klausur wird bewertet und entspricht der Note für das gesamte "Programmieren"-Modul. Bitte beachten Sie, dass das Modul erfahrungsgemäß nur dann bestanden werden kann, wenn Sie die Übungen und Aufgaben selbstständig lösen können. Selbst wenn Ihnen zunächst eine eigene Lösung schwerfällt, müssen Sie es irgendwann im Laufe des Semsters - am besten, jeweils so schnell wie möglich - schaffen, diese Aufgaben selbstständig zu implementieren.

Unter Aufgaben sind die Aufgaben beschrieben, die Sie in jeder Woche ausführen sollen. Damit Sie dies erfolgreich erledigen können, ist jeweils angegeben, welche Themen Sie dafür durcharbeiten müssen. Das Durcharbeiten der jeweiligen Themen entspricht jeweils einer Vorlesung.

Daneben gibt es jede Woche (zu jedem Thema) Übungen, die wir in den Übungszeiten besprechen. Diese dienen der Anwendung und der Festigung der erlangten Kenntnisse. Die Übungen sind kleine Aufgaben, an denen Sie das neue Wissen anwenden sollen. Die Übungen dienen der Befähigung, die (größeren) Aufgaben lösen zu können.

Für die Kommunikation untereinander verwenden wir Slack. Dort können Sie alle inhaltlichen und organisatorischen Fragen stellen. Ich fände es gut, wenn ich dort möglichst wenig Fragen - zumindest die inhaltlichen - beantworten müsste, sondern eine Art internes Diskussionsforum entsteht. Es ist sehr gewünscht, dort Fragen zu stellen und noch mehr gewünscht, diese von Ihnen dort beantwortet zu sehen. Damit wäre allen geholfen und ich kann besser erkennen, wo noch Nachhol- bzw. Erläuterungsbedarf bei den meisten besteht. Außerdem lernen Sie beim Beantworten der Fragen nochmals deutlich mehr. Das wäre super, wenn das klappt!

Grober Inhalt (kann sich noch ändern)

Wir beschäftigen uns dieses Semester mit weiteren Konzepten der Programmierung. Wir lernen weitere Datenstrukturen kennen (Collections), werden lernen, mit Exceptions umzugehen und implementieren Tests. Wir beschäftigen uns mit Grafischen Nutzeroberflächen (GUIs) und lernen, Nutzereignisse zu behandeln.

Nachfolgend der vorläufige Wochenplan (wird eventuell angepasst).

	Woche	Themen (Vorlesung)	Übung	Aufgabe	Abgabe Aufgabe bis
1.	07.-11.04.2025	Organisatorisches, Wiederholung, Einstieg	Übung 2	-	-
1.	14.-18.04.2025	Aufzählungstypen, Wrapper-Klassen (boxing und unboxing)	Übung 3	Aufgabe 1	27.04.2025
2.	21.-25.04.2025	Exceptions	Übung 4	Aufgabe 2	04.05.2025
3.	28.-02.05.2025	eigene Exceptions	Übung 5	Aufgabe 3	18.05.2025
4.	05.-09.05.2025	Collections (List und Set)	Übung 6	Aufgabe 4	25.05.2025
5.	12.-15.05.2025	Collections (Map) und Abstrakte Klassen	Übung 7	Aufgabe 5	01.06.2025
6.	19.-23.05.2025	Interfaces	Übung 8	Aufgabe 6	08.06.2025
7.	26.-30.05.2025	Lambdas	Übung 9	Aufgabe 7	15.06.2025
8.	02.-06.06.2025	Java-Streams	Übung 10	Aufgabe 8	22.06.2025
9.	09.-13.06.2025	Genererics	Übung 11	Aufgabe 9	29.06.2025
10.	16.-20.06.2025	JUnit	Übung 12	Aufgabe 10	06.07.2025
11.	23.-27.06.2025	Test driven development	Übung 13	-	-
12.	30.-04.07.2025	Klausurvorbereitung	Übung 14	-	-
13.	07.-11.07.2025	Klausurvorbereitung	Übung 15	-	-
	14.07.2025 09:45 Uhr	Klausur 1.PZ	C 635 und C 639	-	-
	29.09.2025 09:45 Uhr	Klausur 2.PZ	Labore 6. Etage C-Gebäude	-	-

Inhalte

Einführung und Organisatorisches + Wiederholung + Einstieg

• siehe Organisatorisches
• siehe Wiederholung
• siehe Einstieg
• siehe Übung 2

Code aus der Vorlesung 09.04.2025

Main.javaRectangle.java

import javax.swing.*;
import java.util.Arrays;

public class Main
{
    public static void main(String[] args)
    {
         int[] numbers = {1, 2,  3, 4, 5, 6, 7, 8, 9, 10};
         for(var values : numbers)
         {
             System.out.print(values + ", ");
         }
         System.out.println(Arrays.toString(numbers));

         String s1 = "Hello FIW! \n " + "Welcome to FIW!";
         String s2 = """
                 Hello FIW!
                 Hello FIW!
                 Welcome to FIW!
                 <html>
                    <h1>Hello FIW!</h1>
                    <p>Hello FIW!</p>
                        <a href="www."
                 </html>""";
         System.out.println(s2 + " Hallo ");

         Rectangle r1  = new Rectangle(5, 6);
         Rectangle r2 = new Rectangle(6, 7);
         Rectangle r3 = new Rectangle(5, 6);
         System.out.println(r1.toString());
         System.out.println(r2.toString());
         System.out.println(r3.toString());
         System.out.println("r1 equals r2 ?  " + r1.equals(r2));
         System.out.println("r1 equals r3 ?  " + r1.equals(r3));

         JOptionPane.showMessageDialog(null, "Hello FIW!", "Titel FIW!", JOptionPane.QUESTION_MESSAGE);
         String input = JOptionPane.showInputDialog(null, "Geben Sie eine Zahl ein:");
         System.out.println("Sie haben " + input + " eingegeben");
    }
}

public record Rectangle(double width, double length){}

Aufzählungstypen und Wrapper-Klassen

• siehe Aufzählungstypen
• siehe Wrapper-Klassen (boxing und unboxing)
• siehe Übung 3
• siehe Aufgabe 1

Code aus der Vorlesung 14.04.2025

Vorlesung1404.javaDay.java

package vorlesungen.vorl1404;

import javax.swing.*;

public class Vorlesung1404
{
    enum Ziffern {N0, N1,  }
    public static boolean istWochenende(Day tag)
    {
        return (tag == Day.SAMSTAG || tag == Day.SONNTAG);
    }

    public static boolean istWochentag(Day tag)
    {
        return !istWochenende(tag);
    }
    public static void main(String[] args)
    {
        String tag = "hallo";
        int day = 0;    // Montag
        Day dayTag = Day.DIENSTAG;

        System.out.println(istWochentag(dayTag));

        String eingabe = JOptionPane.showInputDialog(null, "Geben Sie ein Zahl ein : ");
        System.out.println("Ihre Eingabe war " + eingabe);

        Integer io1 = Integer.valueOf(-1234);
        Double do1 = Double.valueOf(-1234.0);
        Integer io2 = 1234;
        Double do2 = 1234.0;

        int wert1 = io1.intValue();
        double wert2 = do1.doubleValue();
        int wert3 = io1;

        String si1 = "1234";
        Integer io3 = Integer.valueOf(eingabe);
        int wert4 = Integer.parseInt(eingabe);
        System.out.println("Eingabe war " + wert4);

        String s = io3.toString();

        Integer io5 = 5000;
        Integer io6 = 5000;
        Integer io7 = 5001;
        System.out.println(io5 == io6);
        System.out.println(io7 >= io6);

        Float fo1 = Float.valueOf("-1234.0");
        Float fo2 = -1234.0f;
        float f3 = fo1.floatValue();

        int[][] matrix = new int[3][4];
        for(int row = 0; row < matrix.length; row++)
        {
            for(int col = 0; col < matrix[row].length; col++)
            {
                matrix[row][col] = (row + 1) * (col + 1);
                System.out.print(row + "," + col + " ");
            }
            System.out.println();
        }

        System.out.println();

        for(int row = 0; row < matrix.length; row++)
        {
            for(int col = 0; col < matrix[row].length; col++)
            {
                System.out.print(matrix[row][col] + " ");
            }
            System.out.println();
        }
    }
}

package vorlesungen.vorl1404;

public enum Day
{
    MONTAG, DIENSTAG, MITTWOCHE, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG
}

Exceptions behandeln (try-catch, throws)

• siehe Exceptions
• siehe Übung 4
• siehe Aufgabe 2

Code aus der Vorlesung 23.04.2025

package vorlesungen.vorl1423;

import javax.swing.*;

public class Ausnahmen
{
    static char charAt(String s, int index) throws Exception
    {
        char c = ' ';
        c = s.charAt(index);
        return c;
    }

    static int divide(int divident, int divisor) throws ArithmeticException
    {
        int result = 0;
        result = divident / divisor; // kritisch, wenn divisor 0
        return result;
    }

    static int inputInt()
    {
        boolean validInput = false;
        int number = 0;
        String message = "Geben Sie eine Zahl ein!";
        while(!validInput)
        {
            String input = JOptionPane.
                    showInputDialog(null,message
                            );

            try {
                number = Integer.parseInt(input);
                validInput = true;      // nur ausgefuehrt, wenn keine
                                        // Exception geworfen wurde
            } catch (RuntimeException e) {
                message = "Das war keine Zahl! Bitte Zahl!";
            }
        }
        return number;
    }

    public static void main(String[] args)
    {
        char c = ' ';
        try {
            c = charAt("Hallo", 7);
        } catch(Exception e)
        {
            e.printStackTrace();
        }
        System.out.println(c);

        int result = 0;
        try {
            result = divide(10, 0);
        } catch(ArithmeticException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }

        System.out.println(result);

        System.out.println(inputInt());

        String[] basen = {"2", "8", "10", "Hi"};
        for(int index = 0; index <= 4; index++)
        {
            try {
                String wert = basen[index];

                int number = Integer.parseInt(wert);
            }
            catch(NumberFormatException e) {
                System.err.println("keine Zahl!");
            }
            catch(ArrayIndexOutOfBoundsException e) {
                System.err.println("kein passender Index!");
            }
        }
        System.out.println("Ende");
    }
}

eigene Exceptions werfen (throw)

• siehe Exceptions
• siehe Übung 5
• siehe Aufgabe 3

Code aus der Vorlesung 28.04.2025

Programmklasse.javaTriangle.javaIllegalSideLengthException.javaIllegalTriangleException.java

package vorlesungen.vorl0428;

import java.util.HashSet;
import java.util.Set;

public class Programmklasse
{
    public static void mehrereExceptions()
    {
        String[] basen = {"2", "8", "10", "Hi"};
        int base = 0;
        double result= 0;
        boolean ok = true;

        for(int index = 0; index<=4; index++)
        {
            try {
                base = Integer.parseInt(basen[index]);
                ok = true;
            }
            catch(NumberFormatException nfe) {
                System.out.println("Keine Zahl!");
                ok = false;
            }
            catch(IndexOutOfBoundsException ioobe) {
                System.out.println("Ausserhalb des Arrays");
                ok = false;
            }
            for(int exp = 0; exp<6 && ok; exp++) {
                result = Math.pow(base, exp);
                System.out.printf("%d ^ %d = %.0f %n", base, exp, result);
            }
        }
    }

    static int getValueAtIndex(int[] field, int index) throws ArrayIndexOutOfBoundsException
    {
        return field[index];
    }

    public static void main(String[] args)
    {
        mehrereExceptions();

        int value = 0;
        boolean ok = true;
        int[] field = {8, 3,-4, 2, -9};
        try
        {
            value = getValueAtIndex(field,-3);
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("Index ausserhalb des Arrays!");
            ok = false;
        }
        if(ok)
        {
            System.out.println("value : " + value);
        }

        Triangle t = null;
        try {
            t = new Triangle(3, 0, 5);
        }
        catch(IllegalSideLengthException e) {
            System.out.println(e.getMessage());
        }
        catch(IllegalTriangleException e) {
            System.out.println(e.getMessage());
        }
        if(t == null) {
            System.out.println("kein Objekt!");
        }

        /*
        try {
            Triangle t2 = new Triangle(3, 1, 5);
        } catch (IllegalSideLengthException e) {
            throw new RuntimeException(e);
        } catch (IllegalTriangleException e) {
            throw new RuntimeException(e);
        }

         */

        int[] arr = { 1, 2, 3 };
        for(int el : arr)
        {
            System.out.println("element : " + el);
        }

        Set<String> s1 = new HashSet<>();     // Menge erzeugen
        s1.add("eins");
        s1.add("zwei");
        s1.add("drei");
        //s1.add(Integer.valueOf(4));     // prinzipiell moeglich, aber schlecht

        for(String element : s1)
        {
            System.out.println("element : " + element);
        }
    }
}

package vorlesungen.vorl0428;

public class Triangle
{
    private int a,b,c;

    public Triangle(int a, int b, int c) throws IllegalSideLengthException, IllegalTriangleException
    {
        if (a <= 0 || b <= 0 || c <= 0) {
            throw new IllegalSideLengthException("sides must be greater than zero! is: ("+a+","+b+","+c+")");
        }
        else if (a >= (b + c) || b >= (c + a) || c >= (a + b)) {
            throw new IllegalTriangleException();
        }
        else {
            this.a = a;
            this.b = b;
            this.c = c;
        }
    }
}

package vorlesungen.vorl0428;

public class IllegalSideLengthException extends Exception
{
    public IllegalSideLengthException(String message) {
        super(message);
    }

    public IllegalSideLengthException() {
        super("sides must be greater than zero!");
    }
}

package vorlesungen.vorl0428;

public class IllegalTriangleException extends Exception
{
    public IllegalTriangleException(String message)
    {
        super(message);
    }

    public IllegalTriangleException()
    {
        super("Illegal triangle!");
    }
}

Collections (Listen und Mengen)

• siehe Collections
• siehe Übung 6
• siehe Aufgabe 4

Code aus der Vorlesung 05.05.2025

package vorlesungen.vorl0505;

import java.util.*;

public class Vorlesung0505
{
    public static void main(String[] args)
    {
        System.out.printf("%n%n----------- Listen ------------------%n%n");
        List<String> list1 = new ArrayList<>();
        list1.add("eins");
        //list1.add(2);       // Integer
        list1.add("zwei");
        for(String str : list1)
        {
            System.out.println(str);
        }
        System.out.println(list1.size());
        list1.remove("eins");
        list1.remove(0);

        List<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        for(Integer i : list2)
        {
            System.out.print(i + " ");          // 1 2 3 4
        }
        Integer v1 = list2.get(0);  // Index 0
        System.out.println(v1);     // 1

        System.out.println();
        list2.remove(0);
        for(Integer i : list2)
        {
            System.out.print(i + " ");          // 2 3 4
        }
        // v1 = 1
        v1 = list2.get(0);              // Index 0
        // v1 = 2
        System.out.println(v1);         // 2
        list2.remove(Integer.valueOf(3));   // Objekt geloescht
        for(Integer i : list2)
        {
            System.out.print(i + " ");      // 2 4
        }
        System.out.println();
        list2.add(2);
        list2.add(4);
        list2.add(2);
        for(Integer i : list2)
        {
            System.out.print(i + " ");      // 2 4 2 4 2
        }
        System.out.println();
        System.out.println(list2.remove(Integer.valueOf(2)));
        for(Integer i : list2)
        {
            System.out.print(i + " ");      // 4 2 4 2
        }
        System.out.println();
        List<Integer> list3 = new ArrayList<>();
        list3.add(2);
        list3.add(3);
        list3.add(4);
        list2.removeAll(list3);             // false
        if(list2.size() == 0) System.out.println("list2 is empty");
        for(Integer i : list2)
        {
            System.out.print(i + " ");      // 4 2 4 2
        }
        System.out.println();
        list2.add(1);
        list2.add(2);
        list2.add(1);
        list2.add(1);
        list2.add(2);
        list2.add(1);
        Integer v3 = Integer.valueOf(1);
        while(list2.contains(v3))
        {
            list2.remove(v3);
        }

        System.out.printf("%n%n----------- Mengen ------------------%n%n");
        Set<String> set1 = new HashSet<>();
        System.out.println(set1.add("vier"));       // true
        System.out.println(set1.add("eins"));       // true
        System.out.println(set1.add("zwei"));       // true
        System.out.println(set1.add("zwei"));       // false
        System.out.println(set1.add("drei"));       // true
        for(String str : set1)
        {
            System.out.print(str + " ");        // eins vier zwei drei
        }

        System.out.printf("%n%n----------- Maps ------------------%n%n");
        Map<String, Double> map1 = new HashMap<>();
        map1.put("s05123456", 1.0);     // true
        map1.put("s05654321", 1.3);     // true
        map1.put("s05111111", 1.7);     // true
        map1.put("s05654321", 2.3);     // false

        Set<String> allKeys = map1.keySet();
        for(String key : allKeys)
        {
            System.out.print(key + " ");
        }
        System.out.println();
        Collection<Double> allValues = map1.values();
        for(Double val : allValues)
        {
            System.out.print(val + " ");
        }
        System.out.println();
        Set<Map.Entry<String, Double>> entries = map1.entrySet();
        for(Map.Entry<String, Double> entry : entries)
        {

        }

    }
}

Collections (Maps, Abstrakte Klassen und Interfaces)

• siehe Abstrakte Klassen
• siehe Interfaces
• siehe Übung 7
• siehe Übung 8
• siehe Aufgabe 5

Code aus der Vorlesung 12.05.2025

Vorlesung0512.javaShape.javaRectangle.javaCircle.java

package vorlesungen.vorl0512;

import java.util.*;

public class Vorlesung0512
{
    public static void printPerimeter(Shape shape)
    {
        System.out.println("Umfang ist " + shape.perimeter());
    }

    public static void printArea(Shape shape)
    {
        System.out.println("Flaecheninhalt ist " + shape.area());
    }

    public static void sortieren(Comparable[] unsorted)
    {
        for(int bubble = 1; bubble < unsorted.length; bubble++)
        {
            for(int index = 0; index < unsorted.length - bubble; index++)
            {
                if(unsorted[index].compareTo(unsorted[index + 1]) > 0)
                {
                    Comparable temp = unsorted[index];
                    unsorted[index] = unsorted[index + 1];
                    unsorted[index + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args)
    {
        Map<String, String> accounts = new HashMap();
        accounts.put("anton", "anton@email.de");
        accounts.put("berta", "berta@email.de");
        accounts.put("cesar", "cesar@email.de");
        accounts.put("anton", "anton2@email.de");

        String valueAnton = accounts.remove("anton");
        System.out.println(valueAnton);
        /* alle Schluessel */
        Set<String> allKeys = accounts.keySet();
        for(String key : allKeys)
        {
            System.out.print(key + " ");    // ceaser berta anton
        }
        System.out.println();

        /* alle Werte */
        Collection<String> allValues = accounts.values();
        for(String value : allValues)
        {
            System.out.print(value + " ");
        }
        System.out.println();

        /* alle Schluessel-Werte-Paare */
        Set<Map.Entry<String, String>> allEntries = accounts.entrySet();
        for(Map.Entry<String, String> entry : allEntries)
        {
            System.out.println("key : " + entry.getKey() + " , value : " + entry.getValue());
        }

        Shape s1 = new Circle(3.0);
        Shape s2 = new Rectangle(3,4);
        printPerimeter(s1);
        printArea(s1);
        printPerimeter(s2);
        printArea(s2);
        Circle c1 = new Circle(1.0);
        System.out.println(c1.perimeter());
        System.out.println(c1.area());
        System.out.println(c1.getDiameter());
        System.out.println(s1.perimeter());
        System.out.println(s1.area());
        //System.out.println(s1.getDiameter());     // keine Eigenschaft von Shape
        printPerimeter(c1);
        printArea(c1);

        Shape[] shapes = new Shape[4];
        shapes[0] = s1;
        shapes[1] = s2;
        shapes[2] = c1;
        shapes[3] = new Rectangle(4,2);
        for(Shape s : shapes)
        {
            printPerimeter(s);
            printArea(s);
            System.out.println(s.toString());
        }

        String str1 = "Anton";
        String str2 = "Berta";
        System.out.println(str1.compareTo(str2));

        Rectangle[] rectArr = new Rectangle[7];
        rectArr[0] = new Rectangle(9, 13);  // 117
        rectArr[1] = new Rectangle(4, 17);  // 68
        rectArr[2] = new Rectangle(12, 5);  // 60
        rectArr[3] = new Rectangle(8, 9);   // 72
        rectArr[4] = new Rectangle(10, 11); // 110
        rectArr[5] = new Rectangle(5, 15);  // 75
        rectArr[6] = new Rectangle(5, 10);  // 50
        System.out.printf("%n%n------------------------ unsortiert --------------------------%n%n");
        for(Rectangle r : rectArr)
        {
            System.out.println(r.toString());
        }
                /*
        System.out.printf("%n%n------------------------- sortiert ---------------------------%n%n");

        sortieren(rectArr);
        for(Rectangle r : rectArr)
        {
            System.out.println(r.toString());
        }

         */

        System.out.printf("%n%n------------------------- treeSet ---------------------------%n%n");
        Set<Rectangle> treeSet = new TreeSet<Rectangle>();
        for(Rectangle r : rectArr)
        {
            treeSet.add(r);
        }
        for(Rectangle r : treeSet)
        {
            System.out.println(r.toString());
        }
    }
}

package vorlesungen.vorl0512;

public abstract class Shape
{
    public abstract double perimeter();
    public abstract double area();

}

package vorlesungen.vorl0512;

public class Rectangle extends Shape
{
    int width;
    int height;

    public Rectangle(int width, int height)
    {
        this.width = width;
        this.height = height;
    }

    @Override
    public double perimeter()
    {
        return 2 * (this.width + this.height);
    }

    @Override
    public double area()
    {
        return this.width * this.height;
    }

    @Override
    public String toString()
    {
        return "Rectangle [width=" + this.width + ", height=" + this.height + "]";
    }
}

package vorlesungen.vorl0512;

public class Circle extends Shape
{
    double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }
    public double getDiameter()
    {
        return 2 * this.radius;
    }

    @Override
    public double perimeter()
    {
        return Math.PI * this.getDiameter();
    }

    @Override
    public double area()
    {
        return Math.PI * this.radius * this.radius;
    }

    @Override
    public String toString()
    {
        return "Circle [radius=" + this.radius + "]";
    }
}

Functional Interfaces und Lambdas

• siehe Functional Interfaces
• siehe Lambda-Ausdrücke
• siehe Übung 9
• siehe Aufgabe 6

Code aus der Vorlesung 26.05.2025

Main.java

package vorlesungen.vorl0526;

import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;

public class Main
{
    public static void printValue(Printable printable, String s)
    {
        printable.print(s);
    }

    public static void main(String[] args)
    {
        /*
        UseInterface useInterface = new UseInterface();
        printValue(useInterface, "Hallo FIW!");
         */

        /*
        printValue(new Printable(){

            @Override
            public void print(String s)
            {
                System.out.println(s);
            }
        }, "Hallo anonyme Klasse");
        */


        printValue(p1 -> System.out.println(p1), "Hallo!");

        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
        numbers.forEach(n -> System.out.println(n));
        numbers.forEach(System.out::println);

        numbers.forEach(Integer::valueOf);

        List<String> staedte = List.of("Berlin", "Hamburg", "München", "Köln", "Frankfurt am Main", "Düsseldorf",
                "Stuttgart", "Leipzig", "Dortmund", "Bremen", "Essen" ,"Dresden");

        staedte.forEach(stadt -> {
            System.out.print(stadt + " ");
            stadt = stadt.toUpperCase();
            System.out.println(stadt);
        });

        Consumer<String> printConsumer = message -> System.out.println(message);
        staedte.forEach(printConsumer);

        Function<String, Integer> lengthOfString = str -> str.length();
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;

    }
}

Printable.javaUseInterface.java

package vorlesungen.vorl0526;

@FunctionalInterface
public interface Printable
{
    // abstrakte Methode - Single Abstract Method (SAM)
    public void print(String s);

    // public void print(String s, int i);
    // in Functional Interfaces genau eine abtrakte Methode

    default void print()
    {
        print("default");
    }
}

package vorlesungen.vorl0526;

public class UseInterface implements Printable
{

    @Override
    public void print(String s)
    {
        System.out.println("UseInterface : " + s);
    }
}

Streams

• siehe Streams
• siehe Optionals
• siehe Übung 10
• siehe Übung 11
• siehe Aufgabe 7
• siehe Aufgabe 8

Code aus der Vorlesung 02.06.2025

Main.javaPerson.java

package vorlesungen.vorl0602;

import java.util.List;
import java.util.stream.Collectors;

public class Main
{
    private static List<Person> getPersonen() {
        List<Person> personen = List.of(
                new Person("Alice", "Ankara"),
                new Person("Alice", "Caracas"),
                new Person("Barbara", "Bern"),
                new Person("Barbara", "Damaskus"),
                new Person("Conny", "Caracas"),
                new Person("Conny", "Bern"),
                new Person("Daniela", "Damaskus"),
                new Person("Daniela", "Caracas"),
                new Person("Elvira","Bern" ),
                new Person("Elvira","Ankara" ),
                new Person("Frieda", "Caracas"),
                new Person("Gerda", "Ankara"),
                new Person("Hannah", "Hanoi"),
                new Person("Ina", "Islamabad"),
                new Person("Jana", "Hanoi")
        );
        return personen;
    }

    public static void main(String[] args)
    {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
        List<Integer> results = numbers.stream()
                .filter( e -> e % 2 == 0)
                .map( evenNumber -> evenNumber * 10 )
                .collect(Collectors.toList());

        results.forEach(s -> System.out.println(s));
    }
}

package vorlesungen.vorl0602;

public record Person(String name, String stadt){
    @Override
    public String toString()
    {
        return String.format("%s aus %s", name, stadt);
    }
}

Code aus der Vorlesung 16.06.2025

VorlesungStreams.java

package vorlesungen.vorl0616;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class VorlesungStreams
{
    public record Rectangle(int width, int length)
    {
        public int area()
        {
            return this.width * this.length;
        }
    }

    public static Optional<String> getValue(Map<String, String> map, String key)
    {
        if(map.containsKey(key))
        {
            return Optional.of(map.get(key));
        }
        else return Optional.empty();
    }

    public static void main(String[] args)
    {
        Map<String, String> studiengaenge = new HashMap<>();
        studiengaenge.put("fiw", "Informatik und Wirtschaft");
        studiengaenge.put("ai", "Angewandte Informatik");
        studiengaenge.put("imi", "Internationale Medieninformatik");
        studiengaenge.put("ikg", "Informatik, Kultur und Gesundheit");
        System.out.println(studiengaenge.get("ai").toUpperCase());
        //System.out.println(studiengänge.get("wi").toUpperCase());

        Optional<String> value = getValue(studiengaenge, "ai");
        if(value.isPresent()) {
            System.out.println(value.get());
        }
        value = getValue(studiengaenge, "wi");
        if(value.isPresent()) {
            System.out.println(value.get());
        }
        else
        {
            System.out.println("wi nicht vorhanden");
        }


        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        List<String> words1 = List.of("eins", "zwei", "drei", "vier", "fuenf");
        List<String> words2 = List.of("abc", "a", "abcd", "abcde", "ab");

        words1.stream()
                .forEach(s -> System.out.println(s.toUpperCase()));
        words1.stream()
                .map(s -> s.toUpperCase())
                .forEach(s -> System.out.println(s));

        words1.stream()
                .mapToInt(s -> s.length())
                .forEach(s -> System.out.println(s));

        Set<Rectangle> rectangles = new HashSet<>();
        rectangles.add(new Rectangle(1, 2));
        rectangles.add(new Rectangle(3, 2));
        rectangles.add(new Rectangle(1, 4));
        rectangles.add(new Rectangle(3, 4));
        rectangles.add(new Rectangle(2, 5));
        rectangles.add(new Rectangle(4, 2));
        rectangles.add(new Rectangle(2, 4));

        List<Rectangle> rectList = rectangles.stream()
                .collect(Collectors.toList());

        Map<Integer, List<Rectangle>> rectArea = rectangles.stream()
                .collect(Collectors.groupingBy(r -> r.width()));

        for(Map.Entry<Integer, List<Rectangle>> entry : rectArea.entrySet())
        {
            Integer key = entry.getKey();
            List<Rectangle> rectangleList = entry.getValue();
            System.out.println(key + " " + rectangleList);
        }

        List<Integer> numbers1 = List.of(1, 2, 3, 4);
        Integer sum = numbers1.stream()
                .reduce(0, (a,b) -> a + b);
        System.out.println("sum = " + sum);

        Integer product = numbers1.stream()
                .reduce(1, (a,b) -> a * b);
        System.out.println("product = " + product);

        numbers1.stream()
                .filter(n -> n % 2 == 0)
                .forEach(s -> System.out.println(s));

        Random r = new Random();
        Stream<Integer> s1 = Stream.generate(() -> r.nextInt(10)).limit(10);
        s1.forEach(s -> System.out.println(s));

        Stream<Integer> s2 = Stream.iterate(0, i -> i + 1).limit(100);
        s2.forEach(s -> System.out.println(s));
    }
}

JUnit

• siehe JUnit-Tests
• siehe Übung 12
• siehe Aufgabe 9

Code aus der Vorlesung 23.06.2025

Fakultaet.javaFakultaetTest.javaMain.java

package vorlesungen.vorl0623;

public class Fakultaet {

    public long fakultaet(int number) throws IllegalArgumentException
    {
        if(number < 1)
        {
            throw new IllegalArgumentException("Zahl muss groesser gleich 1 sein!");
        }
        long result = 1;
        for(int i = 2; i <= number; i++)
        {
            long tmp = result;
            result *= i;
            if(tmp > result)
            {
                throw new IllegalArgumentException("Overflow!");
            }
        }
        return result;
    }

    public void print(int number)
    {
        System.out.printf("%3d! = %,d %n", number, fakultaet(number));
    }

}

package vorlesungen.vorl0623;

import org.junit.jupiter.api.Test;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

import static org.junit.jupiter.api.Assertions.*;

public class FakultaetTest
{
    @Test
    public void testFakultaet6()
    {
        // given
        Fakultaet f = new Fakultaet();

        // when
        long result = f.fakultaet(6);

        // then
        long expected = 720;
        assertEquals(expected, result, "6! should be 720!");
    }

    @Test
    public void testFakultaet1()
    {
        // given
        Fakultaet f = new Fakultaet();

        // when
        long result = f.fakultaet(1);

        // then
        long expected = 1;
        //assertEquals(expected, result, "1! should be 1");
        assertTrue(expected == result, "1! should be 1");
    }

    @Test
    public void testSmallerThan1()
    {
        // given
        Fakultaet f = new Fakultaet();

        // when
        Exception exception = assertThrows(IllegalArgumentException.class, () -> f.fakultaet(0));

        // then
        assertEquals("Zahl muss groesser gleich 1 sein!",  exception.getMessage());
    }


    @Test
    public void testOverflow()
    {
        // given
        Fakultaet f = new Fakultaet();

        // when
        Exception exception = assertThrows(IllegalArgumentException.class, () -> f.fakultaet(21));

        // then
        assertEquals("Overflow!",  exception.getMessage());
    }

    @Test
    void testFakultaetPrint6()
    {
        PrintStream originalOut = System.out;       // System.out merken (Standardausgabegeraet Konsole)
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        System.setOut(new PrintStream(out));

        // given
        Fakultaet f = new Fakultaet();

        // when
        f.print(6);

        // then
        assertEquals("  6! = 720 \n", out.toString(), "should print 6! = 720 with linebreak");
        System.setOut(originalOut);                 // System.out wieder auf das Standardausgabegeraet setzen
    }
}

package vorlesungen.vorl0623;

public class Main
{
    public static void main(String[] args)
    {
        Fakultaet f1 = new Fakultaet();
        int nr = 0;
        while(nr < 22)
        {
            try {
                f1.print(nr);
            }
            catch(IllegalArgumentException e) {
                System.out.println("number = " + nr + " : " + e.getMessage());
            }
            nr++;
        }
    }
}

Code aus der Vorlesung 25.06.2025

UmrechnungTimeZeit.javaTestUmrechnungTimeZeit.javaPower.javaPowerTest.java

package vorlesungen.vorl0625;

public class UmrechnungTimeZeit
{
    private boolean isDigit(char c)
    {
        return c >= '0' && c <= '9';
    }

    public String convert(String time) throws IllegalArgumentException
    {
        if(!isDigit(time.charAt(0))) throw new IllegalArgumentException("no digit");
        final int HOURS_MINUTES = 4;
        String zeit = time.substring(0, HOURS_MINUTES);
        return zeit;
    }
}

package vorlesungen.vorl0625;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class TestUmrechnungTimeZeit
{
    @Test
    @DisplayName("1:00 am converts to 1:00")
    public void testUmrechnungTimeZeit1am()
    {
        // given (preparation)
        UmrechnungTimeZeit utz =  new UmrechnungTimeZeit();

        // when (execution)
        String time = "1:00 am";
        String zeit = utz.convert(time);

        // then (validation)
        String expected = "1:00";
        assertEquals(expected, zeit, time + " should be converted to " + expected);
    }

    @Test
    @DisplayName("2:00 am converts to 2:00")
    public void testUmrechnungTimeZeit2am()
    {
        // given (preparation)
        UmrechnungTimeZeit utz =  new UmrechnungTimeZeit();

        // when (execution)
        String time = "2:00 am";
        String zeit = utz.convert(time);

        // then (validation)
        String expected = "2:00";
        assertEquals(expected, zeit, time + " should be converted to " + expected);
    }

    @Test
    @DisplayName("2:15 am converts to 2:15")
    public void testUmrechnungTimeZeit215am()
    {
        // given (preparation)
        UmrechnungTimeZeit utz =  new UmrechnungTimeZeit();

        // when (execution)
        String time = "2:15 am";
        String zeit = utz.convert(time);

        // then (validation)
        String expected = "2:15";
        assertEquals(expected, zeit, time + " should be converted to " + expected);
    }

    @Test
    @DisplayName("exception if time does not start with digit")
    public void testUmrechnungTimeZeitNoDigitAtBeginning()
    {
        // given (preparation)
        UmrechnungTimeZeit utz =  new UmrechnungTimeZeit();

        // when (execution)
        String time = "hallo";
        Exception e = assertThrows(IllegalArgumentException.class, () -> utz.convert(time));

        // then (validation)
        assertEquals("no digit", e.getMessage());
    }
}

package vorlesungen.vorl0625;

public class Power {

    private int base;
    private int exp;

    public Power(int base, int exp)
    {
        this.base = base;
        this.exp = exp;
    }

    public double value()
    {
        double value = 1.0;
        if(exp > 0)
        {
            for(int i=0; i<exp; i++)
            {
                value *= base;
            }
        }
        else
        {
            for(int i=0; i<-exp; i++)
            {
                value *= base;
            }
            value = 1.0 / value;
        }
        return value;
    }

    @Override
    public String toString()
    {
        return "(" + this.base + "^" + this.exp + ")";
    }

    public void print()
    {
        System.out.println(this.toString());
    }

    @Override
    public boolean equals(Object o)
    {
        if(o == null) return false;
        if(this == o) return true;
        if(this.getClass() != o.getClass()) return false;

        Power p = (Power)o;
        return (this.base==p.base && this.exp==p.exp);
    }

    @Override
    public int hashCode()
    {
        return 7*this.base + 11*this.exp;
    }
}

package vorlesungen.vorl0625;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class PowerTest {
    static Power p1,p2,p3,p4;
    static int testnr = 1;

    @BeforeAll
    public static void setup()
    {
        p1 = new Power(2,3);
        p2 = new Power(2,3);
        p3 = new Power(-2,3);
        p4 = new Power(2,-3);
    }

    @BeforeEach
    public void printBeforeTests()
    {
        System.out.printf("%n %n --------------- Test %d ------------ %n", testnr);
        p1.print();
        p2.print();
        testnr++;
    }


    @Test
    void testToString() {
        String s = p1.toString();

        assertEquals("(2^3)", s, "Strings are not equal!");
    }

    @Test
    void testPower() {
        assertNotNull(p1, "no Power object");
    }

    @Test
    void testValue() {
        double value = p1.value();

        assertEquals(8.0, value, "2^3 should be 8.0");
    }

    @Test
    public void testEqualsObject() {
        assertTrue(p1.equals(p2), " 2^3 should be equal to 2^3!");
    }
}