7th Java Lesson

7. Dezember 2022

Thanks to Moritz Schulz, Florian Kluge for the Slides

Was wir heute machen

Objektorientierte Programmierung: Vererbung

  1. static
  2. Vererbung
  3. Visualisierung von Klassen (UML)

Los geht’s!

Bankkonto - mittel - Teil 1
  • schreibt eine Klasse Bankkonto welches folgende Attribute hat
    • String: kontoInhaber - Name Kontoinhaber*in
    • float: maxiUeberzug - Maximum welcher Betrag das Konto überzogen werden kann(‘im Minus’)
    • String: iban - IBAN/Kontoaddresse
    • int: anzahlTransaktionen
    • float: guthaben - Guthaben
Bankkonto - mittel - Teil 2
  • erweitert die Klasse Bankkonto um folgende Methoden (Parameter ausgelassen):
    • boolean: sendMoney() - schickt einen Betrag an ein anderes Konto und passt das Guthaben an, gibt false oder true zurück wenn es erfolgreich war oder nicht
    • void: payIn() - zahlt Geld in das Konto ein
    • boolean: withdraw() - hebt Geld von dem Konto ab, gibt false oder true zurück wenn es erfolgreich war oder nicht

Das Keyword static

Wenn Funktionen und Variablen

zu keinem bestimmen Objekt gehören,

sondern zur Klasse

Was heißt eigentlich static?

  • z.B. in der Funktion public static void main(String[] args)
  • Alles, was static ist, gehört zu einer Klasse und zu keinem bestimmten Objekt
  • Beispiel:
    • Funktionen sind static, Methoden sind nicht static

⇒ um auf static Funktionen zuzugreifen braucht man kein Objekt

Wofür ist static gut?

  • wir können beispielsweise Funktionen in einer Klasse gruppieren
  • (static) Funktionen lassen sich ohne Objekt aufrufen
  • (static) Funktionen haben aber keinen Zugriff auf Attribute vom Objekt der Klasse
    • denn es ist ihr kein Objekt bekannt
  • Gegensatz: Methoden (ohne static) gehören immer zu einem Objekt einer Klasse!
    • können nur aufgerufen werden, wenn eine Instanz der Klasse (ein Objekt) vorliegt

Beispiel für static

public class Programm {
    public static void main(String[] args) {
        Quadrat luca = new Quadrat(10.0f);
        float flaeche = luca.flaeche();
        float flaeche2 = Quadrat.berechneFlaeche(5.0f);
    }
}

class Quadrat {
    public float seitenlaenge;
    
    public Quadrat(float a){
        seitenlaenge = a;
    }

    public float flaeche() {
        return berechneFlaeche(seitenlaenge);    
    }
    
    public static float berechneFlaeche(float f) {
        // kennt seitenlaenge nicht!
        return f * f;    
    }
}

Anwendung von Funktionen

Funktionen (mit static) kennen also nur - ihre Parameter - übergeordnete static Variablen

Das heißt, sie brauchen kein zusätzliches Wissen.

Anwendung: - so haben wir zu Beginn Funktionalität ausgelagert - z.B. sqrt (Quadratwurzel) braucht nichts außer der Zahl zu wissen

import java.lang.Math;

class Programm {
    public static void main(String args[]) {
        System.out.println(Math.sqrt(30.0));
    }
}

auch Variablen einer Klasse können static sein

public class Apokalypse {
    public static void main(String[] args) {
        Zombie zombie1 = new Zombie();
        Zombie zombie2 = new Zombie();
        Zombie zombie3 = new Zombie();
        Zombie zombie4 = new Zombie();
        Zombie zombie5 = new Zombie();
        
        System.out.println("Es gibt " + Zombie.anzahl + " Zombies!");
    }
}

class Zombie {
    public static int anzahl = 0;
    
    public Zombie(){
        anzahl++;
    }

    public void laufe() {
        System.out.println("*hink*");
    }
}

Vererbung

  • es gibt Objekte, die einander ähnlich sind
  • Beispiele:
    • Auto, LKW, Bus -> alles Fahrzeuge
    • Kuh, Schaf, Schwein -> alles Tiere
    • Rechteck, Kreis, Dreieck -> alles geometrische Formen

Vererbung

  • sie haben Gemeinsamkeiten
  • diese Gemeinsamkeiten können wir bestimmen auf:
    • gemeinsame Eigenschaften (Attribute)
    • gemeinsames Verhalten (Methoden)

Vererbung

  • wir können eine Klasse bilden, die nur diese Gemeinsamkeiten enthält
    • sie nennen wir superclass (übergeordnete Klasse)
  • aus dieser Klasse können wir subclasses (untergeordnete Klassen) ableiten
    • sie übernehmen alle Attribute und Methoden der superclass
      • dieses “Übernehmen” heißt Vererbung
  • Beispiel: (“->” heißt: “erben von”), alles sind Klassen
    • subclasses Auto, LKW, Bus -> superclass Kraftfahrzeug
    • subclasses Kuh, Schaf, Schwein -> superclass Tier

Vererbung - Beispiel

  • PKW, Bus, LKW -> Fahrzeug
    • ein PKW erbt alle Attribute und Methoden der Klasse Fahrzeug

… aber wie sieht das in Java aus?

Vererbung - Beispiel

  • Klasse Fahrzeug, so wie wir es bis jetzt immer gemacht haben
class Fahrzeug {
    public int raeder;
    public int sitzplaetze;
    // ..
    public void starteMotor() {
        System.out.println("Motor läuft!")
    }
}

Vererbung - Beispiel

  • Klasse Bus - ist ein Fahrzeug, hat aber besondere Eigenschaften
    • Vererbung mit extends signalisiert
class Bus extends Fahrzeug {
    /*
    Hier sind jetzt alle Methoden und Attribut 
    aus der Klasse Fahrzeug verfügbar!
    */
    
    // unsere "besondere" Methode welche nur ein Bus hat
    public void verkaufeTicket() {}
}

Vererbung - Beispiel

  • Bus hat nun automatisch alle Methoden und Attribute von der Klasse Fahrzeuge
  • zusätzlich gibt es für jedes Objekt der Klasse Bus
    • alle “besonderen” Methoden/Attribute
      • wie beispielsweise void sellTicket()

Bus b1 = new Bus();
// Attribute und Methoden aus Klasse Fahrzeug
b1.raeder = 4;
b1.sitzplaetze = 40;
b1.starteMotor();

// Methode aus Klasse Bus
b1.verkaufeTicket();

Visualisierung

  • Vererbung von Klassen lässt sich visuell darstellen
    • meist mit einem UML (Unified Modeling Language) Diagramm
    • wichtig für die weiterführenden Semester!
  • UML Diagramme stellen visuell den Zusammenhang von Klassen, Paketen, … dar

UML - Beispiel Fahrzeug/Bus

Bus erbt von Fahrzeug

UML - Beispiel Fahrzeug/Bus

  • wir können ebenfalls Methoden und Attribute im Diagramm darstellen
class Fahrzeug {
    public int raeder;
    public int sitzplaetze;
    // ..
    public void starteMotor() {
        System.out.println("Motor läuft!")
    }
}

UML - Beispiel Fahrzeug/Bus

  • Attribute (Variablen) im Format:
    • -variableName: Datentyp
  • Methoden im Format:
    • +methodenName(Parameter): Datentyp

UML - Beispiel Fahrzeug/Bus

  • Vollständiges Klassendiagramm von Fahrzeug <- Bus

Vererbung - Bemerkungen und Zusammenfassung

  • Klassen können von anderen erben
    • dafür nutzen wir das extends Keyword
  • Klassen können somit Attribute und Methoden einer Oberklasse erben
    • dann übernehmen Objekte einer Klasse auch Attribute und Methoden der Oberklasse(n)
  • Wann macht das Sinn? Wenn die Oberklasse viele Merkmale mehrere Unterklassen verbindet
    • Beispiel:
      • Hund, Katze, Vogel -> alles Tiere
      • PKW, LKW, Bus -> alles Fahrzeuge
      • …
  • mehrere Klassen können von einer Oberklasse mit Unterklasse extends Oberklasse erben
    • wir können aber nur von einer Oberklasse erben!

Vererbung - Bemerkungen und Zusammenfassung

  • Vererbung kann sich theoretisch unendlich lang weiterziehen..
    • Beispiel:
      • Oberklasse: Tier
      • Wolf erbt von Tier
      • Hund erbt von Wolf
      • Haushund erbt von Hund
      • Schäferhund erbt von Haushund
      • ….
  • Klassen können mehrere Oberklassen haben
    • jede Klasse hat automatisch die Oberklasse Object
      • später mehr zu den Eigenschaften, die das mit sich bringt
    • Beispiel:
      • Kugel erbt von 3DKörper, RollendesObjekt, Object

Vererbung - Bemerkungen und Zusammenfassung

  • Was ist der Sinn hinter (mehrfach) Vererbungen?
    • Oberklassen sind allgemein / generalisiert
    • Unterklassen werden immer spezialisierter
  • Oberklassen beschreiben grobe Zusammenhänge
    • und Unterklassen spezialisieren diese

mit mehreren Dateien arbeiten

  • denn eine Klasse pro Datei ist üblich

Vererbung und UML - Aufgabe

  • folgendes UML-Diagramm beschreibt folgenden Zusammenhang:
    • Oberklasse: Person
      • eine Person hat verschiedene Attribute und Methoden
    • Unterklasse 1: Student erbt von Person
      • ein Student hat spezialisierte Methoden und Attribute
    • Unterklasse 2: Dozent erbt von Person
      • ein Dozent hat wiederum ebenfalls spezialisierte Methoden und Attribute

Vererbung und UML - Aufgabe

  • Entwickle die Klassen und definiere die entsprechenden Attribute, Methoden und Konstruktoren.
  • Die Methoden geben jeweils Text aus, der sie beschreibt
  • Die Funktion tellStory() in der Klasse Programm soll den Tagesverlauf eines Studenten beschreiben
    • dazu soll sie entsprechende Objekte verwenden

Vererbung und UML - Aufgabe

Nächste Stunde

  • meeeehr OOP

Tipp: Advent of Code

https://adventofcode.com/2021

See course materials here: https://trivo25.github.io/tud-java-course/

Check out the Cheat Sheet: http://tiny.cc/java-cs