12th Java Lesson (Java Course @ TUD)

https://github.com/Trivo25/tud-java-course

January 20, 2022

Während Ihr darauf wartet, dass es beginnt..

Java

Objektorientierte Programmierung

Florian Kluge, Moritz Schulz

  1. January 2022

https://trivo25.github.io/tud-java-course/


Florian.Kluge@mailbox.tu-dresden.de

Moritz.Schulz2@mailbox.tu-dresden.de

Was wir heute machen

Objekte; Aus dem Standard Library

  • Zeit zur Besprechung der letzten Aufgabe
  • Beispiellösung zur letzten Aufgabe zeigen
  • Objektvariablen speichern Referenzen
  • aus Standard Library: HashMap
  • weitere praktische packages aus der Standard Library

Contact

Florian Kluge

Florian.Kluge@mailbox.tu-dresden.de

Moritz Schulz

Moritz.Schulz2@mailbox.tu-dresden.de

Kurze Info zum Kurs: online

  • bitte abmelden / entschuldigen, wenn ihr nicht kommt
    • zwei Mal in Folge unentschuldigt fehlen => ausgetragen
  • bitte, fragt gern, jederzeit
    • entweder Frage im Chat stellen
    • oder sich mit Handzeichen melden => nach dem Drannehmen per Mikro die Frage stellen
  • praktische Aufgaben- und Beispiel-basierte Lernweise
    • wenn ihr nicht weiterkommt / sich etwas komisch verhält:
      • “?” in den Chat schreiben
      • wir gehen mit dir in einen Breakout-Raum
      • du kannst dann den Bildschirm teilen
      • traut euch :)
  • uns geht es darum, alle mitzunehmen

Stay up to date

  • die E-Mails der TUD regelmäßig überprüfen
    • z.B. Bekanntgabe der Veröffentlichung der Folien
      • auf der Seite des Programmierkurses

Wird Präsenz mehrheitlich gewünscht?

Los geht’s!

noch zu Objekten…

  • in Java gibt es zwei Arten von Datentypen
    • einfache/primitive Datentypen
      • int, float, boolean
    • komplexe Datentypen
      • Objekte

primitive Datentypen

  • werden per Wert übergeben
  • Was gibt das Programm aus?
void verdopple(float s) {
    System.out.println("Verdoppeln von " + s);
    s = 2 * s;
    System.out.println("Neuer Wert von s: " + s);
}

public static void main(String[] args) {
    float l = 99f;
    verdopple(l);
    System.out.println("l hat den Wert " + l);
}

primitive Datentypen

  • Die Programmausgaben sind:
Verdoppeln von 99.0f
Neuer Wert von s: 198.0f
l hat den Wert 99.0f

komplexe Datentypen: Objekte

  • sind eigentlich “Zeiger” = Referenzen
  • werden per Referenz übergeben
class Entity {
    String name;
    public Entity(String name) {
        this.name = name;
    }
}

void benenneUm(Entity e) {
    System.out.println("Umbennenen von " + e.name);
    e.name = "Zaphod Beeblebrox";
    System.out.println("Neuer Name: " + e.name);
}

public static void main(String[] args) {
    Entity arthur = new Entity("Arthur Dent")
    benenneUm(e);
    System.out.println("e heißt nun " + e.name);
}

komplexe Datentypen: Objekte

  • Die Programmausgaben sind:
Umbenennen von Arthur Dent
Neuer Name: Zaphod Beeblebrox
e heißt nun Zaphod Beeblebrox

Was bedeutet das?

  1. Funktionen können Objekte verändern (“mutieren”)
    • häufige Fehlerquelle
  2. Objekte sollten wir nicht “einfach so” vergleichen
    • objA == objB vergleicht nur, ob sie das selbe Objekt sind, also ob der Zeiger gleich ist
    • objA.equals(objB) soll die Werte vergleichen (Gleichheitsrelation)
      • müssen wir selbst implementieren, sonst ist das das gleiche wie objA == objB
      • @Override public boolean equals(Object o) { /* ... */ }
      • instanceof verwenden
    • public int hashcode() sollte auch überschrieben werden

Objekte können auch nicht vorhanden sein

  • Objekt-Variablen starten mit dem Wert null
  • ähnlich wie der Null-Pointer in C: NULL
  • praktisch, wenn
    • Werte optional sind
    • ein “nicht-vorhanden” dargestellt werden soll
//...
Animal loewe; // loewe == null

Kleine Aufgabe (10min)

  1. Schreibe ein Java-Programm mit einer kleinen Klasse
    • 1 Attribut (“Variable”)
    • Konstruktor
  2. Erstelle davon zwei gleichartige Objekte
  3. Vergleiche diese korrekt
    • equals, instanceof, type casts
    • hashCode lassen wir weg
  4. Gib entsprechende Konsolenausgabe!
  5. Teste, indem du ein Objekt abänderst => dass sie ungleich sind, soll erkannt werden

java.util Package

HashMap<K, V>

Was ist eine (Hash)Map?

  • eine Map weist jeweils einem Key einen Wert zu
  • eine Map “mapped” Keys zu Werten
  • also: der Schlüssel zeigt auf einen Wert
  • ähnlich wie eine Funktion / Abbildung
    • ArrayList<T> sind gewissermaßen Funktionen Integer (index) -> T (Wert)
    • Maps erlauben uns aber komplexere Datentypen als Schlüssel zu nutzen

