Während Ihr darauf wartet, dass es beginnt..
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
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?
- Das würde verpflichtende nachzuweisende Schnelltests bedeuten
- Antigen-Schnelltest mit Gültigkeitsdauer 24h
- zur Option hybrid:
- Wir könnten unsere Redeanteile streamen
- Können uns aber nur denen in Person widmen
noch zu Objekten…
- in Java gibt es zwei Arten von Datentypen
- einfache/primitive Datentypen
- komplexe Datentypen
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?
- Funktionen können Objekte verändern (“mutieren”)
- 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)
- Schreibe ein Java-Programm mit einer kleinen Klasse
- 1 Attribut (“Variable”)
- Konstruktor
- Erstelle davon zwei gleichartige Objekte
- Vergleiche diese korrekt
equals
, instanceof
, type casts
hashCode
lassen wir weg
- Gib entsprechende Konsolenausgabe!
- 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
- 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
- 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
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
Quellen
Inspiration für Probleme: