Zum Inhalt

Programmieren I

Herzlich willkommen zur Programmieren I Veranstaltung! Wir werden unter Verwendung der Programmiersprache die wesentlichen Konzepte lernen, die für das Verständnis mordenen 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. 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 verdeutlicht
  • das Skript und die Videos werden (spätestens) freitags hochgeladen (gilt dann für die gesamte Woche - also Freitag + Dienstag)
  • 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 dienstags (12.15 Uhr) und mittwochs (9:45 Uhr) besprochen (Sie können frei wählen, welche der beiden Übungen Sie wählen)
  • bei Bedarf können wir auch gerne eine Synchron-Video-Vorlesung einschieben, um Fragen zu erklären
  • 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 Moodle hochladen. Wenn Sie alle Aufgaben fristgerecht hochgeladen haben, dürfen Sie an der Klausur teilnehmen. Es werden insgesamt wahrscheinlich 9 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 "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 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.

Planung (vorläufig - kann sich noch ändern)

Nachfolgend der vorläufige Wochenplan (wird eventuell angepasst). Die Vorlesungsvideos finden Sie darunter für die einzelnen Wochen (unter Themen).

Woche Themen (Vorlesung) Aufgabe Abgabe Aufgabe bis
1. 02.-06.11.2020 Einführung und Organisatorisches, erstes Programm - -
2. 09.-13.11.2020 Datentypen und Variablen, logische Ausdrücke Aufgabe 1 22.11.2020
3. 16.-20.11.2020 Sequenzen, Iterationen und Selektion Aufgabe 2 29.11.2020
4. 23.-27.11.2020 Nützliche Klassen, Einführung Arrays Aufgabe 3 06.12.2020
5. 30.-04.12.2020 Sortieren von Arrays Aufgabe 4 13.12.2020
6. 07.-11.12.2020 Klassen und Objekte Aufgabe 5 20.12.2020
7. 14.-18.12.2020 Konstruktoren, this, eigene Datentypen, Rückgabe von Objekten Aufgabe 6 10.01.2021
8. 21.-25.12.2020 Klassen- und Objekt-Variablen und -Methoden Aufgabe 7 17.01.2021
 
9. 04.-08.01.2021 Vererbung Aufgabe 8 24.01.2021
10. 11.-15.01.2021 Object und Polymorphie - -
11. 18.-22.01.2021 return - -
12. 25.-29.01.2021 Wiederholung, Klausurvorbereitung Fragen -
13. 01.-05.02.2021 Wiederholung, Klausurvorbereitung -

Themen

Hier sind die Themen in chronologischer Folge aufgeführt, wie wir sie auch in den Vorlesungen behandeln. Durch interne Links werden Bezüge innerhalb der Themen hergestellt. Sie können die Themen in dieser Folge abarbeiten, können aber auch beliebig hin- und herspringen. Zu jeden Themen gibt es Übungsaufgaben. Diese sind ebenfalls verlinkt. Sollten Sie zu einzelnen Themen das Gefühl haben, dass diese nicht ausführlich genug beschrieben sind, geben Sie mir bitte Bescheid. Ziel ist, dass dieses "Skript" Ihnen die Einführung in das Programmieren vollständig ermöglicht. Das heißt nicht, dass Sie nicht weitere Literatur verwenden sollen. Einen Überblick über geeignete Literatur finden Sie hier.

03.11.2020 - Einführung und Organisatorisches
  • siehe Übung 0
  • Zoom-Meeting (sorry, leider zu spät auf Aufnahme gedrückt - vergessen, aber es steht alles hier oben)
  • MyFirstClass.java 
      package uebungen.uebung0;
  /**
   * 
   * @author jornfreiheit
   *
   */
  public class MyFirstClass {

      public static void main(String[] args) {
          System.out.println("Hallo FIW!");
          System.out.println();   // das ist eine Leerzeile
          System.out.println("Wir programmieren!!!");
          System.out.println("Hurra!!!");
          /*
           * 
           * das ist ein Block-Kommentar
           * kann über mehrere Zeilen gehen
           */
      }
  }
06.11. + 10.11.2020 - Variablen, Datentypen, Methoden, Selektion
  • siehe Übung 1
  • Variablen (siehe Skript Variablen)
  • Variablen.java 
      package themen.variablen;

  public class Variablen 
  {

      public static void main(String[] args) 
      {
          System.out.println("Thema heute: Variablen");
          System.out.println("Im Skript unter http://freiheit.f4.htw-berlin.de/prog1/variablen/");
          System.out.println();
          /*
           * Erzeugen einer Variable: "Deklarieren der Variable"
           * datentyp variablenName;
           * 
           * Datentypen???
           * 
           * ganzzahlige Datentypen: int, long, short, byte
           */
          int ganzeZahl;  // Variable ganzeZahl erzeugt (1x)!
          int nochEineGanzeZahl = 0;  // Deklaration und Wertzuweisung (Initialisierung)

          long grosseGanzeZahl = 123456789L;  // int 32 bit , aber long 64 bit
          short kleinereGanzeZahl = 123;      // 16 bit
          byte ganzKleineGanzeZahl = 127;     // 8 bit

          /*
           * Datentypen, um Gleitkommazahlen zu speichern
           * double, float
           */
          double number1 = 6.789;         // 64 bit
          float number2 = 5.0f;           // 32 bit

          /*
           * Datentyp, um ein Zeichen (character) zu speichern
           * char
           */
          char zeichen = 'a';
          char zeichen1 = 97;
          char zeichen2 = '\u00a9'; 

          /*
           * Datentyp, um Wahrheitswerte zu speichern
           * boolean
           */
          boolean condition = true;
          boolean condition1 = false;

          /*
           * Wertzuweisung
           * Wertzuweisungsoperator =
           * variablenName = wert;
           */
          ganzeZahl = 7;  // Wertzuweisung beliebig oft
          System.out.println(ganzeZahl);
          ganzeZahl = -123;
          System.out.println(ganzeZahl);
          System.out.println(grosseGanzeZahl);
          System.out.println(ganzKleineGanzeZahl);
          System.out.println(number1);
          System.out.println(number2);
          System.out.println(zeichen);
          System.out.println(zeichen1);
          System.out.println(zeichen2);
          System.out.println(condition);
          System.out.println(condition1); 

          /*
           * bis hier her Wertetypen
           * jetzt noch ein Datentyp
           * String
           * (Referenztyp)
           * 
           */
          String zeichenkette = "Hallo";
          System.out.println(zeichenkette);


      }

  }
  • Ausdrücke und Operatoren (siehe Skript Ausdrücke und Operatoren)
  • Ausdruecke.java 
      package themen.ausdruecke;

  public class Ausdruecke
  {

      public static void main(String[] args)
      {
          System.out.println("Thema heute: Ausdruecke");
          System.out.println("Im Skript unter http://freiheit.f4.htw-berlin.de/prog1/ausdruecke/#operatoren-und-ausdrucke");
          System.out.println();

          int a = 8;
          int b = 2;
          int c = 0;
          c = a + b;
          System.out.println(c);

          a = a + b;
          System.out.println(a);
          a = a * b;
          System.out.println(a);
          a = a / b;
          System.out.println(a);
          a = a - b;
          System.out.println(a);
          a = 7;
          a = a / b;              // 7 / 2 --> ganzzahlige Division!
          System.out.println(a);  // a ist 3
          a = 7;
          a = a % b;              // Restwertoperator (modulo)
          System.out.println(a);

          double x = 8.2;
          double y = 2.3;

          x = x + y;
          System.out.println(x);
          x = x * y;
          System.out.println(x);
          x = x - y;
          System.out.println(x);
          x = 7.0;
          y = 2.0;
          x = x / y;              // 7.0 / 2.0 --> Gleitkomma-Division!
          System.out.println(x);  // a ist 3.5
          x = 7.0;
          x = x % y;
          System.out.println(x);

          a++;        // a = a + 1;
          System.out.println(a);
          ++a;        // a = a + 1;
          System.out.println(a);
          b = 0;
          a = 2;
          b = ++a;
          System.out.println(b);
          System.out.println(a);
          b = a++;
          System.out.println(b);
          System.out.println(a);

          a--;        // a = a - 1;
          --a;        // a = a - 1;

          a = 5;
          a += 4;     // a = a + 4;
          a *= 3;     // a = a * 3;
          a /= 4;     // a = a / 4;
          a -= 3;     // a = a - 3;
          a %= 2;     // a = a % 2;

          double d = 5.0;
          int e = 2;
          System.out.println(d / e);      // Gleitkommadivision
          System.out.println(e / d);      // Gleitkommadivision

          System.out.println(7 == 2);     // Gleichheit  --> Ergebnis ist boolean
          System.out.println(7 == 7);     // Gleichheit  --> Ergebnis ist boolean

          System.out.println(7 != 2);     // Ungleichheit  --> Ergebnis ist boolean
          System.out.println(7 != 7);     // Ungleichheit  --> Ergebnis ist boolean

          System.out.println(7 > 2);  // groesser als  --> Ergebnis ist boolean
          System.out.println(7 > 7);  // groesser als  --> Ergebnis ist boolean

          System.out.println(7 < 2);  // kleiner als  --> Ergebnis ist boolean
          System.out.println(7 < 7);  // kleiner als  --> Ergebnis ist boolean

          System.out.println(7 <= 2);     // kleiner gleich  --> Ergebnis ist boolean
          System.out.println(7 <= 7);     // kleiner gleich  --> Ergebnis ist boolean

          System.out.println(7 >= 2);     // groesser gleich  --> Ergebnis ist boolean
          System.out.println(7 >= 7);     // groesser gleich  --> Ergebnis ist boolean

          boolean check = 7 != 2;
          System.out.println(check);

          boolean b1 = true;
          boolean b2 = false;

          System.out.println(" -------- Negation ---------- ");
          System.out.println(b1);
          b1 = !b1;       // Negation
          b2 = !b2;       // Negation
          System.out.println(b1);
          System.out.println(b2);

          System.out.println(" -------- logisches UND ---------- ");
          System.out.println(false && true);      // false UND true --> false
          System.out.println(true && true);       // true UND true --> true
          System.out.println(true && false);      // true UND false --> false
          System.out.println(false && false);     // false UND false --> false

          System.out.println(" -------- logisches ODER ---------- ");
          System.out.println(false || true);      // false ODER true --> true
          System.out.println(true || true);       // true ODER true --> true
          System.out.println(true || false);      // true ODER false --> true
          System.out.println(false || false);     // false ODER false --> false

          System.out.println(" -------- logisches EXCLUSIVES ODER ---------- ");
          System.out.println(false ^ true);       // false EXCL. ODER true --> true
          System.out.println(true ^ true);        // true EXCL. ODER true --> false
          System.out.println(true ^ false);       // true EXCL. ODER false --> true
          System.out.println(false ^ false);      // false EXCL. ODER false --> false

          System.out.println(" -------- String-Verkettung ---------- ");
          String s1 = "Hallo ";
          String s2 = "FIW!";
          System.out.println(s1 + s2);    // Verkettung von Strings (Konkatenation) 
          s1 = s1 + s2;                   // "Hallo FIW!"
          System.out.println(s1);

          int z1 = 22;
          int z2 = 11;
          int result = z1/z2;
          System.out.println("das Resultat ist : " + result);  // Konkatenation
          System.out.println(z1 + " / " + z2 + " = " + result);

          System.out.println(3 + " + " + 4 + " = " + 3 + 4);      // warum?
          System.out.println(3 + " + " + 4 + " = " + (3 + 4));    // warum?
      }
  }
  • Methoden (siehe Skript Methoden)
  • Methoden.java 
      package themen.methoden;

  public class Methoden
  {

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

      public static void divide(int divident, int divisor)
      {
          int quotient = divident / divisor;
          int rest = divident % divisor;
          System.out.println(divident + " / " + divisor + " = " 
          + quotient + " mit dem Rest "  + rest);
      }

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

      public static boolean greaterThanZero(int number)
      {
          return (number > 0);
      }

      public static void main(String[] args)
      {
          System.out.println("Thema heute: Methoden");
          System.out.println("Im Skript unter http://freiheit.f4.htw-berlin.de/prog1/methoden/#methoden");
          System.out.println();

          /*
          int summand1 = 3;
          int summand2 = 4;
          int summe = summand1 + summand2;
          System.out.println(summand1 + " + " + summand2 + " = " + summe);

          summand1 = 5;
          summand2 = 9;
          summe = summand1 + summand2;
          System.out.println(summand1 + " + " + summand2 + " = " + summe);

          summand1 = -115;
          summand2 = 999;
          summe = summand1 + summand2;
          System.out.println(summand1 + " + " + summand2 + " = " + summe);    
          */

          add(3, 4);
          add(5, 9);
          add(-115, 999);

          divide(17, 12);
          divide(12, 4);

          int sum = computeSum(3, 4);
          System.out.println(sum);
          System.out.println(computeSum(5,9));

          System.out.println(greaterThanZero(-7));
      }

  }
  • Selektion (siehe Skript Selektion)
13.11. + 17.11.2020 - Iteration (Schleifen), Methodenstack, Sichtbarkeit und Lebensdauer von Variablen
  • siehe Aufgabe 1
  • siehe Übung 2

  • Iteration (siehe Skript Iteration)

  • Schleifen.java aus dem Video
      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
    package themen.iteration;

public class Schleifen
{
    /*
     * verschachtelte Schleife
     * innere Schleife wird immer vollstaendig ausgefuehrt (j von 0 bis 6)
     * erst dann wieder i erhoehen --> dann wieder innere Schleife vollstaendig ausfuehren
     */
    public static void printSchleifeInSchleife()
    {
        for(int i=0; i<8; i++)
        {
            System.out.println("i : " + i + " ----------");
            for(int j=0; j<7; j++)
            {
                System.out.println("j : " + j);
            }
        }
    }

    /* 
     * width gibt Anzahl der Sterne an, die wir in einer Zeile ausgeben
     * height gibt an, wieviele Zeilen wir ausgeben
     */
    public static void printRectangle(int width, int height)
    {
        for(int row=0; row<height; row++)
        {
            for(int stars=0; stars < width; stars++)
            {
                System.out.print("*");
            }
            System.out.println();
        }
    }

    /*
     * es wird eine Folge von Zahlen berechnet
     * die Folge stoppt, wenn die Zahl den Wert 1 hat
     * ist die Zahl gerade, wird der Nachfolger berechnet, 
     * indem die Zahl durch 2 geteilt wird
     * ist die Zahl ungerade, wird der Nachfolger berechnet,
     * indem die Zahl mal 3 multipliziert und dann 1 addiert wird
     * Abbruch bei zahl==1, aber gar nicht sicher, ob das fuer
     * jeden Startwert erreicht wird
     */
    public static void collatzFolge(int start)
    {
        int zahl = start;

        while(zahl!=1)
        {
            System.out.print(zahl + " ");
            if(zahl%2==0)
            {
                zahl = zahl/2;
            }
            else
            {
                zahl = 3*zahl + 1;
            }
        }
        System.out.println("Ende - Zahl ist " + zahl);
    }

    /*
     * Programmethode
     */
    public static void main(String[] args)
    {
        System.out.println("Thema heute : Iterationen (Schleifen) ------------------------");
        System.out.println("Skript      : http://freiheit.f4.htw-berlin.de/prog1/iteration");

        /*
         * Sequenz
         */
        System.out.println("Das");
        System.out.println("ist ");
        System.out.println("eine Sequenz ");

        /*
         * Selektion
         */
        int i = -1;
        if(i==0)
        {
            System.out.println("Der Wert der Variable i ist 0");
        }
        else
        {
            System.out.println("Der Wert der Variable i ist ungleich 0");
        }

        /*
         * Iteration
         * 3 verschiedene Schleifen in Java:
         * - for-Schleife
         * - while-Schleife
         * - do-while-Schleife
         * 
         * zunaechst: for-Schleife
         */
        for(int lauf = 10; lauf > 0; lauf-=2)   // lauf = lauf - 2;
        {
            System.out.println(lauf + ": Diese Anweisung soll wiederholt werden");
            if(lauf%2==0)
            {
                System.out.println("Zahl ist gerade");
            }
        }
        System.out.println("Schleife verlassen - Bedingung false");

        /*
         * verschachtelte Schleife in der Methode 
         * printSchleifeInSchleife()
         */
        System.out.println();
        System.out.println();
        printSchleifeInSchleife();

        /*
         * verschachtelte Schleife in der Methode
         * printRectangle(width, height)
         * siehe auch Skript
         */
        System.out.println();
        System.out.println();
        printRectangle(70, 14);

        /*
         * while-Schleife in der Methode
         * collatzFolge(start)
         */
        System.out.println();
        System.out.println();
        collatzFolge(111);

        /*
         * letzte Schleife, die es in Java gibt
         * do-while-Schleife
         * 
         */
        System.out.println();
        System.out.println();
        int wert = 12;
        do {
            wert = wert/3;
            System.out.println(wert);
        }while(wert > 0);
        System.out.println("Ende"); 
    }
}

  • Methodenstack, Lebensdauer und Sichtbarkeit von Variablen (siehe Skript Methodenstack)

20.11. + 24.11.2020 - Scanner, Math, Random, String, Einführung Arrays
  • siehe Aufgabe 2
  • siehe Übung 3
  • siehe Skript Nützliche Klassen - Scanner, Math, Random, String

  • Video zu Nützliche Klassen - Scanner, Math, Random, String

  • Hilfsklassen.java aus dem Video
     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
    package themen.hilfsklassen;

import java.util.Random;
import java.util.Scanner;

/**
 * 
 * @author jornfreiheit
 * 
 * Wir erstellen eine Tabelle der Form:
 *  System.out.println("  a   |   b   |  a + b   |  a - b  |  a * b  |  a / b  |  a % b |  sqrt(a) |  sqrt(b) |                          2^a    |");
 *  System.out.println("-------------------------------------------------------------------------------------------------------------------------");
 *
 * und verwenden dazu einige nützliche Klassen:
 *  Scanner zum Einlesen von Werten von der Konsole
 *  Random für das Erzeugen von Zufallszahlen
 *  Math für einige mathematische Funktionen 
 * 
 * und nützliche Methoden für das Formatieren von Ausgaben
 *  String.format()
 *  System.out.printf()
 *  
 *  im Skript: http://freiheit.f4.htw-berlin.de/prog1/hilfsklassen/#nutzliche-klassen
 *  
 */
public class Hilfsklassen
{
    public static int inputIntNumber()
    {
        Scanner sc = new Scanner(System.in);
        System.out.print("Geben Sie eine Zahl ein : ");
        int zahl = sc.nextInt();
        return zahl;
    }

    public static void createTable(int rows)
    {
        System.out.println("  a   |   b   |  a + b   |  a - b  |  a * b  |  a / b  |  a % b |  sqrt(a) |  sqrt(b) |                          2^a    |");
        System.out.println("-------------------------------------------------------------------------------------------------------------------------");
        for(int i=0; i<rows; i++)
        {
            Random r = new Random();
            int number1 = r.nextInt(100)+1;
            int number2 = r.nextInt(100)+1;
            double sqrtNr1 = Math.sqrt(number1);
            double sqrtNr2 = Math.sqrt(number2);
            double pow2Nr1 = Math.pow(2, number1);
            String output = String.format("%4d  | %4d  |  %5d   | %5d   | %7d |  %5d  | %6d | %8.5f | %8.5f | %31.0f | %n", number1, number2, 
                    (number1+number2), (number1-number2), (number1*number2), (number1/number2), (number1%number2), 
                    sqrtNr1, sqrtNr2, pow2Nr1 );
            //System.out.printf("%4d  | %4d  | %n", number1, number2);
            System.out.print(output);
        }
    }

    public static void main(String[] args)
    {
        int rows = inputIntNumber();
        System.out.println();
        createTable(rows);

    }

}

  • siehe Skript Einführung Arrays

  • Video zu Einführung Arrays

  • MyArrays.java aus dem Video
     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
    package themen.arrays;

/**
 * 
 * @author jornfreiheit
 *
 * Kurze Einfuehrung in Arrays
 * 
 * Skript: http://freiheit.f4.htw-berlin.de/prog1/arrays/#arrays
 */
public class MyArrays
{

    public static void main(String[] args)
    {
        int number1 = 0;
        int number2 = 1;
        int number3 = 4;
        int number4 = 9;
        int number5 = 16;

        int[] numbers = new int[5];     // Laenge 5 --> 5 Elemente
        numbers[0] = 0;
        numbers[1] = 1;
        numbers[2] = 4;
        numbers[3] = 9;
        numbers[4] = 16;

        System.out.println(numbers[0]);
        System.out.println(numbers[1]);
        System.out.println(numbers[2]);
        System.out.println(numbers[3]);
        System.out.println(numbers[4]);

        System.out.println();

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

        int sum = 0;
        for(int index=0; index<numbers.length; index++)
        {
            sum = sum + numbers[index];
        }
        System.out.println("Summe aller Werte im Array ist " + sum);

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

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

        int[] numbers1 = {0, 1, 4, 9, 16};                  // exakt wie Zeilen 22-27
        String[] satz1 = {"Das", "ist", "ein", "Satz"};     // exakt wie Zeilen 49-53
    }

}
27.11. + 01.12.2020 - Algorithmen über Arrays
  • siehe Aufgabe 3
  • siehe Übung 4
  • siehe Arrays
  • diese Woche kein Video - Skript ist eh informativer (meine Meinung). Arbeiten Sie das Skript (Arrays) bitte eingehend durch! Sowohl in dem Abschnitt über Arrays als auch hier gibt es Übungen zum Thema.
04.12. + 08.12.2020 - Sortieren von Arrays
  • siehe Aufgabe 4
  • siehe Übung 5
  • siehe Sortieren von Arrays
  • Bitte keinen Schreck bekommen, wenn Sie sich das Skript zu Sortieren von Arrays anschauen - es ist nämlich recht lang. Aber Sie müssen nur einen Sortieralgorithmus beherrschen. Die allermeisten wählen Bubble-Sort - der scheint am einfachsten zu sein. Ich habe auch extra damit angefangen. Sie müssen also tatsächlich nur einen Sortieralgorithmus wirklich durcharbeiten. Aber ich freue mich natürlich, wenn Sie sich die anderen auch anschauen - habe ja extra das Skript erstellt ;-). Es ist noch nicht ganz fertig - ich hoffe, ich schaffe es über's Wochenende (aber, wie gesagt, ist dann eh nur zur Information).
  • Sowohl in der Aufgabe als auch in der Übung gibt es jeweils einen "Pflichtteil" und einen Zusatzteil. Auch hier genügt es, wenn Sie sich jeweils auf den Pflichtteil konzentrieren.
  • unter dem Abschnitt zu Variablen habe ich einen Unterabschnitt Typkonvertierung hinzugefügt. Der ist größtenteils zur Information. Sie müssen "nur" den Typkonvertierungsoperator kennen.
  • Ich hoffe, dass es dieses Mal nicht zu viel ist (es sieht, wie gesagt, zunächst mehr aus als es ist). Wenn aber doch, dann sagen Sie Bescheid!
  • für die Aufgabe 2 habe ich noch ein Video erstellt und die Lösung hochgeladen
11.12. + 15.12.2020 - Klassen und Objekte (Einführung in die objektorientierte Programmierung)
  • siehe Aufgabe 5 - Triangle
  • siehe Übung 6
  • siehe Klassen und Objekte
  • Wir beginnen ein neues Thema, nämlich "objektorientierte Programmierung". Wir erstellen uns eigene Datentypen. Da gibt es leider am Anfang wieder recht viel Neues. Ich hoffe, ich konnte es halbwegs eingrenzen und das Ausmaß an Neuem ist nicht zu groß. In dem Skript zu Klassen und Objekte sind drei Beispiele eigener Datentypen, aber im zweiten (Point) und dritten (Circle) Beispiel wiederholt sich schon Vieles aus dem ersten (Adresse) . Wenn ich es schaffe, erstelle ich noch ein Video über das erste Beispiel (Adresse) - das wird dann aber "nur" ein Vorprogrammieren des Skriptes. Viel Spaß mit den neuen Sachen!
  • für die Aufgabe 3 habe ich die Lösung hochgeladen