Was ist eine (Hash)Map?

  • Beispiel: HashMap<String, Integer>
    • Name -> Alter
    • Also: “Florian” -> 22
  • Oder: HashMap<String, Person>
    • Name -> Person (eigene Klasse)

HashMap<K, V>

// wir müssen die HashMap wieder importieren
import java.util.HashMap;
// wir mappen Land -> Stadt
HashMap<String, String> hauptstaedte = new HashMap<String, String>();

HashMap<K, V>

// wir müssen die HashMap wieder importieren
import java.util.HashMap;
// wir mappen Land -> Stadt
HashMap<String, String> hauptstaedte = new HashMap<String, String>();

// wir fügen Schlüssen und Werte hinzu
hauptstaedte.put("England", "London");
hauptstaedte.put("Deutschland", "Berlin");

Methoden von HashMap<K, V>

// .put(k, v) fügt Schlüssel k und Wert v hinzu
hauptstaedte.put("Deutschland", "Berlin");
    
// .get(k) holt den Wert welcher zum Schlüssel k gehört
// wenn Schlüssel nicht vorhanden: null
hauptstaedte.get("Deutschland"); // holt "Berlin"

// .remove(k) löscht den Schlüssel k
hauptstaedte.remove("Deutschland");
// löscht Schlüssel "Deutschland" und dessen Wert "Berlin" aus der Map

// .size() gibt die Länge der Map zurück
hauptstaedte.size();
    
// .keySet() gibt eine List aller Schlüssel zurück
hauptstaedte.keySet();

// .values() gibt eine Liste aller Werte zurück
hauptstaedte.values();

Schleifen - HashMap<K, V>

// durch alle Schlüssel der Map durchgehen
for (String i : hauptstaedte.keySet()) {
    System.out.println(i); // gibt aus "Deutschland", "England" ..
}
   
// durch alle Werte der Map durchgehen
for (String i : hauptstaedte.values()) {
    System.out.println(i); // gibt aus "Berlin", "London" ..
}

Aufgabe HashMap<K, V>

  • schreibt eine einfache Klasse BankKonto
    • Methoden:
      • void pay(amount: int) - gibt "paying" + amount in der Konsole aus
      • void deposit(amount: int) - gibt "depositing" + amount in der Konsole aus
  • erstellt ebenfalls eine HashMap vom Typ HashMap<String, BankKonto>
  • in der Ihr einer Kontonummer (eg DE12345678) ein Konto zuweist
  • fügt 5 Kontonummern-Bankkonten-Paare der Map hinzu
    • erstellt dazu 5 Bankkonto-Objekte
    • map.put("DE123", kontoObjekt);
    • kann auch mit for-Loop geschehen

Nützliches aus der Standard-Library

  • java.lang.Math
    • The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
  • java.util.Random
    • An instance of this class is used to generate a stream of pseudorandom numbers. The class uses a 48-bit seed, which is modified using a linear congruential formula.
  • java.time.LocalDate
    • LocalDate is an immutable date-time object that represents a date, often viewed as year-month-day. Other date fields, such as day-of-year, day-of-week and week-of-year, can also be accessed. For example, the value “2nd October 2007” can be stored in a LocalDate.

java.lang.Math

java.lang.Math

  • um java.lang.Math nutzen zu können, muss das Package erst importiert werden
    • import java.lang.Math; (ganz Oben in der Datei!)

java.lang.Math

import java.lang.Math;

public class MathExample {
  public static void main(String[] args) {

    final double PI = Math.PI;

    System.out.println(Math.sin(PI)); // quasi 0
    System.out.println(Math.cos(PI)); // -1.0
    System.out.println(Math.tan(PI)); // quasi 0

    System.out.println(Math.exp(1.0d)); // e^x = e^1 = 2.71828...

    System.out.println(Math.sqrt(9.0d)); // sqrt(9) = 3;

  }
}

java.util.Random

java.util.Random

  • um java.util.Random nutzen zu können, muss das Package erst importiert werden
    • import java.util.Random; (ganz Oben in der Datei!)

java.util.Random


import java.util.Random;

public class RandomExample {
  public static void main(String[] args) {

    Random randomGenerator = new Random();

    int max = 100;
     // gibt einmalig eine zufälligen int zurück
    int result = randomGenerator.nextInt(max);
    System.out.println(result);

    // gibt einen "stream" an random integer zurück, endlos
    // der (var) -> { /* do something */} Syntax nennt sich Lambda-Funktion
    randomGenerator.ints().forEach((randomInteger) -> { 
      System.out.println(randomInteger);
    });
  }
}

java.Time.LocalDate

java.Time.LocalDate


import java.time.LocalDate;

public class DateExample {
  public static void main(String[] args) {
    LocalDate today = LocalDate.now();
    System.out.println(today);

    try {
      LocalDate notALeapYear = today.of(2021, 02, 29);
      System.out.println(notALeapYear);
    } catch (Exception e) {
      System.out.println("Not a leap year");
    }

    LocalDate leapYear = today.of(2020, 02, 29);
    System.out.println(leapYear);

    LocalDate yesterday = today.minusDays(1);

    System.out.println(yesterday.isBefore(today));
    System.out.println(today.isAfter(yesterday));

    LocalDate parsedDate = LocalDate.parse("2022-01-20");
    System.out.println(parsedDate);

  }
}

Kurze Anmerkung

  • wir haben heute mit Generics gearbeitet, aber diese nicht genauer betrachtet

Wie weiter?

  • Präsenz oder online?
  • Projektideen
    • REST-API
    • Quiz-Anwendung

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

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

Quellen

Inspiration für Probleme: