Zum Inhalt

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 mordenen 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, prohgrammieren...
  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 genaze 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 (Corona-)Plan zur Durchführung der Veranstaltung ist derzeit wie folgt:

  • Themen werden ausführlich in diesem Skript beschrieben und anhand von Videos eingeführt und verdeutlicht,
  • das Skript und die Videos werden (spätestens) freitags hochgeladen,
  • das heißt, "Vorlesungen" finden asynchron statt (im Selbststudium),
  • zusammen mit dem Skript und den Videos werden sowohl die Übung als auch die Aufgabe hochgeladen,
  • die Übung (und die vergangene Aufgabe) werden donnerstags (8:00 Uhr und nochmal 14:00 Uhr) besprochen (Sie können frei wählen, welche der beiden Übungen Sie wählen),
  • bei Bedarf können wir auch gerne jederzeit eine Synchron-Video-Vorlesung einschieben, um Fragen zu erklären,
  • die Veranstaltung wird durch ein Tutorium unterstützt,
  • sollten Sie Wünsche haben, diesen Plan zu ändern, kommen Sie gerne auf mich zu

Zur erfolgreichen Durchführung der Veranstaltung müssen die Aufgaben lösen und zu den jeweiligen Fristen auf GitHub hochladen. Wenn Sie alle Aufgaben fristgerecht hochgeladen haben, dürfen Sie an der Klausur teilnehmen. Es werden insgesamt wahrscheinlich 10 Aufgaben sein, die Sie selbständig lösen und hochladen müssen. Sie können die Aufgaben auch zu zweit lösen. Laden Sie dann aber bitte beide jeweils die Lösung hoch. Am Ende des Semesters schreiben wir eine Klausur (am Rechner). Diese Klausur wird bewertet und entspricht der Note für das gesamte "Programmieren"-Modul.

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. Diese wird also selbständig durchgeführt.

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). Die Vorlesungsvideos finden Sie darunter für die einzelnen Wochen (unter Inhalte).

Woche Themen (Vorlesung) Übung Aufgabe Abgabe Aufgabe bis
1. 05.-09.04.2021 Einführung und Organisatorisches, Wiederholung -  - -
1. 12.-16.04.2021 Git Übung 1 Aufgabe 1 25.04.2021
2. 19.-23.04.2021 Enumerations und Exceptions Übung 2 Aufgabe 2 02.05.2021
3. 26.-30.04.2021 Testen mit JUnit Übung 3 Aufgabe 3 09.05.2021
4. 03.-07.05.2021 Collections (List und Set) Übung 4 Aufgabe 4 16.05.2021
5. 10.-14.05.2021 Wrapper-Klassen (boxing und unboxing) Übung 5 Aufgabe 5 23.05.2021
6. 17.-21.05.2021 Collections (Map) Übung 6  - -
7. 24.-28.05.2021 Abstrakte Klassen + Interfaces Übung 7 Aufgabe 6 06.06.2021
8. 31.-04.06.2021 GUI Einführung Übung 8 Aufgabe 7 13.06.2021
9. 07.-11.06.2021 GUI Ereignisse Übung 9 Aufgabe 8 20.06.2021
10. 14.-18.06.2021 Graphics Übung 10 Aufgabe 9 04.07.2021
12. 21.-25.06.2021 Mausereignisse Übung 11 Aufgabe 10 11.07.2021
13. 28.-02.07.2021 Klausurvorbereitung Übung 12  - -
14. 05.-09.07.2021 Klausurvorbereitung Übung 13  - -
15. 12.-16.07.2021 Klausurvorbereitung -  - -

Inhalte

05.-09.04.2021 - Einführung und Organisatorisches + Wiederholung
12.-16.04.2021 - Git
19.-23.04.2021 - Enum und Exceptions
26.-30.04.2021 - Testen mit JUnit
  • siehe auch Teil 2 des Videos zu Exceptions (unter 19.-23.04.2021 - Enum und Exceptions eins drüber) - das kam erst diese Woche hinzu, deshalb hier der Verweis, gehört aber thematisch in die Woche davor, deshalb dort
  • siehe JUnit-Tests
  • siehe Video zu JUnit-Tests
  • siehe Übung 3
  • siehe Aufgabe 4
  • Video aus der Vorlesung vom 28.04.2021

  • Quellcode aus der Vorlesung vom 28.04.2021

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
    package vorlesungen.testen;

public class MyMath 
{
    public static int abs(int number)
    {
        if(number < 0 )
        {
            return -number;
        }
        else
        {
            return number;
        }
    }

    public static double abs(double number)
    {
        if(number < 0 )
        {
            return -number;
        }
        else
        {
            return number;
        }
    }

    public static double sqrt(double number)
    {
        double a = number;
        double b = 1.0;
        final double AREA = number;
        final double ERROR = 0.000001;
        while(abs(a-b) >= ERROR)
        {
            a = (a + b) / 2.0;
            b = AREA / a;
        }
        return a;
    }

