Agenda

• Wiederholung
• Klausurbesprechung
• Fortgeschrittene Programmierung

Wiederholung

Datentypen

Primitive Datentypen

• boolean
• byte, short, int, long
• float, double
• char

Komplexe Datentypen

• String
• jede Klasse

Tipp: Primitive Datentypen haben keine Methoden

Methoden

public class Calculator {

  public static int add(int x, int y) {
    return x + y;
  }

}

Operatoren

Arithmetische Operatoren

//...
  public static void main(String[] args) {
    int a = 3;
    int b = 2;
    int addition = a + b; // 5;
    int subtraktion = a - b; // 1;
    int multiplikation = a * b; // 6;
    int division = a / b; // 1, nicht 1.5! Warum?;
    int restwert = a % b; // 1;
  }
//...

Arithmetische Operatoren II

//...
  public static void main(String[] args) {
    int a = 3;
    System.out.println(a++); // Log: 3, Wert: 4
    System.out.println(++a); // Log: 5, Wert: 5
    System.out.println(--a); // Log: 4, Wert: 4
    System.out.println(a--); // Log: 4, Wert: 3
  }
//...

Vergleichsoperatoren

//...
  public static void main(String[] args) {
    boolean result;
    result = 3 == 2; // false 
    result = 3 != 2; // true 
    result = 3 > 2; // true 
    result = 2 >= 2; // true 
    result = 2 < 2; // false 
    result = 2 <= 2; // true 
  }
//...

Logische Operatoren I - AND

//...
  public static void main(String[] args) {
    boolean t = true;
    boolean f = false;
    boolean result;

    result = t && f; // false 
    result = t && t; // true 
    result = f && t; // false 
    result = f && f; // false 
  }
//...

Logische Operatoren II - OR

//...
  public static void main(String[] args) {
    boolean t = true;
    boolean f = false;
    boolean result;

    result = f || t; // true 
    result = t || f; // true 
    result = f || f; // false 
    result = t || t; // true 
  }
//...

Logische Operatoren III - NOT

//...
  public static void main(String[] args) {
    boolean t = true;
    boolean f = false;
    boolean result;

    result = !f; // true 
    result = !t; // false 
  }
//...

Kontrollstrukturen

if

//...
  public static void main(String[] args) {
    int age = 18;

    if(age >= 18) {
      // Ich krieg alles, was ich will
    } else if(age >= 16) {
      // Ich krieg Bier, Wein, Most <3 und Sekt 
    } else  {
      // Ich krieg Coca Zero
    } 
  }
//...

switch

  public static void greet(String gender) {
    switch(gender) {
      case 'm':
      case 'M':
        // falls man ein Mann ist
        break; 
      case 'F':
        // falls man eine Frau ist
        break; 
      default :
        // falls man divers ist
        break; 
    }
  }

while-Schleife

  public static boolean exists(String brand) {
    String[] cars = { 'BMW', 'Audi', 'Benz' }; 
    boolean found = false; 
    int i = 0; 
    while(!found && i < cars.length) {
      String car = cars[i];
      if(car.equals(brand)) {
        found = true;
      } else {
        i++;
      }
    }
    return found; 
  }

do-while-Schleife

  public static boolean exists(String brand) {
    String[] cars = { 'BMW', 'Audi', 'Benz' }; 
    boolean found = false; 
    int i = 0; 
    do {
      String car = cars[i];
      if(car.equals(brand)) {
        found = true;
      } else {
        i++;
      }
    }
    while(!found && i < cars.length)
    return found; 
  }

for-Schleife

  public static boolean exists(String brand) {
    String[] cars = { 'BMW', 'Audi', 'Benz' } 
    for (int i = 0; i < cars.length; i++) {
      String car = cars[i];
      if(car.equals(brand)) {
        return true;
      }
    }
    return false; 
  }

for-each-Schleife

  public static boolean exists(String brand) {
    String[] cars = { 'BMW', 'Audi', 'Benz' } 
    for (String car : cars) {
      if(car.equals(brand)) {
        return true;
      }
    }
    return false; 
  }

break und continue

• break beendet die komplette Schleife
• continue überspringt den restlichen Code

Arrays

Array

  public static void example() {
    String[] cars = { 'BMW', 'Audi', 'Benz' };
    String car;
    car = cars[0]; // lesen aus dem Array
    cars[2] = 'Alfa'; // speichern in ein Array
    String[] twoCars = new String[2]; // Array ohne Inhalt
    int amountOfItems = twoCars.length;
  }

ArrayList

  public static void example() {
    ArrayList<String> cars = new ArrayList<>();
    cars.add('BMW');
    cars.add('Audi');
    cars.add('Benz');
    String car;
    car = cars.get(0); // lesen aus der Liste
    cars.set(2,'Alfa'); // speichern in der Liste
    int amountOfItems = cars.size();
    cars.remove(1); // löschen aus der Liste
  }

Klassen und Objekte

Klassen

• Attribute
• Methoden

Beispiel Klasse

public class Human {
  public String firstName;
  public String lastName;
 
  public String getFullName() {
    return firstName + lastName;
  }
}

Objekte

• konkreter Wert für ein Attribut
• konkretes Verhalten einer Methode

Beispiel Objekt

  Human steffen = new Human();
  steffen.firstName = "Steffen";
  steffen.lastName = "Merk";
  String fullName = steffen.getFullName();

Konstruktor

• beschreibt die Initialisierung eines Objektes
• Konstruktoren können Überladen werden

public class Car {
  private String color;
  private char engineType;

  public Car(String color) {
    this.color = color;
    this.engineType = 'b';
  }

  public Car(String color, char engineType) {
    this.color = color;
    this.engineType = engineType;
  }
}

Konstruktor II

• Konstruktoren können andere Konstruktoren verwenden

public class Car {
  private String color;
  private char engineType;

  public Car(String color) {
    this(color, 'b')
  }

  public Car(String color, char engineType) {
    this.color = color;
    this.engineType = engineType;
  }
}

Vererbung

Vererbung

Durch Generalisierung werden gemeinsame Attribute und Methoden von mehreren Klassen in eine weitere Klasse ausgelagert.

public class Dog {
  public String name;
  public Dog(String name) {
    this.name = name;
  }
  // more Dog specific methods
}
public class Cat {
  public String name;
  public Cat(String name) {
    this.name = name;
  }
  // more Cat specific methods
}

public class Animal {
  public String name;
  public Animal(String name) {
    this.name = name;
  }
}

public class Dog extends Animal {
  public Dog(String name) {
    super(name);
  }
}

public class Cat extends Animal {
  public Cat(String name) {
    super(name);
  }
}

Schlüsselwörter zur Vererbung

• extends
• super

Polymorphie

Polymorphie

Eine Referenzvariable, die vom Typ einer generalisierten Klasse ist, kann mehrere (poly) Formen annehmen (Unterklassen).

Eine Referenzvariable vom Typ Animal kann eine Katze oder ein Hund sein.

Upcast

Der Referenzvariable einer Oberklasse wird eine Referenzvariable einer Unterklasse zugewiesen.

Animal animal01 = new Cat();
Animal animal02 = new Dog();

Ist eine Referenzvariable vom Typ einer generalisierten Klasse, können nur die Methoden der generalisierten Klasse verwendet werden.

Animal animal01 = new Dog();
animal01.name = 'Bello'; // funktioniert
animal01.bark(); // funktioniert nicht 

Downcast

Der Referenzvariable einer Oberklasse wird eine Referenzvariable einer Unterklasse zugewiesen.

Animal animal01 = new Dog();
Dog dog01 = (Dog) animal01;
dog01.bark(); // funktioniert

instanceof operator

Animal animal01 = new Dog();
if (animal01 instanceof Dog) {
   // hundespezifischer Quellcode
   Dog bello = (Dog) animal01;
   bello.bark();
}

Modifier

Public Modifier - Klasse

public class Dog {
  //...
}

Klasse kann überall im Projekt verwendet werden.

Kein Modifier - Klasse

class Dog {
  //...
}

Klasse kann nur im selben Paket verwendet werden.

Abstract Modifier - Klasse

public abstract class Dog {
  //...
}

Ein Objekt dieser Klasse kann nicht instanziiert werden.

Final Modifier - Klasse

public final class Dog {
  //...
}

Von dieser Klasse kann nicht geerbt werden.

Public Modifier - Attribut

public class Dog {
  public String name;
  //...
}

Das Attribut kann immer geändert werden.

Dog bello = new Dog();
bello.name = "Steffen"; // funktioniert

public class MonsterDog extends Dog {
 //...
 public void setName(String name) {
   this.name = name; // funktioniert
 }
 //...
}

Private Modifier - Attribut

public class Dog {
  private String name;
  //...
  public void setName(String name) {
    this.name = name; // funktioniert
  }
}

Das Attribut kann innerhalb der Klasse geändert werden.

Dog bello = new Dog();
bello.name = "Steffen"; // funktioniert nicht

public class MonsterDog extends Dog {
 //...
 public void setName(String name) {
   this.name = name; // funktioniert nicht
 }
 //...
}

Protected Modifier - Attribut

public class Dog {
  protected String name;
  //...
  public void setName(String name) {
    this.name = name; // funktioniert
  }
}

Das Attribut kann innerhalb der Klasse und von allen erbenden Klassen geändert werden.

Dog bello = new Dog();
bello.name = "Steffen"; // funktioniert nicht

public class MonsterDog extends Dog {
 //...
 public void setName(String name) {
   this.name = name; // funktioniert
 }
 //...
}

Final Modifier - Attribut

public class Dog {
  public final String name;
  //...
  public Dog(String name) {
    this.name = name; // funktioniert
  }

  public void setName(String name) {
    this.name = name; // funktioniert nicht
  }
}

Das Attribut kann nur im Konstruktor geändert werden.

Dog bello = new Dog("Marianna");
bello.name = "Steffen"; // funktioniert nicht

public class MonsterDog extends Dog {
 //...
 public void setName(String name) {
   this.name = name; // funktioniert nicht
 }
 //...
}

Static Modifier - Attribut

public class Dog {
  public static boolean hasHat = false;
  //...
}

Das Attribut gehört zu der Klasse und nicht zu einem Objekt.

Dog bello = new Dog();
bello.hasHat = true; // funktioniert nicht
Dog.hasHat = true; // funktioniert

public class MonsterDog extends Dog {
 //...
 public void setHat(boolean hasHat) {
   this.hasHat = hasHat; // funktioniert nicht
   Dog.hasHat = hasHat; // funktioniert
 }
 //...
}

Public Modifier - Methode

public class Dog {
  public void bark() {
    //...
  }
  //...
}

Die Methode kann immer verwendet werden.

Dog bello = new Dog();
bello.bark(); // funktioniert

public class MonsterDog extends Dog {
 //...
 public void attack() {
   this.bark(); // funktioniert
 }
 //...
}

Private Modifier - Methode

public class Dog {
  private void bark() {
    //...
  }
  //...
}

Die Methode kann innerhalb der Klasse verwendet werden.

Dog bello = new Dog();
bello.bark(); // funktioniert nicht

public class MonsterDog extends Dog {
 //...
 public void attack() {
   this.bark(); // funktioniert nicht
 }
 //...
}

Protected Modifier - Methode

public class Dog {
  protected void bark() {
    //...
  }
  //...
}

Das Attribut kann innerhalb der Klasse und von allen erbenden Klassen verwendet werden.

Dog bello = new Dog();
bello.bark(); // funktioniert nicht

public class MonsterDog extends Dog {
 //...
 public void attack() {
   this.bark(); // funktioniert
 }
 //...
}

Final Modifier - Methode

public class Dog {
  public final void bark() {
    //...
  }
  //...
}

Die Methode kann nicht überschrieben werden.

public class MonsterDog extends Dog {
 //...
 public void bark() { // funktioniert nicht 
   //...
 }
 //...
}

Static Modifier - Methode

public class Dog {
  public static hasHat = true;
  public static isCool = true;
  public static boolean isCoolAndHasHat() {
    return Dog.isCool && Dog.hasHat;
  }
  //...
}

Die Methode gehört zu der Klasse und nicht zu einem Objekt. Es kann nur auf statische Attribute zugegriffen werden.

Dog bello = new Dog();
bello.isCoolAndHasHat(); // funktioniert nicht
Dog.isCoolAndHasHat(); // funktioniert

public class MonsterDog extends Dog {
 //...
 public void attack() {
   this.isCoolAndHasHat(); // funktioniert nicht
   Dog.isCoolAndHasHat(); // funktioniert
 }
 //...
}

Abstract Modifier - Methode

public abstract class Animal {
  //...
  public abstract void makeSound();
}

Die Methode muss von der erbenden Klasse implementiert werden. Abstrakte Methoden können nur in abstrakten Klassen definiert werden.

public class MonsterDog extends Dog {
 // funktioniert nicht, makeSound muss implementiert werden
}

Enumeration

Enumeration

Eine Enumeration ist eine Klasse mit Attributen und Methoden. Sie definiert zusätzlich alle möglichen Ausprägungen dieser Klasse.

Enumeration implementieren

public enum Gender {
 MALE("Mann"),
 FEMALE("Frau"),
 DIVERS("Divers");
 
 public final String text;
 
 Gender(String text) {
   this.text = text;
 }
 
 public boolean isBinary() {
   return this == Gender.MALE || this == Gender.FEMALE;
 }
}

Enumeration als Typ verwenden

public class Human {
 public final Gender gender;
 
 public Human(Gender gender) {
   this.gender = gender;
 }
 public doSomethingBinaryRelated() {
   if(this.gender.isBinary())
   //...
 }
}

Enumeration als Wert setzen

Human steffen = new Human(Gender.MALE);

Interfaces

Interfaces

Definieren Methoden unabhängig von der Vererbungshierarchie.

Dient als Schnittstelle zwischen Ersteller und Verwender einer Funktionalität.

Interface (Ersteller)

public interface Item {
  public String getName(); 
}

public class ShoppingList {
  ArrayList<Item> items = new ArrayList<>();
  public void add(Item item) {
    this.items.add(item);
  }
  public void print() {
    for(Item item : items) {
      System.out.println(item.getName();
    }
  }
}

Interface (Verwender) I

public class Human implements Item {
  public final String firstName;
  public final String lastName;
  
  public Human(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  
  public String getName() {
    return firstName + " " + lastName;
  }
}

Interface (Verwender) II

ShoppingList shoppingList = new ShoppingList();
Human steffen = new Human("Steffen", "Merk");
shoppingList.add(steffen);
shoppingList.print(); // "Steffen Merk"

Comparator

Comparator

Definiert wie eine Liste von Elementen sortiert wird.

Vergleicht immer zwei Elemente miteinander, bei dem angegeben wird, wo das erste Element im Vergleich zum zweiten Element positioniert wird (Zahlenstrahl).

Comparator implementieren

public class AgeAscComparator implements Comparator<Human> {
  
  public int compare(Human h1, Human h2) {
    if(h1.getAge() > h2.getAge()) {
     return 1;
    } else if (h1.getAge() < h2.getAge()) {
      return -1;
    } else {
      return 0;
    } 
  }
}

Comparator verwenden

ArrayList<Human> developers = new ArrayList<>();
developers.add(new Human(28));
developers.add(new Human(24));
Collections.sort(developers, new AgeAscComparator());

Exceptions

Exceptions

Sind Fehler, die während der Ausführung des Programms auftreten können und dienen zur Kommunikation.

Fehler können mitgeteilt (throws) und verarbeitet werden (catch).

Exception implementieren

public class TooYoungException extends Exception {
  
  public final int yearsTillAllowed;
  
  public TooYoungException(int yearsTillAllowed) {
    super();
    this.yearsTillAllowed = yearsTillAllowed;
  }
}

Exception auslösen

public class ShoppingList {
  Human buyer;
  //...
  public addItem(Item item) throws TooYoungException {
    if(item.isAlcohol() && this.buyer.getAge() < 21) {
      throw new TooYoungException(21 - buyer.getAge());
    }
  }
}

Exception behandeln

public class Main {
  public static void main(String[] args) {
    ShoppingList sl = new ShoppingList();
    Beer corona = new Beer();
    try {
      sl.add(corona);
    } catch (TooYoungException e) {
      System.out.println("Du bist" + e.yearsTillAllowed + "zu jung");
    } finally {
      System.out.println("Einkauf beendet. (Immer)");
    }
  }
}

Klassendiagramme (Doku)

Klausurbesprechung

Organisatorsiches

Fortgeschrittene Programmierung

• Algorithmen und Datenstrukturen
• Generische Programmierung
• Funktionale Programmierung

Prüfungsleistungen

• Projektbericht (50 Punkte)
• Klausur am PC (50 Punkte)

Projektbericht - Termine

• 30.04.2024 - Problem und Daten in Moodle
• 30.05.2025 - Abgabe Projektbericht (Moodle/Papier)

Projektbericht - Problem

• findet ein Problem (im Unternehmen)
• (er)findet dazu Daten
• mindestens eine Verknüpfung
• keine doppelten Themen (Selbstorganisiert)

Projektbericht - Ergebnis am 30.04

• Problembeschreibung (Textdatei)
• Tabelle mit mindestens 20 Datensätzen (CSV-Datei)
• Hochladen in Moodle

Projektbericht - Ergebnis am 31.05

• Erklärung am 30.04

Klausur am PC

• Ablauf wie Test/Klausur
• VSCode anstatt Notepad++
• Keine Fragenbeschreibung in Moodle

Rest of the day

• Wiederholung
• Entwicklungsumgebung einrichten