18.12. + 22.12.2020 - Klassen und Objekte II (Konstruktoren, this, Rückgabe von Objekten)
  • siehe Aufgabe 6 - Bruch
  • siehe Übung 7
  • siehe Klassen und Objekte II
  • Wir machen weiter mit eigenen Datentypen und erstellen uns Objekte, die von diesen Typen sind. Wir verwenden eigene Datentypen in neuen Datentypen, definieren mehrere Konstruktoren in der Klasse, erzeugen in Methoden Objekte und geben diese auch zurück und lernen das Schlüsselwort this kennen.
  • für die Aufgabe 4 habe ich die Lösung hochgeladen
08.01. + 12.01.2021 - Vererbung
  • siehe Vererbung
  • Video zu Vererbung
  • Wir lernen ein wichtiges Konzept der objektorientierten Programmierung kennen, nämlich Vererbung. Um von einer Klasse zu erben, verwenden wir das Schlüsselwort extends. Eine Kindklasse erbt von ihrer Elternklasse alle Eigenschaften, also alle Objektvariablen und Objektmethoden. Eine geerbte Methode kann in der Kindklasse überschrieben werden. Wird eine Methode überschrieben, verwenden wir die Annotation @Override. Im Konstruktor der Kindklasse wird der Konstruktor der Elternklasse aufgerufen. Dies kann implizit erfolgen, wenn der implizite Konstruktor der Elternklasse existiert, oder es erfolgt explizit durch die Verwendung des Schlüsselwortes super. Mithilfe von Vererbung erhöhen wir die Wiederverwendbarkeit von Code und vermeiden doppelte Implementierungen. Außerdem sorgen wir für eine bessere Strukturierung des Codes.
  • siehe Übung 8
  • für die Übung 7 habe ich ein Video und die Lösung hochgeladen
  • für die Aufgabe 5 habe ich die Lösung hochgeladen
  • außerdem werden jetzt nach und nach Probeklausuren hochgeladen - eine ist schon da.
15.01. + 19.01.2021 - Object und Polymorphie
  • siehe Object
  • Video zu Object
  • Die Klasse java.lang.Object ist die Basisklasse (Elternklasse) aller in Java existierenden Klassen. Object wird häufig auch als die "Mutter aller Klassen" in Java bezeichnet. Eine Klasse kann entweder explizit von einer anderen Klasse erben (mithilfe von extends) oder sie erbt implizit von der Klasse Object. Das bedeutet, dass jede Klasse von der Klasse Object erbt. Jede Referenzvariable ist somit (auch) vom Laufzeittyp Object. Wir lernen den Unterschied zwischen Compilertyp und Laufzeittyp kennen. Für alle Klassen, die wir in Zukunft schreiben, werden wir die Objektmethoden toString() und equals() (und also auch hashCode()) überschreiben. Wir betrachten außerdem die Objektmethoden getClass() und clone() genauer und lernen ein wichtiges weiteres Konzept der objektorientierten Programmierung kennen, nämlich Polymorphie.
  • siehe Übung 9
  • siehe Aufgabe 8 - Mensch, Studentin, Studiengaenge
  • für die Übung 8 habe ich ein Video und die Lösung hochgeladen
  • für die Aufgabe 6 habe ich die Lösung hochgeladen
  • außerdem sind weitere Probeklausuren (Computer und Uhrzeit - jeweils mit Lösung) hochgeladen.
22.01. + 26.01.2021 - return
  • siehe return
  • siehe Übung 10
  • für die Übung 9 habe ich ein Video und die Lösung hochgeladen
  • für die Aufgabe 7 habe ich die Lösung hochgeladen
  • Überlegen Sie sich gerne Fragen, die wir in den Übungen beantworten und diskutieren können! Wir wiederholen ab jetzt alles, was wir hatten. Sollte Bedarf bestehen, können wir auch noch einen weiteren Wochentermin einschieben. Viel Erfolg bei der Klausurvorbereitung!