Zum Inhalt

Programmieren I

Herzlich willkommen zur Programmieren I Veranstaltung! Wir werden unter Verwendung der Programmiersprache Java die wesentlichen Konzepte lernen, die für das Verständnis modernen Programmierens notwendig sind. Es sind keinerlei Vorkenntnisse erforderlich. Hier einige Tipps, damit Sie die Veranstaltung erfolgreich durchführen und Sie dabei auch Spaß haben:

  1. In diesem Skript sind bereits alle Inhalte des gesamten Semesters verfügbar. Der Grund dafür ist der, dass Sie sich das jeweilige Thema vorab selbständig erarbeiten können, indem Sie sich den jeweiligen Abschnitt bereits vor der jeweiligen Vorlesung anschauen. Ich empfehle Ihnen diese Vorgehensweise - sie hat sich bewährt!
  2. 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! Sie müssen irgendwann in der Lage sein, alle Übungsaufgaben selbständig zu lösen.
  3. 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!
  4. 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.
  5. 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... (siehe auch hier)
  6. 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.
  7. Haben Sie Spaß! Je mehr Sie das Programmieren lernen, je mehr Spaß werden Sie haben. 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 der Vorlesung vorgestellt und in diesem Skript beschrieben.
  • Es ist geplant, die neuen Themen stets vorab in diesem Skript hier zu veröffentlichen. Sie können sich also bereits vorab mit dem jeweiligen neuen Thema beschäftigen.
  • Zusammen mit dem Skript (das neue Thema) werden sowohl die dazugehörige Übung als auch die dazugehörige Aufgabe hochgeladen.
  • Die beiden Übungen am Freitag sind jeweils gleich (d.h. dort werden die gleichen Übungsaufgaben gelöst). Die Übungen behandeln den Stoff, der am Montag und Mittwoch in der gleichen Woche besprochen wird. Das bedeutet: das neue Thema wird am Montag und Mittwoch in den Vorlesungen vermittelt und am folgenden Freitag in der Übung angewendet.
  • Sie können frei wählen, welche der beiden Übungen Sie besuchen. Sie können auch beliebig wöchentlich wechseln.
  • Es wird ein Tutorium angeboten (Termin wird noch bekanntgegeben).
  • Sollten Sie Wünsche haben, diesen Plan zu ändern, kommen Sie gerne auf mich zu.

Zur erfolgreichen Durchführung der Veranstaltung müssen Sie die Aufgaben (Hausaufgaben) lösen und zu den jeweiligen Fristen auf Moodle hochladen. Wenn Sie alle Aufgaben fristgerecht hochgeladen haben, dürfen Sie an der Klausur teilnehmen. Es werden insgesamt wahrscheinlich 8 Aufgaben sein, die Sie selbständig lösen und mindestens 6 davon 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 "Programmieren 1".

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 meistens jeweils einem Wochenthema. 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 (Channel #b11_prog1_ws2024_25). Dort können Sie alle inhaltlichen und organisatorischen Fragen stellen. Ich fände es gut, wenn eine Art internes Diskussionsforum entsteht. Es ist sehr gewünscht, dort Fragen zu stellen und noch mehr gewünscht, dass Sie sich diese gegenseitig beantworten. Damit wäre allen geholfen und wir können besser erkennen, wo noch Nachhol- bzw. Erläuterungsbedarf bei den meisten besteht. Bei Bedarf beantworten die Lehrenden die Fragen natürlich.

Das Tutorium bei Noa Sauter findet immer mittwochs um 15:45 Uhr in C 624 statt.

Planung

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

Woche Themen (Vorlesung) Übung Aufgabe Abgabe Aufgabe bis
1. 07.-11.10.2024 Organisatorisches, Algorithmen und Erstes Programm Übung 0 - -
2. 14.-18.10.2024 Variablen und Datentypen Übung 1 - -
3. 21.-25.10.2024 Operatoren und Ausdrücke Übung 2 - -
4. 28.-01.11.2024 Methoden und Methodenstack Übung 2a - -
5. 04.-08.11.2024 Selektion (if) und Iteration (for) Übung 3 Aufgabe 1 22.11.2024
6. 11.-15.11.2024 Iteration (while) und Methodenstack Übung 4 Aufgabe 2 29.11.2024
7. 18.-22.11.2024 Klassen und Objekte, Konstruktoren, this Übung 5 Aufgabe 3 06.12.2024
8. 25.-29.11.2024 Eigene Datentypen, Rückgabe von Objekten und Leben der Objekte Übung 6 Aufgabe 4 13.12.2024
9. 02.-06.12.2024 Vererbung, Object und Polymorphie Übung 7 Aufgabe 5 20.12.2024
10. 09.-13.12.2024 Arrays Übung 8 Aufgabe 6 03.01.2025
11. 16.-20.12.2024 Algorithmen über Arrays Übung 9 Aufgabe 7 10.01.2025
 
12. 06.-10.01.2025 Sortieren von Arrays Übung 10 Aufgabe 8 17.01.2025
13. 13.-17.01.2025 Suchen in Arrays Übung 11 Probeklausuren -
14. 20.-24.01.2025 JavaDoc Übung 12 Probeklausuren -
15. 27.-31.01.2025 Wiederholung, Klausurvorbereitung Probeklausuren -
16. 07.02.2025 09.30-11.30 Uhr Klausur 1.PZ - -
16. 28.03.2025 09.30-11.30 Uhr Klausur 2.PZ - -

Code aus der Vorlesung

Vorlesung Datentypen und Variablen 
package vorlesungen.vorl1016;

public class Datentypen
{
    public static void main(String[] args) 
    {
        // hier hinter koennen Sie schreiben, was Sie moechten
        // Zeilenkommentar

        /*
            Blockkommentar ueber mehrere Zeilen
            alles 
            noch
            Kommentar
        */

          System.out.println("test test test"); 
          System.out.println("test test test");

          int ganzeZahl = 0;
          boolean wahrheitswert = true;
          double gleitkommaZahl = 1.0;
          char zeichen = 'a';
          String zeichenkette = "Das ist eine Zeichenkette";

          System.out.println(zeichenkette);

          ganzeZahl = 5;
          System.out.println(ganzeZahl);

          ganzeZahl = 9;
          System.out.println(ganzeZahl);

          wahrheitswert = true;
          gleitkommaZahl = 5.5;

          gleitkommaZahl = 17.56;

          double number = 1;
          System.out.println(number);

          //int numberInt = 1.0;
          //System.out.println(numberInt);

          System.out.println(ganzeZahl);

          ganzeZahl = ganzeZahl + 1;

          System.out.println(ganzeZahl);

          byte test = 127;
          test = (byte) (test + 1);
          System.out.println(test);

    }

}
Vorlesung Ausdrücke 
package vorlesungen.vorl1021;

public class Ausdruecke
{

    public static void main(String[] args)
    {
        System.out.println();
        System.out.println("------ arithmetische Operatoren ------");
        System.out.println();
        System.out.println(3 + 4);
        System.out.println(3.0 - -4);
        System.out.println(3 * 4);
        System.out.println(3.0 * -4);
        System.out.println(-4);
        System.out.println(+4);
        System.out.println(-4.0);
        System.out.println(+4.0);
        System.out.println(9 / 3);
        System.out.println(9.0 / 3.0);

        System.out.println(5 / 3);      // int-Division 1
        System.out.println(5.0 / 3);    // double-Division 1.66
        System.out.println(5 / 3.0);    // double-Division 1.66
        System.out.println(5.0 / 3.0);  // double-Division 1.66

        System.out.println(5 % 3);      // Rest 2
        System.out.println(5 + 3 * 4);  // 17

        int x = 3 + 4 * 5 + 6 - 7;      // 22
        x = 3 + 4 * (5 + 6) - 7;        // 40
        System.out.println(x);
        x = x + 1;
        System.out.println(x);
        x++;                            // x = x + 1;
        System.out.println(x);
        ++x;
        System.out.println(x);          // x = x + 1;
        x+=1;
        System.out.println(x);          // x = x + 1;
        x*=3;                           // x = x * 3;
        x/=3;                           // x = x / 3;
        x-=3;                           // x = x - 3;
        x%=3;                           // x = x % 3;

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

        int y = 7;
        int z = 8;
        int w = 8;
        System.out.println(y < z);      // true
        System.out.println(y > z);      // false
        System.out.println(y == z);     // false
        System.out.println(z == w);     // true
        System.out.println(y <= z);     // true
        System.out.println(y >= z);     // false

        System.out.println(y % 2 == 1 );    // wenn true, dann y ungerade (false: gerade)
        System.out.println(y % 2 == 0 );    // wenn true, dann y gerade (false: ungerade)


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


        String s1 = "Hello " + "FIW!";
        String s2 = " noch mehr dazu ";
        String s3 = s1 + s2;
        System.out.println(s1);
        System.out.println(s3+s1);

        int a = 3;
        System.out.println(a);
        System.out.println("a = " + a);     // "a = " + "3"
        System.out.println(a + " = a");     // "3" + " = a"
    }

}
Vorlesung Ausdrücke - Teil 2 
package vorlesungen.vorl1023;

public class Ausdruecke2
{

    public static void main(String[] args)
    {
        int nr1 = 13;
        int nr2 = 4;
        int sum = nr1 + nr2;

        System.out.println(nr1 + " + " + nr2 + " = " + sum);
        System.out.println(nr1 + " + " + nr2 + " = " + (nr1 + nr2));

        System.out.println();
        System.out.println("--------- Logische Ausdruecke ----------");
        System.out.println();

        boolean a = false;
        boolean b = true;

        System.out.println(a + " && " + b + " = " + (a && b));
        System.out.println(a + " || " + b + " = " + (a || b));
        System.out.println("!a = " + !a);

        int year = 2024;
        boolean isLeapYear = ((year % 400) == 0) || 
                ((year % 4) == 0 && !((year % 100) == 0));

        System.out.println("war " + year + " Schaltjahr ? " + isLeapYear);

        int x = 3;
        int y = 4; 
        int z = 5;

        boolean xSmallerYSmallerZ = (x < y) && (y < z);

        int noten = 1 + 2 + 3 + 1 + 3 + 4 + 1 + 1 + 2 + 1;
        double schnitt = noten / 10.0;
        System.out.println("Durchschnitt ist " + schnitt);

        int test1 = 1;
        double test2 = test1;
        System.out.println(test2);
        test2 = 1.7;
        test1 = (int) test2;
        System.out.println(test1);
        System.out.println(test2);
    }

}
Vorlesung Methoden 
package vorlesungen.vorl1028;

public class Methoden
{
    public static void add(int summand1, int summand2)
    {
        int summe = summand1 + summand2;
        System.out.println(summand1 + " + " + summand2 + " = " + summe);
    }

    public static int computeSum(int summand1, int summand2)
    {
        int summe = summand1 + summand2;
        return summe;
    }

    public static void main(String[] args)
    {

        add(4,5);
        add(5,4);
        add(7,9);
        add(-7,19);
        add(3,3);

        int nr1 = 12;
        int nr2 = 13;
        int ergebnis = computeSum(nr1, nr2);
        System.out.println(nr1 + " + " + nr2 + " = " + ergebnis);

        ergebnis = computeSum(31,2);        
    }
}
Vorlesung Methodenstack und Selektion 
package vorlesungen.vorl1030;

public class Methoden2
{

    public static double multiply(double nr1, double nr2)
    {
        return nr1 * nr2;
    }

    public static double multiply(double nr1, double nr2, double nr3)
    {
        return nr1 * nr2 * nr3;
    }

    public static double multiply(int nr1, int nr2, int nr3)
    {
        return nr1 * nr2 * nr3;
    }


    public static void printProduct(double nr1, double nr2)
    {
        double product = multiply(nr1, nr2); 
        System.out.println(nr1 + " * " + nr2 + " = " + product);
    }

    public static void main(String[] args)
    {
        double nr1 = 3.5;
        double nr2 = 4.5;
        printProduct(nr1, nr2);

        System.out.println(multiply(3.5, 4.5, 5.5)); 
        System.out.println(multiply(3, 4 , 5)); 
        double product = multiply(3.5, 4.5); 
        System.out.println(product);

        int a = 2;
        int b = 4;

        System.out.println("a = " + a + ", b = " + b);
        if( a > b )
        {
            // wenn a > b true
            System.out.println("a > b -> true");
            a = a - b;

        }
        else
        {
            // wenn a > b false
            System.out.println("a > b -> false");
            b = b - a;
        }
        System.out.println("a = " + a + ", b = " + b);

        int n = 5;

        System.out.println("n = " + n);
        if( n % 2 == 0 )
        {
            System.out.println("n gerade ");
            n = n / 2;
        }
        else
        {
            System.out.println("n ungerade ");
            n = n * 3 + 1;
        }
        System.out.println("n = " + n);

        int x = 1;
        int y = 2;
        int z = 3;

        if( z > y )
        {
            // z > y true
            if( y > x )
            {
                // y > x true ( && z > y true)
                System.out.println("z > y > x");
            }
            else
            {
                // z > y && !y>x
                if( y == x)
                {
                    System.out.println("z > y == x");
                }
                else
                {
                    // z > y && x > y
                }
            }
        }
        else
        {
            // z > y false
        }

    }

}
Vorlesung Iteration - for-Schleife 
package vorlesungen.vorl1104;

public class Iteration1
{

    public static void main(String[] args)
    {
        for(int i = 0; i < 0; i++)
        {
            System.out.println("in der Schleife : i = " + i);
        }

        System.out.println("fertig");

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

        printSum1ToN(10);
        /*
        for(int i = 1; i < 50; i++)
        {
            System.out.print(" i = " + i + " : ");
            printSum1ToN(i);
        }
        */
    }

    public static void printSum1ToN(int n)
    {
        int sum = 0;

        for(int summand = 1; summand <= n ; summand++)
        {
            System.out.print(summand);

            if(summand < n) 
            {
                System.out.print(" + ");
            }

            sum = sum + summand;
        }

        System.out.println(" = " + sum);
    }

}
Vorlesung Iteration - verschachtelte for-Schleife 
package vorlesungen.vorl1106;

public class Iteration2
{

    public static void main(String[] args)
    {
        for(int number = -5; number < 17; number++)
        {
            System.out.println(number + "! = " + factorial(number));
        }

        printRectangle(6, 4);
        printRectangle(16, 10);
    }

    public static int factorial(int n)
    {
        if(n < 1)
        {
            return 0;
        }
        else
        {
            int product = 1;    
            for(int factor = n;  factor > 1   ; factor--)
            {
                product = product * factor;
            }
            return product;
        }
    }

    public static void printRectangle(int width, int height)
    {
        // kein row
        for(int row = 1; row <= height; row++)
        {
            // kein stars
            // probieren Sie in der folgenden Bedingung anstelle von width mal row
            // for(int stars = 1;  stars <= width; stars++)
            // for(int stars = width;  stars > 0; stars--)
            // for(int stars = width;  stars >= 1; stars--)
            for(int stars = 0;  stars < width; stars++)
            {
                System.out.print(" [" + stars + ", " + row + "] ");
                // System.out.print("* ");
            }
            // kein stars
            System.out.println();
        }
        // kein row
        System.out.println();
    }

}
Vorlesung Iteration - while-Schleife 
package vorlesungen.vorl1111;

public class Iteration3
{

    public static void main(String[] args)
    {
        printTriangleLeft(7);
        //printNStarsInOneRow(10);
        //printNStarsInOneRow(1);

        printCollatz(7);
        printGGT(-148, 144);
    }

    public static void printNStarsInOneRow(int nrOfStars)
    {
        for(int stars = 1; stars <= nrOfStars; stars++)
        {
            System.out.print("* ");
        }
        System.out.println();
    }

    public static void printNCharsInOneRow(int n, char c)
    {
        for(int stars = 1; stars <= n; stars++)
        {
            System.out.print(c + " ");
        }
    }

    public static void printTriangleLeft(int height)
    {

        for(int row = 1; row <= height; row++)
        {
            printNCharsInOneRow(height-row, ' ');
            printNCharsInOneRow(row, '*');
            System.out.println();
        }
    }

    public static void printCollatz(int anfang)
    {
        int n = anfang;

        while( n > 1 )
        {
            System.out.print(n + " ");
            if(n % 2 == 0)
            {
                n = n/2;
            }
            else
            {
                n = 3 * n + 1;
            }
        }

        System.out.println(n + "      ende für anfang = " + anfang);
    }

    public static void printGGT(int nr1, int nr2)
    {
        int a = nr1;        
        int b = nr2;
        if(a < 0)
        {
            a = -a;     // wenn a negativ, dann |a|
        }
        if(b < 0)
        {
            b = -b;     // wenn b negativ, dann |b|
        }
        if(a == 0)
        {
            a = b;      // wenn a gleich 0, dann b ist ggT
        }
        if(b == 0)
        {
            b = a;      // wenn b gleich 0, dann a ist ggT
        }
        while(a != b)
        {
            System.out.println("a = " + a + ", b = " + b);
            if(a > b)
            {
                a = a - b;
            }
            else
            {
                b = b - a;
            }
        }
        System.out.println("ggT von " + nr1 + " und " + nr2 + " ist " + a);
    }

}
Klasse und Objekte - Adresse 
package vorlesungen.vorl1113;

public class Adresse
{
    // Objektvariablen
    private String strasse;
    private int nummer;
    private int plz;
    private String wohnort;


    // Konstruktor
    public Adresse(String str, int nr, int postleitzahl, String ort)
    {
        strasse = str;
        nummer = nr;
        plz = postleitzahl;
        wohnort = ort;
    }


    // Objektmethode
    public String getAdresse()
    {
        return strasse + " " + nummer + " in " + plz + " " + wohnort;
    }

    public void strasseUmbenennen(String neuerStrassenname)
    {
        strasse = neuerStrassenname;
    }
}

package vorlesungen.vorl1113;

public class Programmklasse
{

    public static void main(String[] args)
    {
        Adresse adresse1 = new Adresse("Wilhelminenhofstrasse", 75, 12459, "Berlin");   // ein Objekt erzeugt
        Adresse adresse2 = new Adresse("Treskowallee", 8, 10435, "Berlin"); // noch ein Objekt erzeugt

        /*
        adresse1.strasse = "Wilhelminenhofstrasse"; // geht nicht wegen private
        adresse1.nummer = 75;
        adresse1.plz = 12459;
        adresse1.wohnort = "Berlin";
        */
        System.out.println(adresse1.getAdresse());
        adresse1.strasseUmbenennen("Neue Strasse");
        System.out.println(adresse1.getAdresse());

        /*
        adresse2.strasse = "Treskowallee";
        adresse2.nummer = 8;
        adresse2.plz = 10435;
        adresse2.wohnort = "Berlin";
        */
        System.out.println(adresse2.getAdresse());


    }

}
Klasse und Objekte - Point 
package vorlesungen.vorl1118;

public class Point
{
    // Objektvariablen
    private int x;
    private int y;

    // Konstruktor
    public Point(int px, int py)
    {
        x = px;
        y = py;
    }

    // Objektmethoden
    // Getter
    public int getX()
    {
        return x;
    }

    public int getY()
    {
        return y;
    }

    public void print()
    {
        System.out.println("[ x=" + x + ", y=" + y + " ]");
    }

    public void translate(int deltaX, int deltaY)
    {
        x = x + deltaX;
        y = y + deltaY;
    }

    public boolean isLeft(Point otherPoint)
    {
        return x < otherPoint.x;
    }


}

package vorlesungen.vorl1118;

public class Programmklasse
{

    public static void main(String[] args)
    {
        Point p1 = new Point(-1, 3);
        Point p2 = new Point(2, 2);

        // p1.x = 5;    // Fehler wegen private
        System.out.println("p1.x = " + p1.getX());
        System.out.println("p1.y = " + p1.getY());

        System.out.println("p2.x = " + p2.getX());
        System.out.println("p2.y = " + p2.getY());

        p1.print();
        p2.print();

        System.out.println("----------- p3 ---------------");
        Point p3 = new Point(1, 5);
        p3.print();
        p3.translate(-1, -3);
        p3.print();

        System.out.println("----------- p1 ---------------");
        p1.print();
        p2.print();
        System.out.println("p1 links von p2 ? " + p1.isLeft(p2));
        p2.print();


        Point p4 = p3;
        p4.print();
        p3.print();
        p3.translate(1, -1);
        p4.print();


    }

}
Klasse und Objekte - Circle 
package vorlesungen.vorl1120;

public class Circle
{
    // Obejektvariable
    private double radius;

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

    // Konstruktor (parameterlos)
    public Circle()
    {
        this.radius = 1.0;
    }

    public double getDiameter()
    {
        return 2.0 * this.radius;
    }

    public double getRadius()
    {
        return this.radius;
    }

    public double getPerimeter()
    {
        return Math.PI * this.getDiameter();
    }

    public double getArea()
    {
        return Math.PI * Math.pow(this.radius, 2);
    }

    public void print()
    {
        System.out.println("Radius         " + this.radius);
        System.out.println("Durchmesser    " + this.getDiameter());
        System.out.println("Umfang         " + this.getPerimeter());
        System.out.println("Flaecheninhalt " + this.getArea());
        System.out.println();
    }

    public boolean isBigger(Circle c)
    {
        return this.radius > c.radius;
    }
}

package vorlesungen.vorl1120;

public class Programmklasse
{

    public static void main(String[] args)
    {
        Circle c1 = new Circle(3.0);
        Circle c2 = new Circle(4.0);
        Circle c3 = new Circle();

        System.out.println("c1 Radius : " + c1.getRadius() + " Durchmesser : " + c1.getDiameter());
        System.out.println("c2 Radius : " + c2.getRadius() + " Durchmesser : " + c2.getDiameter());

        c1.print();
        c2.print();
        c3.print();

        System.out.println("c3 groesser als c1 ? " + c3.isBigger(c1));

        Circle c4 = c3; // 2 Referenzen auf dasselbe Objekte
        Circle c5 = new Circle();
        c5.print();

        Circle c6;      // Referenz ist null                
    }

}
Klasse und Objekte - Person 
package vorlesungen.vorl1113;

public class Adresse
{
    // Objektvariablen
    private String strasse;
    private int nummer;
    private int plz;
    private String wohnort;


    // Konstruktor
    public Adresse(String strasse, int nummer, int plz, String wohnort)
    {
        this.strasse = strasse;
        this.nummer = nummer;
        this.plz = plz;
        this.wohnort = wohnort;
    }


    // Objektmethode
    public String adresseToString()
    {
        return this.strasse + " " + this.nummer + " in " + this.plz + " " + this.wohnort;
    }

    public void strasseUmbenennen(String neuerStrassenname)
    {
        this.strasse = neuerStrassenname;
    }
}

package vorlesungen.vorl1125;

import vorlesungen.vorl1113.Adresse;

public class Person
{
    private String vorname;
    private String nachname;
    private Adresse adresse;

    public Person(String vorname, String nachname, Adresse adresse)
    {
        this.vorname = vorname;
        this.nachname = nachname;
        this.adresse = adresse;
    }

    public void print()
    {
        System.out.printf("%s %s %n%s %n", this.vorname, this.nachname, "wohnt in");
        System.out.println(this.adresse.adresseToString());
        System.out.println();
    }

    public Adresse getAdresse()
    {
        return this.adresse;
    }
}

package vorlesungen.vorl1125;

import vorlesungen.vorl1113.Adresse;

public class Programmklasse
{

    public static void main(String[] args)
    {
        Adresse wh = new Adresse("Wilhelminenhofstr.", 75, 12459, "Berlin");
        Adresse ta = new Adresse("Treskowallee", 8, 10435, "Berlin");

        Person max = new Person("Max", "Muster", new Adresse("Wilhelminenhofstr.", 75, 12459, "Berlin"));
        Person maria = new Person("Maria", "Schmidt", ta);
        Person mo = new Person("Mo", "Mueller", wh);
        Person bo = new Person("Bo", "Mueller", wh);

        max.print();
        maria.print();      // Treskowallee
        mo.print();
        bo.print();

        ta.strasseUmbenennen("Neue Strasse");

        maria.print();

        System.out.println();

        System.out.println(max.getAdresse().adresseToString());

    }

}
Klasse und Objekte - Leben von Objekten 
 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
package vorlesungen.vorl1127;

import vorlesungen.vorl1113.Adresse;
import vorlesungen.vorl1125.Person;

public class Programmklasse
{
    public static int doSomething(int beliebig)
    {
        beliebig++;
        return beliebig;
    }

    public static void doSomething(Int i)
    {
        i.increment();
    }

    public static Int createInt(int value)
    {
        Int i = new Int(value);
        return i;
    }

    public static void main(String[] args)
    {
        int i = 0;
        i = doSomething(i);
        System.out.println("i = " + i);

        Int nr1 = new Int(0);
        Int nr2 = new Int(10);
        doSomething(nr1);
        doSomething(nr2);
        System.out.println(nr1.getValue());
        System.out.println(nr2.getValue());

        Int i1 = createInt(5);

        Person p1 = new Person("Peter", "Lustig", "Lustigweg", 12, 12345, "Bayern");
        p1.print();

        Adresse pA = p1.getAdresse();
        System.out.println(pA.adresseToString());

        Adresse wh = new Adresse("Wilhelminenhofstr.", 75, 12459, "Berlin");
        Adresse ta = new Adresse("Treskowallee", 8, 10435, "Berlin");

        p1.umzug(ta);
        p1.print();

        ta.strasseUmbenennen("Neue Strasse");
        p1.print();
        p1.umzug("Noch neuer Strasse", 1, 12345, "Bayern");
        p1.print();

        Adresse a = p1.getAdresse();
        a.strasseUmbenennen("Alte Strasse");
        p1.print();
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
package vorlesungen.vorl1127;

public class Int
{
    private int value;

    public Int(int value)
    {
        this.value = value;
    }

    public void increment()
    {
        this.value++;
    }

    public int getValue()
    {
        return this.value;
    }
}

 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
package vorlesungen.vorl1125;

import vorlesungen.vorl1113.Adresse;

public class Person
{
    private String vorname;
    private String nachname;
    private Adresse adresse;

    public Person(String vorname, String nachname, Adresse adresse)
    {
        this.vorname = vorname;
        this.nachname = nachname;
        this.adresse = adresse;
    }

    public Person(String vorname, String nachname, 
            String strasse, int nummer, int plz, String wohnort)
    {
        this.vorname = vorname;
        this.nachname = nachname;
        this.adresse = new Adresse(strasse, nummer, plz, wohnort);
    }

    public void print()
    {
        System.out.printf("%s %s %n%s %n", this.vorname, this.nachname, "wohnt in");
        System.out.println(this.adresse.adresseToString());
        System.out.println();
    }

    public Adresse getAdresse()
    {
        return this.adresse;
    }

    public void umzug(Adresse neueAdresse)
    {
        this.adresse = neueAdresse;
    }

    public void umzug(String strasse, int nummer, int plz, String wohnort)
    {
        this.adresse = new Adresse(strasse, nummer, plz, wohnort);
    }
}
Vererbung 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
package vorlesungen.vorl1202;

public class Programmklasse
{

    public static void main(String[] args)
    {
        Viereck v1 = new Viereck(10,20,30,40);
        v1.print();

        Rechteck r1 = new Rechteck(80, 40);
        r1.print();

        Quadrat q1 = new Quadrat(35);
        q1.print();
    }

}

 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
package vorlesungen.vorl1202;

public class Viereck
{
    // Objektvariablen
    protected int a, b, c, d;       // Seiten des Vierecks

    public Viereck(int a, int b, int c, int d)
    {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }

    public int umfang()
    {
        return this.a + this.b + this.c + this.d;
    }

    public void print()
    {
        System.out.printf("[ a=%2d, b=%2d, c=%2d, d=%2d ]%n", this.a, this.b, this.c, this.d);
        System.out.printf("Der Umfang des Vierecks betraegt %3dcm.%n%n", this.umfang());
    }


}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
package vorlesungen.vorl1202;

public class Rechteck extends Viereck
{   
    public Rechteck(int laenge, int breite)
    {
        super(laenge, breite, laenge, breite); // Aufruf des Konstruktors von Viereck
    }

    public int flaecheninhalt()
    {
        return this.a * this.b;
    }

    @Override
    public void print()
    {
        System.out.printf("[ laenge=%2d, breite=%2d ]%n", this.a, this.b);
        System.out.printf("Der Umfang des Rechtecks betraegt %3dcm.%n", this.umfang());
        System.out.printf("Der Flaecheninhalt des Rechtecks betraegt %4dcm.%n%n", this.flaecheninhalt());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
package vorlesungen.vorl1202;

public class Quadrat extends Rechteck
{
    public Quadrat(int seite)
    {
        super(seite, seite);    // Aufruf des Konstruktors von Rechteck
    }

    @Override
    public void print()
    {
        System.out.printf("[ seite=%2d ]%n", this.a );
        System.out.printf("Der Umfang des Quadrats betraegt %3dcm.%n", this.umfang());
        System.out.printf("Der Flaecheninhalt des Quadrats betraegt %4dcm.%n%n", this.flaecheninhalt());

    }
}
Object 
 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
package vorlesungen.vorl1204;

public class Programmklasse
{

    public static void main(String[] args)
    {
        Viereck v1 = new Viereck(10,20,30,40);
        v1.print();

        Viereck r1 = new Rechteck(80, 40);
        r1.print();
        if(r1 instanceof Rechteck) {
            Rechteck r2 = (Rechteck)r1;
            System.out.println(r2.flaecheninhalt());
        }


        Viereck q1 = new Quadrat(35);
        q1.print();

        System.out.println(v1.getClass());
        System.out.println(r1.getClass());
        System.out.println(q1.getClass());

        if(q1 instanceof Quadrat)
        {
            System.out.println("q1 ist vom Laufzeittyp Quadrat");
        }
        else
        {
            System.out.println("q1 ist nicht vom Laufzeittyp Quadrat");
        }

        if(q1 instanceof Rechteck)
        {
            System.out.println("q1 ist vom Laufzeittyp Rechteck");
        }
        else
        {
            System.out.println("q1 ist nicht vom Laufzeittyp Rechteck");
        }

        if(q1 instanceof Viereck)
        {
            System.out.println("q1 ist vom Laufzeittyp Viereck");
        }
        else
        {
            System.out.println("q1 ist nicht vom Laufzeittyp Viereck");
        }

        if(q1 instanceof Object)
        {
            System.out.println("q1 ist vom Laufzeittyp Object");
        }
        else
        {
            System.out.println("q1 ist nicht vom Laufzeittyp Object");
        }

        System.out.println(q1.toString());
        System.out.println(q1);

        Viereck o1 = new Quadrat(10);
        Viereck o2 = new Rechteck(10, 20);
        Viereck o3 = new Viereck(10, 20, 30, 40);
        o1.print();
        o2.print();
        o3.print();

        Viereck ve1 = new Viereck(10,20,30,40);
        Viereck ve2 = new Viereck(10,20,30,40);
        Viereck ve3 = ve1;
        System.out.println("ve1 gleich ve2 ? " + (ve1 == ve2));     // false
        System.out.println("ve1 gleich ve3 ? " + (ve1 == ve3));     // true
        System.out.println("ve1 gleich ve2 ? " + (ve1.equals(ve2)));    // false
        System.out.println("ve1 gleich ve3 ? " + (ve1.equals(ve3)));    // true
    }

}
equals(Object) und Arrays 
 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
package vorlesungen.vorl1209;

import vorlesungen.vorl1120.Circle;
import vorlesungen.vorl1202.Rechteck;
import vorlesungen.vorl1202.Viereck;

public class Programmklasse
{

    public static void main(String[] args)
    {

        Viereck ve1 = new Viereck(10,20,30,40);
        Viereck ve2 = new Viereck(10,20,30,40);
        Viereck ve3 = ve1;
        System.out.println("ve1 gleich ve2 ? " + (ve1 == ve2));     // false
        System.out.println("ve1 gleich ve3 ? " + (ve1 == ve3));     // true
        System.out.println("ve1 gleich ve2 ? " + (ve1.equals(ve2)));    // true
        System.out.println("ve1 gleich ve3 ? " + (ve1.equals(ve3)));    // true

        Circle c1 = new Circle();
        System.out.println("ve1 gleich null ? " + (ve1.equals(null)));  // false
        System.out.println("ve1 gleich c1 ? " + (ve1.equals(c1)));      // false

        Rechteck r1 = new Rechteck(10,20);
        Rechteck r2 = new Rechteck(15,25);
        Rechteck r3;
        Rechteck r4;
        Rechteck r5;

        Rechteck[] rechtecke = new Rechteck[5];     // Laenge des Arrays ist 5
        rechtecke[0] = new Rechteck(10,20);
        rechtecke[1] = new Rechteck(15,25);
        rechtecke[2] = new Rechteck(20,30);
        rechtecke[3] = new Rechteck(25,35);
        rechtecke[4] = new Rechteck(30,40);

        rechtecke[0].print();
        rechtecke[1].print();
        rechtecke[2].print();
        rechtecke[3].print();
        rechtecke[4].print();

        for(int index = 0; index < rechtecke.length; index++)
        {
            rechtecke[index].print();
        }

        Rechteck[] vieleRechtecke = new Rechteck[1000];
        for(int index = 0; index < vieleRechtecke.length; index++)
        {
            System.out.println(index);
            int laenge = 10 + 5 * index;
            int breite = 20 + 5 * index;
            vieleRechtecke[index] = new Rechteck(laenge, breite);
            vieleRechtecke[index].print();
        }

    }

}

 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
package vorlesungen.vorl1202;

public class Viereck
{
    // Objektvariablen
    protected int a, b, c, d;       // Seiten des Vierecks

    public Viereck(int a, int b, int c, int d)
    {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }

    public int umfang()
    {
        return this.a + this.b + this.c + this.d;
    }

    public void print()
    {
        System.out.printf("[ a=%2d, b=%2d, c=%2d, d=%2d ]%n", this.a, this.b, this.c, this.d);
        System.out.printf("Der Umfang des Vierecks betraegt %3dcm.%n%n", this.umfang());
    }

    @Override
    public String toString()
    {
        return String.format("[ a=%d, b=%d, c=%d, d=%d ]", this.a, this.b, this.c, this.d);
    }

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

        // hier wissen wir: o ist Referenz auf ein Viereckobjekt
        Viereck other = (Viereck)o;
        return this.a == other.a && this.b == other.b && 
                this.c == other.c && this.d == other.d;
    }



}
Arrays 
 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
package vorlesungen.vorl1211;

public class Programmklasse
{
    public static void printIntArray(int[] numbers)
    {
        System.out.print("[ ");
        for (int index = 0; index < numbers.length; index++)
        {
            System.out.print(numbers[index]);
            if(index < numbers.length - 1)
            {
                System.out.print(", ");
            }
        }
        System.out.println(" ]");
    }

    public static void main(String[] args)
    {
        int[] numbers = new int[6];

        numbers[0] = 0;
        numbers[1] = 1;
        numbers[2] = 4;
        numbers[3] = 9;
        numbers[4] = 16;
        numbers[5] = 25;

        for(int index = 0; index < numbers.length; index++)
        {
            numbers[index] = index * index;
        }

        System.out.print("[ ");
        for (int index = 0; index < numbers.length - 1; index++)
        {
            System.out.print(numbers[index] + ", ");
        }
        System.out.println(numbers[numbers.length-1] + " ]");

        printIntArray(numbers);

        int[] numbers1 = { 1, 2, 3, 4, 5, 6, 7 };
        System.out.println(numbers1.length);
        printIntArray(numbers1);

        String[] satz = new String[5];
        satz[0] = "Das";
        satz[1] = "ist";
        satz[2] = "ein";
        satz[3] = "Satz";
        satz[4] = ".";

        for(int index = 0; index < satz.length; index++)
        {
            System.out.print(satz[index] + " ");
        }

        System.out.println();

        char[] alphabet = new char[26];
        for(int index = 0; index < alphabet.length; index++)
        {
            alphabet[index] = (char)('A' + index);
            System.out.print(alphabet[index] + " ");
        }

        System.out.println();
        char c1 = 65;
        System.out.println(c1);
        c1++;
        System.out.println(c1);


    }

}
Algorithmen über Arrays 
  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
package vorlesungen.vorl1218;

import java.util.Random;

public class Programmklasse
{
    public static void print(int[] numbers)
    {
        System.out.print("[ ");
        for (int index = 0; index < numbers.length; index++)
        {
            System.out.print(numbers[index]);
            if(index < numbers.length - 1)
            {
                System.out.print(", ");
            }
            if(index>0 && index%20 == 0)
            {
                System.out.println();
            }
        }
        System.out.println(" ]");
    }


    public static int[] createAndFillArray(int laenge)
    {
        Random r = new Random();
        // int-Array erzeugen
        int[] ia = new int[laenge];

        // Befuellen des Arrays mit Zufallszahlen
        for (int index = 0; index < ia.length; index++)
        {
            ia[index] = r.nextInt(laenge);
        }

        // Referenz auf int-Array zurueckgeben
        return ia;
    }

    public static int[] concat(int[] a, int[] b)
    {
        int[] c = new int[a.length + b.length];


        for (int index = 0; index < a.length; index++)
        {
            c[index] = a[index];
        }

        for (int index = 0; index < b.length; index++)
        {
            c[index + a.length] = b[index];
        }

        return c;
    }

    public static boolean contains(int[] a, int element)
    {
        for (int index = 0; index < a.length; index++)
        {
            if(a[index] == element)
            {
                return true;
            }
        }
        return false;
    }

    public static int getFirstIndex(int[] a, int element)
    {
        final int NOT_FOUND = -1;

        for (int index = 0; index < a.length; index++)
        {
            if(a[index] == element)
            {
                return index;
            }
        }

        return NOT_FOUND;
    }

    public static int getLastIndex(int[] a, int element)
    {
        final int NOT_FOUND = -1;

        for (int index = a.length-1; index >= 0; index--)
        {
            if(a[index] == element)
            {
                return index;
            }
        }

        return NOT_FOUND;
    }

    public static boolean containsDoublets(int[] a)
    {
        for (int index = 0; index < a.length; index++)
        {
            if(getFirstIndex(a, a[index]) != getLastIndex(a, a[index]))
            {
                return true;
            }
        }
        return false;
    }

    public static int numberOfOccurrences(int[] a, int element)
    {
        int counter = 0;
        for (int index = 0; index < a.length; index++)
        {
            if(a[index] == element)
            {
                counter++;
            }
        }
        return counter;
    }

    public static boolean isSorted(int[] a)
    {   
        /*
         * [ 1, 2, 2, 3, 6, 8, 9 ]  sortiert    true
         * [ 1, 2, 2, 1, 6, 8, 9 ]  unsortiert false
         */

        for (int index = 0; index < a.length-1; index++)
        {
            if(a[index + 1] < a[index])
            {
                return false;
            }
        }
        return true;
    }


    public static int[] append(int[] a, int value)
    {
        int[] b = new int[a.length + 1];

        // b befuellt mit allen Werten aus a
        for (int index = 0; index < a.length; index++)
        {
            b[index] = a[index];    
        }

        b[b.length-1] = value;

        return b;
    }


    public static void main(String[] args)
    {
        int[] ia1 = createAndFillArray(7);
        print(ia1);

        int[] ia2 = createAndFillArray(0);
        print(ia2);

        int[] ia3 = concat(ia1, ia2);
        print(ia3);

        System.out.println(contains(ia1, 5));
        System.out.println(getFirstIndex(ia1, 5));

        int[] sorted = {1, 2, 2, 3, 6, 8, 9};
        int[] unsorted = {1, 2, 2, 1, 6, 8, 9};
        System.out.println(isSorted(sorted));
        System.out.println(isSorted(unsorted));
    }

}
Sortieren von Arrays 
  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
package vorlesungen.vorl0106;

import java.util.Random;

public class Sortieren
{
    public static int[] createArray(int length, int bound)
    {
        Random r = new Random();

        // Array mit Laenge length erzeugen
        int[] arr = new int[length];

        // Array mit Zufasllszahlen befuellen 
        for (int index = 0; index < arr.length; index++)
        {
            arr[index] = r.nextInt(bound);
        }

        return arr;
    }

    public static void print(int[] a)
    {
        System.out.print("[ ");
        for (int index = 0; index < a.length; index++)
        {
            System.out.printf("%2d", a[index]);
            if(index < a.length-1)
            {
                System.out.print(", ");
            }
        }
        System.out.println(" ]");
    }

    public static int[] bubbleSort(int[] unsorted)
    {
        int[] sorted = new int[unsorted.length];

        // alle Werte aus unsorted nach sorted kopieren
        for (int index = 0; index < sorted.length; index++)
        {
            sorted[index] = unsorted[index];
        }

        // jetzt sorted sortieren
        for(int bubble = 1; bubble <= sorted.length-1; bubble++)
        {
            for(int index = 0; index < sorted.length-bubble; index++)
            {
                if(sorted[index] > sorted[index+1])
                {
                    int merke = sorted[index];
                    sorted[index] = sorted[index+1];
                    sorted[index+1] = merke;
                }
            }
        }

        return sorted;
    }

    public static void main(String[] args)
    {
        int[] a1 = createArray(10, 100);
        print(a1);

        boolean isSorted = false;

        for(int bubble=1; bubble <= a1.length-1 && !isSorted; bubble++)
        {
            isSorted = true;

            System.out.printf("Nach Bubble-Phase %2d (9) --> ", bubble);
            for(int index = 0; index < a1.length-bubble; index++)
            {
                if(a1[index] > a1[index+1])
                {
                    // Nachbarn tauschen
                    int merke = a1[index];
                    a1[index] = a1[index+1];
                    a1[index+1] = merke;
                    isSorted = false;
                }
            }
            print(a1);
            //System.out.println();
        }

        print(a1);

        int[] a2 = createArray(20, 100);
        print(a2);
        int[] a3 = bubbleSort(a2);
        print(a3);
        //print(a2);

    }

}
binarySearch und Circle-Array 
  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
package vorlesungen.vorl0108;

import java.util.Random;

public class Programmklasse
{

    public static void print(int[] a)
    {
        System.out.print("[ ");
        for (int index = 0; index < a.length; index++)
        {
            System.out.printf("%2d", a[index]);
            if(index < a.length-1)
            {
                System.out.print(", ");
            }
        }
        System.out.println(" ]");
    }


    public static void print(int[] a, int startIndex, int endIndex)
    {
        System.out.print("[ ");
        for (int index = startIndex; index <= endIndex; index++)
        {
            System.out.printf("%2d", a[index]);
            if(index < a.length-1)
            {
                System.out.print(", ");
            }
        }
        System.out.println(" ]");
    }

    public static int[] createArray(int length, int bound)
    {
        Random r = new Random();

        // Array mit Laenge length erzeugen
        int[] arr = new int[length];

        // Array mit Zufasllszahlen befuellen 
        for (int index = 0; index < arr.length; index++)
        {
            arr[index] = r.nextInt(bound);
        }

        return arr;
    }

    public static Circle[] createCircleArray(int length, int bound)
    {
        Random r = new Random();

        // Array mit Laenge length erzeugen
        Circle[] arr = new Circle[length];

        // Array mit Circle-Objekten befuellen 
        for (int index = 0; index < arr.length; index++)
        {
            arr[index] = new Circle(r.nextInt(bound)+1);
        }

        return arr;
    }

    public static int[] bubbleSort(int[] unsorted)
    {
        int[] sorted = new int[unsorted.length];

        // alle Werte aus unsorted nach sorted kopieren
        for (int index = 0; index < sorted.length; index++)
        {
            sorted[index] = unsorted[index];
        }

        // jetzt sorted sortieren
        for(int bubble = 1; bubble <= sorted.length-1; bubble++)
        {
            for(int index = 0; index < sorted.length-bubble; index++)
            {
                if(sorted[index] > sorted[index+1])
                {
                    int merke = sorted[index];
                    sorted[index] = sorted[index+1];
                    sorted[index+1] = merke;
                }
            }
        }

        return sorted;
    }

    public static boolean containsInUnsorted(int[] a, int element)
    {
        for (int index = 0; index < a.length; index++)
        {
            if(a[index] == element)
            {
                return true;
            }
        }
        return false;
    }


    public static boolean containsInSorted(int[] a, int element)
    {
        for (int index = 0; index < a.length; index++)
        {
            if(a[index] == element)
            {
                return true;
            }
            if(a[index] > element)
            {
                return false;
            }
        }
        return false;
    }

    public static boolean binarySearch(int[] a, int element)
    {
        int lo = 0;
        int hi = a.length - 1;

        while(lo <= hi) 
        {
            print(a, lo, hi);
            int mid = (lo + hi) / 2;
            if(a[mid]==element) // element gefunden
            {
                return true;
            }

            if(element < a[mid])
            {
                hi = mid - 1;
            }
            else // element > a[mid]
            {
                lo = mid + 1;
            }
        }
        return false;
    }

    public static void main(String[] args)
    {
        int[] a1 = createArray(50, 100);
        print(a1);
        int[] a2 = bubbleSort(a1);
        print(a2);
        System.out.println(binarySearch(a2, 26));

        Circle[] c1 = createCircleArray(10, 10);
        for (int index = 0; index < c1.length; index++)
        {
            c1[index].print();
        }

        for (int bubble = 1; bubble < c1.length; bubble++)
        {
            for (int index = 0; index < c1.length - bubble; index++)
            {
                if(c1[index].isBigger(c1[index+1]))
                {
                    Circle merke = c1[index];
                    c1[index] = c1[index+1];
                    c1[index+1] = merke;
                }
            }
        }
        System.out.printf("%n--------- jetzt sortiert (hofentlich) ------%n%n");

        for (int index = 0; index < c1.length; index++)
        {
            c1[index].print();
        }

    }

}

 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
package vorlesungen.vorl0108;

public class Circle
{
    // Obejektvariable
    private double radius;

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

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

    public double getDiameter()
    {
        return 2.0 * this.radius;
    }

    public double getRadius()
    {
        return this.radius;
    }

    public double getPerimeter()
    {
        return Math.PI * this.getDiameter();
    }

    public double getArea()
    {
        return Math.PI * Math.pow(this.radius, 2);
    }

    public void print()
    {
        System.out.println("Radius         " + this.radius);
        System.out.println("Durchmesser    " + this.getDiameter());
        System.out.println("Umfang         " + this.getPerimeter());
        System.out.println("Flaecheninhalt " + this.getArea());
        System.out.println();
    }

    public boolean isBigger(Circle c)
    {
        return this.radius > c.radius;
    }
}
Klausurvorbereitung 13.-15.1.2025 
package vorlesungen.vorl0113;

import java.util.Arrays;

public class Testklasse
{

    public static int[] insertIntoSorted(int[] old, int element)
    {
        int[] newArray = new int[old.length + 1];

        int index = 0;
        // erstmal alle Werte aus old in newArray kopieren,
        // die kleiner sind als element
        while(index < old.length && old[index] < element)
        {
            newArray[index] = old[index];
            index++;
        }

        // element hinzufuegen
        newArray[index] = element;

        // Rest kopieren
        /*
        for (int i = index; i < newArray.length; i++)
        {
            newArray[i+1] = old[i];
        }
        */
        while(index < old.length)
        {
            newArray[index+1] = old[index];
            index++;
        }

        return newArray;
    }


    public static int[] mergeSorted(int[] a1, int[] a2)
    {

        int[] merged = a1;

        for(int index = 0; index < a2.length; index++)
        {
            merged = insertIntoSorted(merged, a2[index]);
            //System.out.printf("merged %d : %s %n", index, Arrays.toString(merged));
        }


        return merged;  
    }

    public static int[] mergeSorted2(int[] a1, int[] a2)
    {

        int[] merged = new int[a1.length + a2.length];

        int indexA1 = 0;
        int indexA2 = 0;

        for(int index = 0; index < merged.length; index++)
        {
            if(indexA1 == a1.length)
            {
                merged[index] = a2[indexA2];
                indexA2++;
            } 
            else if(indexA2 == a2.length)
            {
                merged[index] = a1[indexA1];
                indexA1++;
            }
            else if(a1[indexA1] < a2[indexA2])
            {
                merged[index] = a1[indexA1];
                indexA1++;
            }
            else
            {
                merged[index] = a2[indexA2];
                indexA2++;
            }
        }

        return merged;  
    }

    public static void main(String[] args)
    {
        System.out.printf("%n%n--------------------- Test Wohnung -------------------------%n%n");
        Wohnung w1 = new Wohnung(70, 3, 4, 12.50);
        Wohnung w2 = new Wohnung(40, 1, 0, 9.50);
        Wohnung w3 = new Wohnung(90, 4, 2, 11.10);
        Wohnung w4 = new Wohnung(60, 2, 0, 9.00);

        w1.print();
        w2.print();
        w3.print();
        w4.print();

        System.out.printf("%n%n--------------- Test Dachgeschosswohnung -------------------%n%n");
        Dachgeschosswohnung dg1 = new Dachgeschosswohnung(70, 3, 15.50);
        Dachgeschosswohnung dg2 = new Dachgeschosswohnung(100, 4, 17.25);

        dg1.print();
        dg2.print();

        System.out.printf("%n%n---------------------- Test Haus ---------------------------%n%n");
        Haus h1 = new Haus(10);
        h1.print();


        int[] a1 = { 3, 5, 9, 11, 13, 17, 19 };
        int[] a2 = insertIntoSorted(a1, 12);
        System.out.println(Arrays.toString(a2));
        int[] a3 = insertIntoSorted(a1, 1);
        System.out.println(Arrays.toString(a3));
        int[] a4 = insertIntoSorted(a1, 21);
        System.out.println(Arrays.toString(a4));
        int[] a5 = { 1, 2, 8, 10, 12, 17, 18, 19, 21, 22 };
        System.out.println("a1 : " + Arrays.toString(a1));
        System.out.println("a5 : " + Arrays.toString(a5));
        int[] a6 = mergeSorted2(a1, a5);
        System.out.println("a6 : " + Arrays.toString(a6));
    }

}

package vorlesungen.vorl0113;

public class Wohnung
{
    private int qm;
    private int anzZimmer;
    private int etage;
    private double qmMiete;

    public Wohnung(int qm, int anzZimmer, int etage, double qmMiete)
    {
        this.qm = qm;
        this.anzZimmer = anzZimmer;
        this.etage = etage;
        this.qmMiete = qmMiete;
    }

    public int getQm()
    {
        return this.qm;
    }

    public int getAnzZimmer()
    {
        return this.anzZimmer;
    }

    public int getEtage()
    {
        return this.etage;
    }

    public double getQmMiete()
    {
        return this.qmMiete;
    }

    public double gesamtMiete()
    {
        return this.qm * this.qmMiete;
    }

    public boolean billiger(Wohnung w)
    {
        return this.gesamtMiete() < w.gesamtMiete();
    }

    public boolean teurer(Wohnung w)
    {
        return this.gesamtMiete() > w.gesamtMiete();
    }

    @Override
    public String toString()
    {
        /*
        return this.anzZimmer + "-Zimmer Wohnung mit ";
        s += this.qm + " qm in der " + this.etage + ". Etage.";
        s += " Monatliche Miete: "+ this.gesamtMiete() + " Euro.";
        */

        if(this.etage > 0)
        {
            return String.format("%d-Zimmer Wohnung mit %d qm in der %d. Etage. "
                    + "Monatliche Miete: %.2f Euro.", 
                this.anzZimmer, this.qm, this.etage, this.gesamtMiete());
        }
        else
        {
            return String.format("%d-Zimmer Wohnung mit %d qm im Erdgeschoss. "
                    + "Monatliche Miete: %.2f Euro.", 
                    this.anzZimmer, this.qm, this.gesamtMiete());
        }
    }

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

}

package vorlesungen.vorl0113;

public class Dachgeschosswohnung extends Wohnung
{
    boolean balkon;

    public Dachgeschosswohnung(int qm, int anzZimmer, double qmMiete)
    {
        super(qm, anzZimmer, 5, qmMiete);
        //this.balkon = balkon;
    }

    @Override
    public String toString()
    {
        String s = this.getAnzZimmer() + "-Zimmer DG-Wohnung mit ";
         s += this.getQm() + " qm in der 5. Etage. Monatliche Miete: ";
         s += this.gesamtMiete() + " Euro.";

        return s;
    }
}

package vorlesungen.vorl0113;

import java.util.Random;

public class Haus
{
    private Wohnung[] wohnungen;

    public Haus(int anzWohnungen)
    {
        this.wohnungen = new Wohnung[anzWohnungen];
        for (int index = 0; index < this.wohnungen.length; index++)
        {
            this.wohnungen[index] = this.neueWohnung();
        }
    }

    public Wohnung neueWohnung()
    {
        /*
         * Ein Wert für eine Quadratmeteranzahl qm aus dem Wertebereich [20, 40, 60, 80, 100] ( → also zufällig eine dieser 5 Zahlen),
         * Ein Wert für die Anzahl der Zimmer anzZimmer aus dem Wertebereich [1, 2, 3, 4, 5] ( → also zufällig eine dieser 5 Zahlen),
         * Ein Wert für die Etage etage aus dem Wertebereich [0, 1, 2, 3, 4, 5] ( → also zufällig eine dieser 6 Zahlen),
         * Ein Wert für den Mietpreis pro Quadratmeter qmMiete aus dem Wertebereich [8.0, 8.5, 9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0, 12.5] ( → also zufällig eine dieser 10 Zahlen – Achtung hier double, Sie können aber trotzdem nextInt(int bound) verwenden, müssen dann aber geeignet multiplizieren und addieren). Erzeugen Sie mit diesen Werten ein neues Wohnung-Objekt und geben Sie dieses Objekt zurück.
         */
        Random r = new Random();
        /*
        int[] qmarr = {20, 40, 60, 80, 100};
        int index = r.nextInt(5);
        int qm1 = qmarr[index];
        */
        int qm = (r.nextInt(5) + 1) * 20;
        int anzZimmer = r.nextInt(5) + 1;
        int etage = r.nextInt(6);
        double qmMiete = 8 + r.nextInt(10) * 0.5; 

        Wohnung w = new Wohnung(qm, anzZimmer, etage, qmMiete);
        return w;

    }

    public void print()
    {
        System.out.println("Das Haus besteht aus: ");
        for (int index = 0; index < this.wohnungen.length; index++)
        {
            System.out.println("  " + this.wohnungen[index].toString());
            // oder:
            // System.out.println("  "); 
            // this.wohnungen[index].print();
        }
    }
}

package vorlesungen.vorl0113;

public class SortedArray
{
    int[] s;

    SortedArray()
    {
        this.s = new int[0];
    }

    public boolean contains(int element)
    {
        for (int index = 0; index < this.s.length; index++)
        {
            if(this.s[index] == element)
            {
                return true;
            }
        }
        return false;
    }

    public boolean insert(int element)
    {
        if(this.contains(element))
        {
            return false;
        }
        int[] newArray = new int[this.s.length + 1];
        int index = 0;
        while(index < this.s.length && this.s[index] < element)
        {
            newArray[index] = this.s[index];
            index++;
        }

        newArray[index] = element;

        while(index < this.s.length)
        {
            newArray[index+1] = this.s[index];
            index++;
        }

        this.s = newArray;

        return true;
    }
}
Klausurvorbereitung 22.1.2025 
package vorlesungen.vorl0122;

public class Programmklasse
{

    public static void main(String[] args)
    {
        final int ascii_a = 65;
        for(int nr = 0; nr<10; nr++)
        {
            char c1 = (char)(ascii_a + nr);
            System.out.println(c1);
        }

        Produkt p = new Produkt();
        for(int anz = 0; anz < 5; anz++)
        {
            int nummer = p.erzeuge8stelligeNummer();
            double preis = p.erzeugePreis(nummer);
            String code = p.erzeugeCode();
            System.out.printf("%d %.2f Euro %s %n", nummer, preis, code);
        }

    }

}

package vorlesungen.vorl0122;

import java.util.Random;

public class Produkt
{
    private int nummer;
    private double preis;
    private String code;

    public String getCode()
    {
        return this.code;
    }

    public Produkt()
    {
        this.nummer = this.erzeuge8stelligeNummer();
        this.preis = this.erzeugePreis(this.nummer);
        this.code = this.erzeugeCode();
    }

    public int erzeuge8stelligeNummer()
    {
        Random r = new Random();
        return r.nextInt(90000000) + 10000000;
    }

    public double erzeugePreis(final int nummer)
    {
        int copynummer = nummer;
        while(copynummer > 9999)
        {
            copynummer = copynummer / 10;
        }
        double preis = copynummer / 100.0;
        return preis;
    }

    public String erzeugeCode()
    {
        String s = "";
        final int CODE_LENGTH = 4;
        Random r = new Random();
        /*
        for(int anz = 0; anz < 4; anz++)
        {
            char buchstabe = (char)(r.nextInt(10) + 65);
            s = s + buchstabe;
        }
        */
        while(s.length() < CODE_LENGTH)
        {
            char buchstabe = (char)(r.nextInt(10) + 65);
            s = s + buchstabe;
        }

        return s;
    }

    @Override
    public String toString()
    {
        return String.format("%d %.2f Euro %s", this.nummer, this.preis, this.code);
    }

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

    public boolean istTeurer(Produkt p)
    {
        return this.preis > p.preis;
    }


}

package vorlesungen.vorl0122;

public class Produktgruppe
{

}

Hinweise zur Klausur

  • Es stehen immer ein Mac-Labor (z.B. 624) und ein Windows-Labor (z.B. 625) zur Verfügung.
  • Wenn die Klausur auf 10 Uhr angesetzt ist, werden die Aufgabenblätter ca. 9:45 Uhr ausgeteilt, so dass um ca. 9:55 Uhr mit dem Programmieren begonnen werden kann. Seien Sie am besten spätestens eine halbe Stunde vor dem offiziellen Beginn in dem Labor Ihrer Wahl.
  • Sie können sich vorab schon ein Package klausur erstellen und darin eine Programmklasse mit main-Methode. Probieren Sie auch schonmal mindestens eine Ausgabe auf die Konsole, damit Sie wissen, ob alles funktioniert.
  • Sie können sich in Ihren Workspace gerne allen Ihren Code importieren, den Sie im Laufe des Semesters erzeugt haben (üben Sie den Import dann am besten vorher - Sie können sich nicht sicher sein, dass Sie an dem Rechner die Klausur schreiben können, an dem Sie den Import geübt haben).
  • Sie dürfen während der Klausur im Web browsen und sogar Google verwenden (nicht jedoch Bing).
  • Es ist nicht gestattet:
    • den eigenen Rechner zu verwenden (gar nicht mitbringen oder auspacken)
    • das Handy zu verwenden (gar nicht mitbringen oder auspacken)
    • Kommunikation mit anderen oder mit KI-Tools
  • Wichtig!
    • Mit Teilnahme an der Klausur gestatten Sie uns, nachträglich die Access-Logs der Rechner im Labor zu überprüfen!
    • Bereits geöffnete Programme oder Tabs (selbst, wenn Sie unbenutzt sind), die eine Kommunikation mit anderen (z.B. E-Mail, Chats, KI, ...) ermöglichen, führen zum Ausschluss aus der Klausur.
  • Sollte sich herausstellen, dass 2 Labore nicht genügen, weichen wir auf ein drittes Labor aus (Windows). Deswegen ist es wichtig, dass Sie spätestens eine halbe Stunde vor Beginn vor Ort sind.
  • Bitte beachten Sie auch, dass wir nicht beim Hochladen der Lösung in Moodle unterstützen können. Das haben Sie für die Aufgaben genügend geübt. Wichtig ist, dass Sie wissen, wo Ihr workspace auf dem Rechner ist, damit Sie von dort aus hochladen können.