    public static int ggT(int a, int b)
    {
        while(b!=0)
        {
            int rest = a % b;
            a = b;
            b = rest;
        }
        return a;
    }
}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
    package vorlesungen.testen;

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

import org.junit.jupiter.api.Test;

class MyMathTest {

    @Test
    void testAbs3() {
        int result = MyMath.abs(3);
        assertEquals(3, result, "abs(3) not 3");
    }

    @Test
    void testAbsMinus3() {
        int result = MyMath.abs(-3);
        assertEquals(3, result, "abs(-3) not 3");
    }


    @Test
    void testSqrt9() {
        double result = MyMath.sqrt(9.0);
        assertEquals(3.0, result, 0.00001);
    }


    @Test
    void testSqrt25() {
        double result = MyMath.sqrt(25.0);
        assertTrue(MyMath.abs(5.0 - result) <= 0.00001);
    }   

    @Test
    void testGgT44und12() {
        int result = MyMath.ggT(44, 12);
        assertEquals(4, result, "ggT of 44 and 12 not 4");
    }
}

    1
2
3
4
    module SoSe2021 {
    requires java.desktop;
    requires org.junit.jupiter.api;
}
03.-07.05.2021 - Collections (List und Set)
  • siehe Collections
  • siehe Video zu Collections - Vorlesung 05.05.2021

  • Quellcode aus der Vorlesung vom 05.05.2021

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

import java.util.*;

/*
 * Collections: aehnlich wie Arrays, viele Elemente speichern
 * keine feste Laenge
 * wir koennen nur Referenztypen speichern (also nicht int, boolean, char, double, ...)
 * Elemente verschiedenen Typs speicherbar --> gar nicht gut, deshalb Typisieren
 * Arten von Collections: List (wie Arrays), Set (keine Doppelungen), Stack, Queue
 * Map (2-spaltige Tabellen Schlüssel-/Werte-Paare)
 */
public class ListenUndMengen {

    public static void main(String[] args) {

        System.out.printf("%n%n-------------- Listen ------------------%n%n");
        Set<String> set1 = new HashSet<>();
        Set<String> set2 = new TreeSet<>();

        String s1 = "erster";
        String s2 = "zweiter";
        String s3 = "dritter";
        String s4 = "zweiter";

        Integer i1 = 1;

        System.out.println(set1.add(s1));
        System.out.println(set1.add(s2));
        System.out.println(set1.add(s3));
        System.out.println(set1.add(s4));
        // System.out.println(set1.add(i1));

        System.out.println(set1.size());

        Iterator<String> it = set1.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }

        System.out.println();

        for(String element : set1)
        {
            System.out.println(element);
        }

        System.out.println(set1.remove("erster"));
        System.out.println(set1.remove("vierter"));

        System.out.println();

        for(String element : set1)
        {
            System.out.println(element);
        }

        System.out.printf("%n%n-------------- Listen ------------------%n%n");

        List<String> l1 = new ArrayList<>();
        List<String> l2 = new LinkedList<>();

        l1.add(s1);
        l1.add(s2);
        l1.add(s3);
        l1.add(s4);

        for(String s : l1)
        {
            System.out.println(s);
        }

        System.out.println(l1.size());

        System.out.println(l1.remove("zweiter"));
        System.out.println(l1.remove("vierter"));


        for(String s : l1)
        {
            System.out.println(s);
        }
        System.out.println();
        System.out.println("geloescht : " + l1.remove(1));

        for(String s : l1)
        {
            System.out.println(s);
        }

        System.out.println();

        l2.add("neu");
        l2.add("alt");

        for(String s : l2)
        {
            System.out.println(s);
        }

        System.out.println();

        l1.addAll(l2);

        for(String s : l1)
        {
            System.out.println(s);
        }


        System.out.println();


        l1.removeAll(l2);

        for(String s : l1)
        {
            System.out.println(s);
        }
    }

}

  • siehe Übung 5

  • siehe Aufgabe 5
10.-14.05.2021 - Wrapper-Klassen (boxing und unboxing)
  • siehe Wrapper-Klassen
  • siehe Video zu Wrapper-Klassen - Vorlesung 12.05.2021
  • diese Woche keine neue Übung (Donnerstag ist Feiertag)
  • diese Woche keine neue Aufgabe (Möglichkeit, bisher "Liegengebliebenes" aufzuarbeiten)
  • Lösungen für Aufgaben 1 - 3 hochgeladen
17.-21.05.2021 - Collections (Map)
  • siehe Maps
  • siehe Video zu Maps - Vorlesung 19.05.2021

  • Quellcode aus der Vorlesung vom 19.05.2021

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
    package vorlesungen.maps;

import java.util.*;

public class Maps {

    public static void main(String[] args) {
        /*
         * in Maps speichern wir Schluessel-Werte-Paare
         * Schluessel sind eindeutig, Schluesseltyp K
         * Werte koennen sich doppel, Wertetyp V
         * statt add(), addAll() hier put(), putAll()
         */

        Map<String, Integer> mapA = new HashMap<>();
        mapA.put("A", 1);
        mapA.put("B", 2);
        mapA.put("C", 3);

        /*
         * ein einzelnes Schluessel-Werte-Paar ist vom 
         * Typ Map.Entry
         * typisiert: Map.Entry<K,V>
         * unser Beispiel: Map.Entry<String, Integer>
         */

        /* 
         * leider nicht iterator(), sondern entrySet()
         * entrySet() erzeugt eine Set von lauter Schluessel-Werte-Paaren
         */

        // Variante 1
        Set<Map.Entry<String, Integer>> allEntriesFromMapA = mapA.entrySet();   
        for(Map.Entry<String, Integer> entry : allEntriesFromMapA)
        {
            System.out.println("Schluessel : " + entry.getKey() + " Wert : " + entry.getValue());
        }

        System.out.println(allEntriesFromMapA.size());

        // Iterator<Map.Entry<String, Integer>> it = allEntriesFromMapA.iterator();

        System.out.println();

        // Variante 2
        for(Map.Entry<String, Integer> entry : mapA.entrySet())
        {
            System.out.println("Schluessel : " + entry.getKey() + " Wert : " + entry.getValue());
        }

        System.out.println(mapA.containsKey("B"));
        System.out.println(mapA.containsKey("D"));

        System.out.println(mapA.get("B"));


        System.out.printf("%n%n------------ alle keys von mapA ---------------%n%n");
        Set<String> allKeys = mapA.keySet();    
        for(String key : allKeys)
        {
            System.out.println("key : " + key);
        }

        System.out.printf("%n%n------------ mapA ---------------%n%n");
        mapA.put("B", 5);
        for(Map.Entry<String, Integer> entry : mapA.entrySet())
        {
            System.out.println("Schluessel : " + entry.getKey() + " Wert : " + entry.getValue());
        }

        System.out.printf("%n%n------------ mapB ---------------%n%n");
        Map<String, Integer> mapB = new HashMap<>();
        mapB.put("B", 6);
        mapB.put("D", 7);
        for(Map.Entry<String, Integer> entry : mapB.entrySet())
        {
            System.out.println("Schluessel : " + entry.getKey() + " Wert : " + entry.getValue());
        }

        mapA.putAll(mapB);
        System.out.printf("%n%n------------ mapA ---------------%n%n");

        for(Map.Entry<String, Integer> entry : mapA.entrySet())
        {
            System.out.println("Schluessel : " + entry.getKey() + " Wert : " + entry.getValue());
        }
        mapA.put("E", 1);


        System.out.printf("%n%n------------ alle values von mapA ---------------%n%n");
        Collection<Integer> allValues = mapA.values();
        for(Integer val : allValues)
        {
            System.out.println("value : " + val);
        }
    }

}

  • siehe Übung 6

  • siehe Aufgabe 6
24.-28.05.2021 - Abstrakte Klassen und Interfaces
  • siehe Abstrakte Klassen und Interfaces
  • siehe Video zu Abstrakte Klassen und Interfaces - Vorlesung 26.05.2021

  • Quellcode aus der Vorlesung vom 26.05.2021

    1
2
3
4
5
    public abstract class Shape 
{
    public abstract double perimeter();
    public abstract double area();
}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
    public class Rectangle extends Shape implements Comparable<Rectangle>
{
    private int width;
    private int height;

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

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

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

    @Override
    public int compareTo(Rectangle o) 
    {
        /*
         * this > o --> positiver int-Wert
         * this < o --> negativer int-Wert
         * this == o --> 0
         */
        return ((this.width + this.height) - (o.width + o.height));
    }


}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
    public class Circle extends Shape
{
    private double radius;

    public Circle(double radius) 
    {
        this.radius = radius;
    }

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

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

}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
    public class TestShape 
{
    public static void printPerimeter(Shape s)
    {
        System.out.printf("perimeter : %.2f cm%n", s.perimeter());
    }

    public static void printArea(Shape s)
    {
        System.out.printf("area : %.2f cm%n", s.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 tmp = unsorted[index];
                    unsorted[index] = unsorted[index+1];
                    unsorted[index+1] = tmp;
                }
            }
        }
    }

    public static void main(String[] args) 
    {
        Shape s1 = new Rectangle(10,20);
        System.out.println(s1.perimeter());
        System.out.println(s1.area());

        Shape s2 = new Circle(1.0);
        System.out.println(s2.perimeter());
        System.out.println(s2.area());

        printPerimeter(new Rectangle(5,15));
        printPerimeter(new Circle(5.0));

        System.out.println("A".compareTo("B"));
        System.out.println("B".compareTo("A"));
        System.out.println("A".compareTo("A"));

        Rectangle[] rectArr = new Rectangle[6];
        rectArr[0] = new Rectangle(9, 13);
        rectArr[1] = new Rectangle(4, 17);
        rectArr[2] = new Rectangle(12, 5);
        rectArr[3] = new Rectangle(8, 9);
        rectArr[4] = new Rectangle(10, 11);
        rectArr[5] = new Rectangle(5, 15);
        System.out.printf("%n%n------------------------ unsortiert --------------------------%n%n");
        sortieren(rectArr);
    }

}

  • siehe Übung 7

  • siehe Aufgabe 7
31.-04.06.2021 - GUI Einführung
  • siehe Grafical User Interfaces
  • siehe Video zu Grafical User Interfaces - Vorlesung 02.06.2021

  • Quellcode aus der Vorlesung vom 02.06.2021

      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
    import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.GridLayout;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTextField;

public class MyFirstWindow extends JFrame
{

    public MyFirstWindow() 
    {
        super();    // Konstruktor von JFrame
        this.setTitle("My first window");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel content = this.initContent();
        this.getContentPane().add(content);
        // this.getContentPane().setBackground(Color.CYAN);

        this.setSize(400, 300);
        this.setLocation(200, 100);
        this.setVisible(true);
    }
    /*
     * FlowLayout - alles nebeneinander, so lange es passt, sonst untereinander (Standardlayout JPanel)
     * GridLayout - Gitterstruktur (Zeilen und Spalten)
     * BorderLayout - Norden, Sueden, Osten, Westen, Center (Stanfdardlayout eines JFrame)
     */
    private JPanel initContent()
    {
        JPanel mainPanel = new JPanel();

        mainPanel.setLayout(new BorderLayout());

        JPanel center = new JPanel();
        center.setLayout(new GridLayout(3, 2));

        JButton cb1 = new JButton("EAST");
        JButton cb2 = new JButton("WEST");
        JButton cb3 = new JButton("NORTH");
        JButton cb4 = new JButton("SOUTH");
        JButton cb5 = new JButton("CENTER");

        center.add(cb1);
        center.add(cb2);
        center.add(cb3);
        center.add(cb4);    
        center.add(cb5);

        JButton b1 = new JButton("EAST");
        JButton b2 = new JButton("WEST");
        JButton b3 = new JButton("NORTH");
        JButton b4 = new JButton("SOUTH");
        JButton b5 = new JButton("CENTER");

        mainPanel.add(b1, BorderLayout.EAST);
        mainPanel.add(center, BorderLayout.CENTER);
        mainPanel.add(b3, BorderLayout.NORTH);
        mainPanel.add(b4, BorderLayout.SOUTH);
        mainPanel.add(b2, BorderLayout.WEST);

        /*
        mainPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 30, 40));

        JButton b1 = new JButton("EAST");
        JButton b2 = new JButton("WEST");
        JButton b3 = new JButton("NORTH");
        JButton b4 = new JButton("SOUTH");
        JButton b5 = new JButton("CENTER");

        mainPanel.add(b1);
        mainPanel.add(b2);
        mainPanel.add(b3);
        mainPanel.add(b4);
        mainPanel.add(b5);
        */

        /*
        mainPanel.setLayout(new BorderLayout());

        JButton b1 = new JButton("EAST");
        JButton b2 = new JButton("WEST");
        JButton b3 = new JButton("NORTH");
        JButton b4 = new JButton("SOUTH");
        JButton b5 = new JButton("CENTER");
        JLabel l1 = new JLabel("Test");

        JPanel east = new JPanel();
        east.setLayout(new FlowLayout());
        east.add(b1);
        east.add(l1);

        mainPanel.add(east, BorderLayout.EAST);
        mainPanel.add(b2, BorderLayout.WEST);
        mainPanel.add(b3, BorderLayout.NORTH);
        mainPanel.add(b4, BorderLayout.SOUTH);
        mainPanel.add(b5, BorderLayout.CENTER);
        */

        /*
        // hier weitere Container oder Steuerelemente hinzufuegen
        JLabel label = new JLabel("Name : ");
        JTextField input = new JTextField(10);
        JButton button = new JButton("Klick mich!");
        JCheckBox cb = new JCheckBox();
        JRadioButton rb = new JRadioButton();

        mainPanel.add(label);
        mainPanel.add(input);
        mainPanel.add(button);
        mainPanel.add(cb);
        mainPanel.add(rb);
        */

        return mainPanel;
    }


    public static void main(String[] args) 
    {
        new MyFirstWindow();
    }

}

  • siehe Übung 8

  • siehe Aufgabe 8
07.-11.06.2021 - GUI Ereignisse
  • siehe GUI Ereignisse
  • siehe Video zu GUI Ereignisse - Vorlesung 09.06.2021

  • Quellcode aus der Vorlesung vom 09.06.2021

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
    import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class Ereignisbehandlung extends JFrame implements ActionListener
{
    Integer anzKlicks = 0;
    JLabel unten;

    public Ereignisbehandlung(){
        super();
        this.setTitle("Ereignisbehandlung");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel content = this.initContent();
        this.getContentPane().add(content);

        this.setSize(200, 150);
        this.setLocation(200, 100);
        this.setVisible(true);
    }

    public JPanel initContent() {
        JPanel mainPanel = new JPanel();
        mainPanel.setLayout(new BorderLayout());

        JPanel oben = new JPanel();

        JButton minus = new JButton("-");
        JButton plus = new JButton("+");

        oben.add(minus);
        oben.add(plus);

        plus.addActionListener(this);
        minus.addActionListener(this);

        this.unten = new JLabel(this.anzKlicks.toString());
        this.unten.setFont(new Font("Verdana", Font.BOLD, 48));
        this.unten.setHorizontalAlignment(JLabel.CENTER);

        mainPanel.add(oben, BorderLayout.NORTH);
        mainPanel.add(unten, BorderLayout.CENTER);

        return mainPanel;
    }

    public static void main(String[] args) {
        new Ereignisbehandlung();
    }

    @Override
    public void actionPerformed(ActionEvent e) 
    {   
        Object quelle = e.getSource();  // hat ActionEvent ausgeloest
        if(quelle instanceof JButton)
        {
            JButton button = (JButton)quelle;
            if(button.getText().equals("-"))
            {
                this.anzKlicks--;
                System.out.println("Minus-Button geklickt ... " + this.anzKlicks);
            }
            else if(button.getText().equals("+"))
            {
                this.anzKlicks++;
                System.out.println("Plus-Button geklickt ... " + this.anzKlicks);
            }
            this.unten.setText(this.anzKlicks.toString());
        }
    }

}

  • siehe Übung 9

  • siehe Aufgabe 9
14.-18.06.2021 - Graphics
  • siehe GUI Graphics
  • siehe Video zu GUI Graphics - Vorlesung 16.06.2021

  • Quellcode aus der Vorlesung vom 16.06.2021

      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
    import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class Ereignisbehandlung extends JFrame
{
    private Integer anzKlicks = 0;
    private JLabel unten;

    public Ereignisbehandlung(){
        super();
        this.setTitle("Ereignisbehandlung");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel content = this.initContent();
        this.getContentPane().add(content);

        this.setSize(200, 150);
        this.setLocation(200, 100);
        this.setVisible(true);
    }

    public JPanel initContent() {
        JPanel mainPanel = new JPanel();
        mainPanel.setLayout(new BorderLayout());

        JPanel oben = new JPanel();

        JButton minus = new JButton("-");
        JButton plus = new JButton("+");

        oben.add(minus);
        oben.add(plus);

        // ActionHandler ah = new ActionHandler();
        plus.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                Ereignisbehandlung.this.anzKlicks++;
                Ereignisbehandlung.this.unten.setText(Ereignisbehandlung.this.anzKlicks.toString());

            }

        });


        minus.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                Ereignisbehandlung.this.anzKlicks--;
                Ereignisbehandlung.this.unten.setText(Ereignisbehandlung.this.anzKlicks.toString());
            }

        });

        this.unten = new JLabel(this.anzKlicks.toString());
        this.unten.setFont(new Font("Verdana", Font.BOLD, 48));
        this.unten.setHorizontalAlignment(JLabel.CENTER);

        mainPanel.add(oben, BorderLayout.NORTH);
        mainPanel.add(unten, BorderLayout.CENTER);

        return mainPanel;
    }

    /*
    public class ActionHandler implements ActionListener 
    {

        @Override
        public void actionPerformed(ActionEvent e) {
            Object quelle = e.getSource();  // hat ActionEvent ausgeloest
            if(quelle instanceof JButton)
            {
                JButton button = (JButton)quelle;
                if(button.getText().equals("-"))
                {
                    Ereignisbehandlung.this.anzKlicks--;
                    System.out.println("Minus-Button geklickt ... " + Ereignisbehandlung.this.anzKlicks);
                }
                else if(button.getText().equals("+"))
                {
                    Ereignisbehandlung.this.anzKlicks++;
                    System.out.println("Plus-Button geklickt ... " + Ereignisbehandlung.this.anzKlicks);
                }
                Ereignisbehandlung.this.unten.setText(Ereignisbehandlung.this.anzKlicks.toString());
            }
        }

    }
    */

    public static void main(String[] args) {
        new Ereignisbehandlung();
    }

}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
    import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.geom.Arc2D;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Zeichnen extends JFrame
{

    public Zeichnen(){
        super();
        this.setTitle("Wir zeichnen!");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel oben = new JPanel();
        JTextField tf = new JTextField(10);
        oben.add(tf);   
        this.getContentPane().add(oben, BorderLayout.NORTH);

        Canvas content = new Canvas();
        this.getContentPane().add(content, BorderLayout.CENTER);

        JPanel unten = new JPanel();
        JButton but1 = new JButton("ok");
        unten.add(but1);
        this.getContentPane().add(unten, BorderLayout.SOUTH);

        this.setSize(500, 500);
        this.setLocation(200, 100);
        this.setVisible(true);
    }

    public class Canvas extends JPanel {

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2 = (Graphics2D)g;

            g2.setColor(new Color(127, 127, 0));
            g2.fillRect(20, 80, 400, 400);
            Shape arc = new Arc2D.Double(40, 30, 300, 300, 90, -180, Arc2D.PIE);

            g2.draw(arc);

        }
    }

    public static void main(String[] args) {
        new Zeichnen();
    }

}

  • siehe Übung 10

  • siehe Aufgabe 10
21.-25.06.2021 - Mausereignisse
  • siehe Mausereignisse
  • siehe Video zu Mausereignisse - Vorlesung 23.06.2021

  • Quellcode aus der Vorlesung vom 23.06.2021

      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
    import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Mausereignisse extends JFrame implements MouseListener, MouseMotionListener {
    Canvas canvas;
    List<Point> points;
    Linie aktuelleLinie;
    List<Linie> linien;

    public Mausereignisse()
    {
        super();
        this.setTitle("Mausereignisse");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    

        this.canvas = new Canvas();
        this.canvas.addMouseListener(this);
        this.canvas.addMouseMotionListener(this);
        this.getContentPane().add(this.canvas);

        this.points = new ArrayList<>();
        this.linien = new ArrayList<>();

        this.setSize(400, 400);
        this.setLocation(1000,100);
        this.setVisible(true);
    }

    private class Canvas extends JPanel
    {
        final static int DURCHMESSER = 20;

        @Override
        protected void paintComponent(Graphics g)
        {
            super.paintComponent(g);        // Implementierung von JPanel aufrufen
            Graphics2D g2 = (Graphics2D)g;  // Methoden von Graphics2D nutzbar
            // hier koennen wir zeichnen
            for(Point p : Mausereignisse.this.points)
            {
                if(p.x > this.getWidth()/2)
                {
                    g2.setColor(Color.RED);
                }
                else
                {
                    g2.setColor(Color.BLUE);
                }
                g2.fillOval(p.x, p.y, DURCHMESSER, DURCHMESSER);    
            }

            g2.setColor(Color.GREEN);

            for(Linie l : Mausereignisse.this.linien) {
                int x1 = l.getXStart();
                int y1 = l.getYStart();
                int x2 = l.getXEnde();
                int y2 = l.getYEnde();

                g2.drawLine(x1, y1, x2, y2);
            }

            if(Mausereignisse.this.aktuelleLinie != null)
            {
                int x1 = Mausereignisse.this.aktuelleLinie.getXStart();
                int y1 = Mausereignisse.this.aktuelleLinie.getYStart();
                int x2 = Mausereignisse.this.aktuelleLinie.getXEnde();
                int y2 = Mausereignisse.this.aktuelleLinie.getYEnde();

                g2.drawLine(x1, y1, x2, y2);
            }
        }
    }

    public static void main(String[] args) 
    {
        new Mausereignisse();
    }

    @Override
    public void mouseClicked(MouseEvent e) {

        /*
        int x = e.getX();
        int y = e.getY();
        System.out.println("mouseClicked bei [x=" + p.x +", y=" +p.y +"]");
        System.out.println("mouseClicked bei [x=" + x +", y=" +y +"]");
        */
    }

    @Override
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();  // p.x p.y
        this.points.add(p);
        this.aktuelleLinie = new Linie(p,p);

        this.canvas.repaint();  // ruft paintComponent() von canvas auf

        System.out.println("mousePressed");
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        System.out.println("mouseReleased");
        this.linien.add(this.aktuelleLinie);

        this.canvas.repaint();
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        System.out.println("mouseEntered");
    }

    @Override
    public void mouseExited(MouseEvent e) {
        System.out.println("mouseExited");
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        Point p = e.getPoint();
        this.aktuelleLinie.setEnde(p);

        this.canvas.repaint();
        // System.out.println("mouseDragged");
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        int x = e.getX();
        int y = e.getY();
        // System.out.println("mouseMoved bei [x=" + x + ", y= " + y + "]");
    }

}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    public class Linie {
    private Point start;
    private Point ende;

    public Linie(Point start, Point ende) {
        this.start = start;
        this.ende = ende;
    }

    public int getXStart() {
        return this.start.x;
    }

    public int getYStart() {
        return this.start.y;
    }

    public int getXEnde() {
        return this.ende.x;
    }

    public int getYEnde() {
        return this.ende.y;
    }

    public void setEnde(Point ende) {
        this.ende = ende;
    }

}

  • siehe Übung 11

  • keine neuen Aufgaben mehr, jetzt nur noch Klausurvorbereitung, sowohl in den Vorlesungen, als auch in den Übungen
28.-02.07.2021 - Klausurvorbereitung
  • siehe Klausurvorbereitung
  • siehe Video zu Klausurvorbereitung - Vorlesung 30.06.2021

  • Quellcode aus der Vorlesung vom 30.06.2021

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
    import java.awt.*;
import java.util.Random;

import javax.swing.*;

public class KV1 extends JFrame
{
    Canvas canvas;

    public KV1()
    {
        super();
        this.setTitle("Klausurvorbereitung 1");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        this.canvas = new Canvas();
        this.getContentPane().add(this.canvas, BorderLayout.CENTER);
        this.setSize(400, 400);
        this.setLocation(200,100);
        this.setVisible(true);
    }

    class Canvas extends JPanel 
    {   
        final static int DURCHMESSER = 3;
        final static int ANZAHL_PUNKTE = 10000;
        @Override
        protected void paintComponent(Graphics g)
        {
            super.paintComponent(g);
            Graphics2D g2 = (Graphics2D)g;

            int widthCanvas = this.getWidth();
            int heightCanvas = this.getHeight();
            System.out.println("w = " + widthCanvas +", h = " + heightCanvas);

            //g2.drawLine(0, 0,  widthCanvas,  heightCanvas);
            //g2.drawLine(widthCanvas, 0,  0,  heightCanvas);

            int x1=0, seite=0, y1 = 0;

            if(widthCanvas < heightCanvas)
            {
                x1 = (int)(widthCanvas * 0.05);
                seite = (int)(widthCanvas * 0.9);
                y1 = (heightCanvas - seite) /2;
            }
            else
            {
                y1 = (int)(heightCanvas * 0.05);
                seite = (int)(heightCanvas * 0.9);
                x1 = (widthCanvas - seite) / 2;
            }

            g2.setStroke(new BasicStroke(3.0f));
            g2.drawRect(x1, y1, seite, seite);
            g2.drawArc(x1, y1, seite * 2, seite * 2, 90, 90);

            // g2.fillOval(30,  40,  DURCHMESSER,  DURCHMESSER);
            // g2.fillOval(130,  140,  DURCHMESSER,  DURCHMESSER);

            Random r = new Random();


            int xm = x1 + seite;
            int ym = y1 + seite;

            for(int i = 0; i < ANZAHL_PUNKTE; i++)
            {
                int x = r.nextInt(seite-DURCHMESSER) + x1;
                int y = r.nextInt(seite-DURCHMESSER) + y1;

                // (x-xm)^2 + (y-ym)^2 = r^2
                if(((x-xm) * (x-xm) + (y -ym) * (y-ym) <= seite * seite))
                {
                    g2.setColor(Color.RED);
                }
                else
                {
                    g2.setColor(Color.BLUE);
                }
                g2.fillOval(x,  y,  DURCHMESSER,  DURCHMESSER);
            }

        }
    }

    public static void main(String[] args) {
        new KV1();
    }
}

  • siehe Übung 12

12.-16.07.2021 - Klausurvorbereitung
  • siehe Klausurvorbereitung
  • siehe Video zu Klausurvorbereitung - Vorlesung 14.07.2021

  • Quellcode aus der Vorlesung vom 14.07.2021

      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
    import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.List;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class RechteckeAnordnen extends JFrame implements MouseListener, MouseMotionListener{
    Canvas canvas;
    JLabel fixLabel;
    MyRectangle curRect;
    Point remember;
    boolean move = false;
    List<MyRectangle> fixierteRect;

    public RechteckeAnordnen()
    {
        super();
        this.setTitle("Rechtecke fixieren");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

        this.fixierteRect = new ArrayList<>();

        this.canvas = new Canvas();
        this.canvas.setBorder(BorderFactory.createLineBorder(Color.BLACK));

        this.canvas.addMouseListener(this);
        this.canvas.addMouseMotionListener(this);
        this.getContentPane().add(this.canvas, BorderLayout.CENTER);

        // von den folgenden vier Zeilen werden eventuell eine oder mehrere oder alle auskommentiert
        this.getContentPane().add(this.initNorth(), BorderLayout.NORTH);
        this.getContentPane().add(this.initSouth(), BorderLayout.SOUTH);

        this.setSize(400, 400);
        this.setLocation(300,200);
        this.setVisible(true);
    }

    // start inner class
    private class Canvas extends JPanel
    {

        @Override
        protected void paintComponent(Graphics g)
        {
            super.paintComponent(g);        // Implementierung von JPanel aufrufen
            Graphics2D g2 = (Graphics2D)g;  // Methoden von Graphics2D nutzbar

            int widthPanel = this.getWidth();
            int heightPanel = this.getHeight();
            g2.drawLine(widthPanel/2, 0, widthPanel/2, heightPanel);
            g2.drawLine(0, heightPanel/2, widthPanel, heightPanel/2);

            for(MyRectangle mr : RechteckeAnordnen.this.fixierteRect)
            {
                int x = mr.getX();
                int y = mr.getY();
                int width = mr.getWidth();
                int height = mr.getHeight();

                Color curColor = mr.getColor();
                g2.setColor(curColor);
                g2.fillRect(x, y, width, height);
            }

            if(RechteckeAnordnen.this.curRect != null)
            {
                int x = RechteckeAnordnen.this.curRect.getX();
                int y = RechteckeAnordnen.this.curRect.getY();
                int width = RechteckeAnordnen.this.curRect.getWidth();
                int height = RechteckeAnordnen.this.curRect.getHeight();

                Color curColor = RechteckeAnordnen.this.curRect.getColor();
                g2.setColor(curColor);
                g2.fillRect(x, y, width, height);


            }
        }
    }
    // ende innere Klasse

    private JPanel initNorth() 
    {
        JPanel north = new JPanel();

        this.fixLabel = new JLabel("0 Rechtecke fixiert");
        this.fixLabel.setFont(new Font("Verdana", Font.ITALIC, 16));
        north.add(this.fixLabel);
        return north;
    }

    private JPanel initSouth() 
    {
        JPanel south = new JPanel();
        JButton btnClear = new JButton("clear");

        btnClear.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                RechteckeAnordnen.this.curRect = null;
                RechteckeAnordnen.this.fixierteRect.clear();
                RechteckeAnordnen.this.move = false;
                RechteckeAnordnen.this.fixLabel.setText("0 Rechtecke fixiert");
                RechteckeAnordnen.this.canvas.repaint();
            }

        });

        south.add(btnClear);

        JButton btnRect = new JButton("rectangle");

        btnRect.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) 
            {
                int widthCanvas = RechteckeAnordnen.this.canvas.getWidth();
                int heightCanvas = RechteckeAnordnen.this.canvas.getHeight();
                int widthRect = widthCanvas/2;
                int heightRect = heightCanvas/2;
                int xRect = widthCanvas/4;
                int yRect = heightCanvas/4;
                Color curColor;

                switch(RechteckeAnordnen.this.fixierteRect.size()) {
                case 0: curColor = Color.GREEN; break;
                case 1: curColor = Color.RED; break;
                case 2: curColor = Color.YELLOW; break;
                case 3: curColor = Color.DARK_GRAY; break;
                default: curColor = Color.WHITE;
                }
                RechteckeAnordnen.this.curRect = new MyRectangle(xRect, yRect, widthRect, heightRect, curColor);

                RechteckeAnordnen.this.canvas.repaint();
            }

        });

        south.add(btnRect);
        return south;
    }

    public static void main(String[] args) 
    {
        new RechteckeAnordnen();
    }

    @Override
    public void mouseDragged(MouseEvent e) 
    {

        if(this.move) 
        {
            // bewegen
            int x = e.getX();
            int y = e.getY();

            int xLast = this.remember.x;
            int yLast = this.remember.y;

            int xDiff = x - xLast;
            int yDiff = y - yLast;

            this.curRect.move(xDiff, yDiff);
            this.remember = e.getPoint();

            // fixieren
            int xRect = this.curRect.getX();
            int yRect = this.curRect.getY();
            final int ABSTAND = 25;

            int xGoal = 0;
            int yGoal = 0;

            int widthCanvas = this.canvas.getWidth();
            int heightCanvas = this.canvas.getHeight();

            switch(this.fixierteRect.size()) {
                case 0: xGoal = 0; yGoal = 0; break;
                case 1: xGoal = widthCanvas/2; yGoal = 0;  break;
                case 2: xGoal = 0; yGoal = heightCanvas/2; break;
                case 3: xGoal = widthCanvas/2; yGoal = heightCanvas/2; break;
            }

            if(Math.abs(xRect - xGoal) < ABSTAND && Math.abs(yRect - yGoal) < ABSTAND)
            {
                this.curRect.setFix(true);
                this.curRect.setX(xGoal);
                this.curRect.setY(yGoal);
                this.fixierteRect.add(this.curRect);
                int anzFix = this.fixierteRect.size();
                if(anzFix == 1) 
                {
                    this.fixLabel.setText(anzFix + " Rechteck fixiert");
                }
                else if(anzFix == 4) 
                {
                    this.fixLabel.setFont(new Font("Verdana", Font.ITALIC|Font.BOLD, 18));
                    this.fixLabel.setText(anzFix + " Rechtecke fixiert -- Ende");
                }
                else
                {
                    this.fixLabel.setText(anzFix + " Rechtecke fixiert");
                }

                this.curRect = null;
                this.move = false;
            }
            this.canvas.repaint();
        }

    }

    @Override
    public void mouseMoved(MouseEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseClicked(MouseEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mousePressed(MouseEvent e) 
    {
        int x = e.getX();
        int y = e.getY();

        if(this.curRect != null && !this.curRect.isFix() && this.curRect.inside(x, y)) {
            this.remember = new Point(x,y);
            this.move = true;
        }

    }

    @Override
    public void mouseReleased(MouseEvent e) 
    {
        this.move = false;

    }

    @Override
    public void mouseEntered(MouseEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseExited(MouseEvent e) {
        // TODO Auto-generated method stub

    }
}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
    import java.awt.Color;

public class MyRectangle {

    private int x;
    private int y;
    private int width;
    private int height;
    private Color color;
    private boolean fix;

    public MyRectangle(int x, int y, int width, int height, Color color) 
    {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
        this.color = color;
        this.fix = false;
    }

    public int getX() {
        return this.x;
    }

    public int getY() {
        return this.y;
    }

    public int getWidth() {
        return this.width;
    }

    public int getHeight() {
        return this.height;
    }

    public Color getColor() {
        return this.color;
    }

    public boolean inside(int x, int y) {
        return (x >= this.x && x <= this.x+this.width && y >= this.y && y <= this.y+this.height);
    }

    public void move(int xDiff, int yDiff) {
        this.x = this.x + xDiff;
        this.y = this.y + yDiff;
    }

    public boolean isFix() {
        return this.fix;
    }

    public void setFix(boolean fix) {
        this.fix = fix;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }


}

  • siehe Übung 14