Klassen und Objekte
Jetzt setzen wir den Entwurf aus dem letzten Kapitel um: einen Kunden und ein
Konto, das Geld annehmen und auszahlen kann.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- eine Klasse mit Feldern, Konstruktoren und Methoden schreiben
- Objekte mit
newerzeugen und ihre Methoden aufrufen thisverwenden- erklären, was
staticbedeutet – und was der Unterschied zu einer Instanzmethode ist
Startprojekt 15-bank
⤓ bank-start.zip herunterladenIn Eclipse: File → Import… → General → Existing Projects into Workspace →Select archive file → die ZIP-Datei wählen → Finish. Das Projekt15-bank erscheint mit allen Dateien im Workspace.
Enthält: Betrag.java, BetragTest.java
Wer das Projekt lieber selbst anlegt: Projekt 15-bank mit dem Package
de.drv.bank – wie in
Arbeiten mit Eclipse
beschrieben – und die beiden Dateien aus dem nächsten Abschnitt hineinkopieren.
Vorgegeben: der Betrag
Abschnitt betitelt „Vorgegeben: der Betrag“Für Geld gibt es eine fertige Klasse – denn mit double wird Geld nie exakt
(siehe Variablen). Lege
die Klasse Betrag im Package de.drv.bank an und kopiere den Inhalt hinein:
package de.drv.bank;
import java.util.Locale;
/** * Ein Geldbetrag in Euro, intern exakt in Cent gespeichert. * * Ein Betrag ist unveränderlich: Rechenmethoden liefern immer einen neuen Betrag. * * @param cent der Betrag in Cent – 1,00 € sind 100 Cent, {@code new Betrag(500)} sind 5,00 € */public record Betrag(long cent) {
/** Der Betrag 0,00 € – also 0 Cent. */ public static final Betrag NULL = new Betrag(0);
/** Ein Betrag in ganzen Euro, z. B. {@code Betrag.euro(250)}. */ public static Betrag euro(long euro) { return new Betrag(euro * 100); }
/** Ein Betrag aus Euro und Cent, z. B. {@code Betrag.euro(19, 99)}. */ public static Betrag euro(long euro, int cent) { if (cent < 0 || cent > 99) { throw new IllegalArgumentException("Cent muss zwischen 0 und 99 liegen: " + cent); } return new Betrag(euro * 100 + (euro < 0 ? -cent : cent)); }
/** Summe dieses und des anderen Betrags. */ public Betrag plus(Betrag anderer) { return new Betrag(cent + anderer.cent); }
/** Differenz dieses und des anderen Betrags. */ public Betrag minus(Betrag anderer) { return new Betrag(cent - anderer.cent); }
/** {@code true}, wenn der Betrag kleiner als 0 ist. */ public boolean istNegativ() { return cent < 0; }
/** {@code true}, wenn dieser Betrag größer als der andere ist. */ public boolean istGroesserAls(Betrag anderer) { return cent > anderer.cent; }
/** {@code true}, wenn dieser Betrag kleiner als der andere ist. */ public boolean istKleinerAls(Betrag anderer) { return cent < anderer.cent; }
/** Deutsche Schreibweise, z. B. {@code 1.234,56 €}. */ @Override public String toString() { long betrag = Math.abs(cent); return String.format(Locale.GERMANY, "%s%,d,%02d €", cent < 0 ? "-" : "", betrag / 100, betrag % 100); }
}Wie diese Klasse gebaut ist, sehen wir uns im Kapitel über Records an. Bis
dahin benutzen wir sie einfach – so wie LocalDate:
| Aufruf | Ergebnis |
|---|---|
Betrag.euro(250) |
250,00 € |
Betrag.euro(19, 99) |
19,99 € |
Betrag.NULL |
0,00 € |
a.plus(b), a.minus(b) |
ein neuer Betrag – wie bei String und LocalDate |
a.istGroesserAls(b), a.istKleinerAls(b), a.istNegativ() |
Vergleiche |
System.out.println(a) |
deutsche Schreibweise, z. B. 1.234,56 € |
Die erste eigene Klasse: Kunde
Abschnitt betitelt „Die erste eigene Klasse: Kunde“package de.drv.bank;
import java.time.LocalDate;
public class Kunde {
String name; LocalDate geburtsdatum;
Kunde(String name, LocalDate geburtsdatum) { this.name = name; this.geburtsdatum = geburtsdatum; }
}name und geburtsdatum stehen in der Klasse, aber außerhalb jeder Methode.
Das sind die Felder: Jedes Kunde-Objekt hat seinen eigenen Namen und sein
eigenes Geburtsdatum. Anders als lokale Variablen bekommen Felder automatisch
einen Standardwert – null, 0 oder false –, bis ihnen etwas zugewiesen wird.
Der Konstruktor
Abschnitt betitelt „Der Konstruktor“Kunde(String name, LocalDate geburtsdatum) { … } sieht aus wie eine Methode,
hat aber keinen Rückgabetyp und heißt genau wie die Klasse. Das ist der
Konstruktor: Er läuft, wenn mit new ein Objekt erzeugt wird, und bringt es
in einen sinnvollen Anfangszustand.
Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));Im Konstruktor heißen Parameter und Felder gleich. name allein meint dort den
Parameter. Mit this.name ist das Feld des Objekts gemeint, das
gerade erzeugt wird. this heißt: „dieses Objekt hier“.
Das Konto
Abschnitt betitelt „Das Konto“package de.drv.bank;
public class Konto {
static int anzahlKonten = 0;
int kontonummer; Kunde inhaber; Betrag kontostand;
Konto(Kunde inhaber) { anzahlKonten++; this.kontonummer = 1000 + anzahlKonten; this.inhaber = inhaber; this.kontostand = Betrag.NULL; }
Konto(Kunde inhaber, Betrag startguthaben) { this(inhaber); einzahlen(startguthaben); }
void einzahlen(Betrag betrag) { kontostand = kontostand.plus(betrag); }
boolean abheben(Betrag betrag) { if (betrag.istGroesserAls(kontostand)) { return false; } kontostand = kontostand.minus(betrag); return true; }
String beschreibung() { return "Konto " + kontonummer + " (" + inhaber.name + "): " + kontostand; }
}Zwei Konstruktoren
Abschnitt betitelt „Zwei Konstruktoren“Ein Konto lässt sich auf zwei Arten eröffnen: leer oder mit Startguthaben. Wie
Methoden lassen sich auch Konstruktoren überladen. Der zweite ruft mit
this(inhaber) den ersten auf – so steht die eigentliche Arbeit nur an
einer Stelle. Dieser Aufruf muss die erste Anweisung im Konstruktor sein.
Methoden ohne static
Abschnitt betitelt „Methoden ohne static“einzahlen, abheben und beschreibung tragen kein static. Sie gehören
zu einem Objekt und arbeiten mit dessen Feldern: kontostand meint dort den
Kontostand des Kontos, auf dem die Methode aufgerufen wurde.
Das Feld inhaber ist selbst ein Objekt – ein Kunde. Mit inhaber.name
kommt das Konto an den Namen seines Inhabers: die Beziehung aus der Skizze im
letzten Kapitel.
Objekte benutzen
Abschnitt betitelt „Objekte benutzen“package de.drv.bank;
import java.time.LocalDate;
public class Bankdemo {
public static void main(String[] args) { Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12)); Kunde ben = new Kunde("Ben Beispiel", LocalDate.of(1999, 11, 2));
Konto annasKonto = new Konto(anna); Konto bensKonto = new Konto(ben, Betrag.euro(100));
annasKonto.einzahlen(Betrag.euro(250)); boolean geklappt = annasKonto.abheben(Betrag.euro(19, 99)); System.out.println("Abheben geklappt: " + geklappt);
boolean zuViel = bensKonto.abheben(Betrag.euro(500)); System.out.println("500 € abheben geklappt: " + zuViel);
System.out.println(annasKonto.beschreibung()); System.out.println(bensKonto.beschreibung()); System.out.println("Konten insgesamt: " + Konto.anzahlKonten); }
}Abheben geklappt: true500 € abheben geklappt: falseKonto 1001 (Anna Muster): 230,01 €Konto 1002 (Ben Beispiel): 100,00 €Konten insgesamt: 2Jedes Konto hat seinen eigenen Kontostand. annasKonto.einzahlen(…) ändert
nur Annas Konto – Bens bleibt, wie es ist.
Und was du aus dem Kapitel Referenzen
weißt, gilt auch für eigene Objekte: In annasKonto steht ein Verweis.
Nach Konto k = annasKonto; zeigen beide Variablen auf dasselbe Konto.
Endlich: static
Abschnitt betitelt „Endlich: static“Seit dem ersten Tag steht static vor main und vor unseren Methoden. Jetzt
können wir es erklären:
mit static |
ohne static |
|
|---|---|---|
| gehört zu | der Klasse | einem Objekt |
| gibt es | einmal | je Objekt einmal |
| Aufruf | Klasse.methode() – z. B. Math.max(3, 7) |
objekt.methode() – z. B. annasKonto.einzahlen(…) |
| Beispiel im Konto | anzahlKonten – zählt alle Konten |
kontostand – jedes Konto hat seinen eigenen |
anzahlKontengibt es nur einmal für alle Konten. Jeder Konstruktor zählt es hoch – deshalb bekommt jedes Konto eine neue Nummer.mainmussstaticsein: Beim Programmstart gibt es noch kein einziges Objekt, auf dem Java eine Methode aufrufen könnte.- Unsere bisherigen Methoden wie
istPrimoderbewertebrauchten keine Daten aus einem Objekt – deshalb waren siestatic. Das ist für reine Rechenfunktionen auch richtig so.
Eine statische Methode kann keine Instanzmethode direkt aufrufen – sie weiß
nicht, auf welchem Objekt. Konto.einzahlen(…) meldet in Eclipse:
Cannot make a static reference to the non-static method einzahlen(Betrag) from
the type Konto.
Eine offene Hintertür
Abschnitt betitelt „Eine offene Hintertür“package de.drv.bank;
import java.time.LocalDate;
public class Hintertuer {
public static void main(String[] args) { Konto konto = new Konto(new Kunde("Anna Muster", LocalDate.of(2004, 3, 12)));
konto.kontostand = konto.kontostand.plus(Betrag.euro(1_000_000)); konto.kontonummer = 4711;
System.out.println(konto.beschreibung()); }
}Konto 4711 (Anna Muster): 1.000.000,00 €Unser Konto führt sorgfältig Buch über jede Einzahlung und Abhebung – und jeder andere Code erhöht den Kontostand einfach mal eben um eine Million Euro, ohne dass irgendwo Geld eingezahlt wurde. Auch die Kontonummer lässt sich beliebig ändern. Die Regel steht zwar an einer Stelle, aber man kann um sie herum greifen.
Wie man diese Tür schließt, ist das Thema des nächsten Kapitels: Kapselung.
Wenn es nicht klappt
Abschnitt betitelt „Wenn es nicht klappt“| Meldung in Eclipse | Ursache |
|---|---|
| The constructor Konto() is undefined | Es gibt nur Konstruktoren mit Parametern – hier fehlt der Inhaber |
| Cannot make a static reference to the non-static method … | Instanzmethode über den Klassennamen aufgerufen statt über ein Objekt |
| The method einzahlen(Betrag) … is not applicable for the arguments (int) | Zahl statt Betrag übergeben – Betrag.euro(5) statt 5 |
| Null pointer access: The variable k can only be null at this location (Warnung) | Methode auf einer Variable aufgerufen, die noch kein Objekt hat |
| Alle Konten haben dieselbe Nummer | anzahlKonten ohne static – dann hat jedes Konto seinen eigenen Zähler |
Übungen
Abschnitt betitelt „Übungen“- Ergänze das Konto um das Feld
eroeffnetAm(einLocalDate), das der Konstruktor auf das heutige Datum setzt. Gib es inbeschreibungmit aus. - Schreibe die Methode
ueberweisen(Konto ziel, Betrag betrag). Sie soll nur überweisen, wenn genug Geld da ist, undtrueoderfalsezurückgeben. Verwende die vorhandenen Methoden. - Gib dem Kunden eine Methode
alter(), die sein Alter in Jahren liefert. - Alle Konten unserer Bank haben dieselbe Bankleitzahl
12345678. Lege sie als Konstante an und schreibe eine Methodekontokennung(), die12345678/1001liefert.
Lösung
Lösung zu 1, 2 und 4. ueberweisen nutzt abheben und einzahlen – so gilt die
Prüfung der Deckung automatisch auch hier. Die Bankleitzahl ist static final:
einmal für alle Konten und unveränderlich.
package de.drv.bank;
import java.time.LocalDate;
public class Konto {
static final String BANKLEITZAHL = "12345678"; static int anzahlKonten = 0;
int kontonummer; Kunde inhaber; Betrag kontostand; LocalDate eroeffnetAm;
Konto(Kunde inhaber) { anzahlKonten++; this.kontonummer = 1000 + anzahlKonten; this.inhaber = inhaber; this.kontostand = Betrag.NULL; this.eroeffnetAm = LocalDate.now(); }
Konto(Kunde inhaber, Betrag startguthaben) { this(inhaber); einzahlen(startguthaben); }
void einzahlen(Betrag betrag) { kontostand = kontostand.plus(betrag); }
boolean abheben(Betrag betrag) { if (betrag.istGroesserAls(kontostand)) { return false; } kontostand = kontostand.minus(betrag); return true; }
boolean ueberweisen(Konto ziel, Betrag betrag) { if (!abheben(betrag)) { return false; } ziel.einzahlen(betrag); return true; }
String kontokennung() { return BANKLEITZAHL + "/" + kontonummer; }
String beschreibung() { return "Konto " + kontokennung() + " (" + inhaber.name + ", eröffnet am " + eroeffnetAm + "): " + kontostand; }
}Lösung
Lösung zu 3 – mit Period aus dem Kapitel Datum und Zeit.
package de.drv.bank;
import java.time.LocalDate;import java.time.Period;
public class Kunde {
String name; LocalDate geburtsdatum;
Kunde(String name, LocalDate geburtsdatum) { this.name = name; this.geburtsdatum = geburtsdatum; }
int alter() { return Period.between(geburtsdatum, LocalDate.now()).getYears(); }
}Lösung
package de.drv.bank;
import java.time.LocalDate;
public class Bankdemo {
public static void main(String[] args) { Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12)); Kunde ben = new Kunde("Ben Beispiel", LocalDate.of(1999, 11, 2));
Konto annasKonto = new Konto(anna, Betrag.euro(250)); Konto bensKonto = new Konto(ben);
boolean geklappt = annasKonto.ueberweisen(bensKonto, Betrag.euro(80)); System.out.println("Überweisung 80 €: " + geklappt);
boolean zuViel = annasKonto.ueberweisen(bensKonto, Betrag.euro(500)); System.out.println("Überweisung 500 €: " + zuViel);
System.out.println(annasKonto.beschreibung()); System.out.println(bensKonto.beschreibung()); System.out.println(anna.name + " ist " + anna.alter() + " Jahre alt."); System.out.println("Konten insgesamt: " + Konto.anzahlKonten); }
}