Zum Inhalt springen

Klassen und Objekte

Jetzt setzen wir den Entwurf aus dem letzten Kapitel um: einen Kunden und ein Konto, das Geld annehmen und auszahlen kann.

  • eine Klasse mit Feldern, Konstruktoren und Methoden schreiben
  • Objekte mit new erzeugen und ihre Methoden aufrufen
  • this verwenden
  • erklären, was static bedeutet – und was der Unterschied zu einer Instanzmethode ist

Startprojekt 15-bank

⤓ bank-start.zip herunterladen

In 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.

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:

Betrag.java
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 €
Kunde.java
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.

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“.

Konto.java
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;
}
}

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.

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.

Bankdemo.java
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);
}
}
Terminal-Fenster
Abheben geklappt: true
500 € abheben geklappt: false
Konto 1001 (Anna Muster): 230,01 €
Konto 1002 (Ben Beispiel): 100,00 €
Konten insgesamt: 2

Jedes 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.

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
  • anzahlKonten gibt es nur einmal für alle Konten. Jeder Konstruktor zählt es hoch – deshalb bekommt jedes Konto eine neue Nummer.
  • main muss static sein: Beim Programmstart gibt es noch kein einziges Objekt, auf dem Java eine Methode aufrufen könnte.
  • Unsere bisherigen Methoden wie istPrim oder bewerte brauchten keine Daten aus einem Objekt – deshalb waren sie static. 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.

Hintertuer.java
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());
}
}
Terminal-Fenster
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.

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
  1. Ergänze das Konto um das Feld eroeffnetAm (ein LocalDate), das der Konstruktor auf das heutige Datum setzt. Gib es in beschreibung mit aus.
  2. Schreibe die Methode ueberweisen(Konto ziel, Betrag betrag). Sie soll nur überweisen, wenn genug Geld da ist, und true oder false zurückgeben. Verwende die vorhandenen Methoden.
  3. Gib dem Kunden eine Methode alter(), die sein Alter in Jahren liefert.
  4. Alle Konten unserer Bank haben dieselbe Bankleitzahl 12345678. Lege sie als Konstante an und schreibe eine Methode kontokennung(), die 12345678/1001 liefert.
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.

Konto.java
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.

Kunde.java
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
Bankdemo.java
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);
}
}