Wir wollen uns die wichtigsten Begriffe der OOP nochmals an einem Beispiel klar machen. Wir erstellen dazu eine sehr simple Girokontenverwaltung.

Wir wiederholen zunächst den zentralen Gedanken der objektorientierten Programmierung (OOP). Dazu ziehen wir zunächst einen Vergleich zur klassischen Programmierung (auch wenn wir davon noch nicht allzu viel behandelt haben).

Im Mittelpunkt der OO-Programmierung stehen Objekte. Darunter versteht man in der Informatik einen Gegenstand, ein Lebewesen, einen Sachverhalt, etc., der

• Eigenschaften (Attribute) besitzt
• Verhaltensweisen (Methoden) hat
• in Beziehung zu anderen Objekten stehen kann (Vererbung)

Die Vorteile dieser Sichtweise sind:

• natürlichere Modellierung von Problemen
• einfache Erweiterbarkeit existierender Programme
• Wiederverwendbarkeit von Programmen
• ModularisierungDatenkapselung, d.h. auf Daten eines Objekts wird niemals direkt, sondern immer nur über Methoden zugegriffen.

Man muss zwischen einem Objekt und einer Klasse von Objekten unterscheiden. Eine Klasse beschreibt

• Eigenschaften (Variablen / Attribute)
• Struktur (Subobjekte)
• Verhalten (Funktionen / Methoden) einer Gruppe von gleichartigen Objekten

Ein Objekt, manchmal auch Instanz einer Klasse genannt, wird durch eine Klasse beschrieben und setzt sich demnach zusammen aus

• Attributwerten, d.h. konkrete Werte der Attribute der Klasse
• den auf den Attributen ausführbaren Methoden

Alle Objekte einer Klasse haben gleiche Attribute und gleiche Methoden, sie unterscheiden sich nur in den Werten ihrer Attribute.

Beispiel: Die Klasse „Auto“ beschreibt die gemeinsamen Attribute und Methoden aller Auto-Objekte. In einem UML-Klassendiagramm sieht das folgendermaßen aus: (UML bedeutet Unified Modeling Language)

Das konkrete Objekt „MeineSchrottkarre“ der Klasse „Auto“ verfügt hingegen über konkrete Attributwerte wie eine Leistung von 56 PS und einen Füllstand von 17 Litern.

Zur Erinnerung: Java ist komplett objektorientiert, d.h. es ist nicht möglich ein Java-Pro¬gramm zu schreiben, ohne eine Klasse zu definieren.

Nun soll anhand des Beispiels Girokonto die Umsetzung dieser doch relativ abstrakten Aussagen über Objekte in Java konkretisiert werden. Wir führen die Klasse „Girokonto“ mit den Attributen „Kontostand“ und „Kredit“ sowie den Methoden „eroeffnen“, „GeldEinzahlen“, „GeldAbheben“ und „KontostandAnzeigen“ ein:

// Klasse GiroKonto 
public class GiroKonto //eine Klasse für ein Girokonto
{
   double Kontostand ;      // Das sind Daten bzw. Attribute
   double Kredit ;   
 
   void eroeffnen(double Kredi)  // Methode,übergeben wird der Kreditrahmen
   {
     Kontostand = 0 ; Kredit = - Kredi ;
   }
 
   double Kontostand_anzeigen() // Methode, die den Kontostand zurückgibt.
   {
     return Kontostand ;
   double Geld_abheben(double Betrag)   // Methode, die den gewünschten Betrag
        // übergeben bekommt und den tatsächlich ausgezahlten Betrag unter
        // Berücksichtigung des Kreditrahmens zurückgibt.
   {
     if (Kontostand - Betrag >= Kredit)
       {
         Kontostand -= Betrag ;
         return Betrag ;
       }
     else
        {
          double auszahlung = Kontostand - Kredit ;
          Kontostand = Kredit ;
          return auszahlung ;
        }
   }
   void Geld_einzahlen (double Summe)  // Methode  für das Einzahlen
   {
     Kontostand += Summe ;
   }
}

Es fällt natürlich auf, dass es in dem Quellcode überhaupt kein Hauptprogramm gibt. Deswegen führt auch der Versuch, das Programm auszuführen, zu einer Fehlermeldung, obwohl es sich ohne Probleme übersetzen lässt. Was wir geschaffen haben, ist eine neue Klasse „Girokonto“, auf deren Methoden wir in anderen Programmen zugreifen können. Voraussetzung dafür ist (im Moment), dass sich das auszuführende Programm im selben Verzeichnis wie das übersetzte Programm „Girokonto.class“ befindet. Wie man konkret auf diese Klasse zugreift, zeigt das nächste Beispiel.

GiroKonto meinKonto = new GiroKonto() ; // Diese Zeile deklariert eine
  // neue Instanz der Klasse GiroKonto mit dem Namen MeinKonto und
  // ruft eine Spezialmethode Konstruktor auf, die nicht extra
  // deklariert werden muss und die nichts zurückgibt und nichts
  // erhält. Vor dem Aufruf des Konstruktors steht das Schlüssel-
  // wort new.
  // Anfang Methoden
  public void jButton1_ActionPerformed(ActionEvent evt) 
  {
    double kredit = Double.parseDouble(jTextField1.getText()) ;
    meinKonto.eroeffnen(kredit) ;
    jTextField4.setText("Das Konto wurde eröffnet.") ;  
  } // end of jButton1_ActionPerformed
 
  public void jButton2_ActionPerformed(ActionEvent evt) 
  {
    double betrag = Double.parseDouble(jTextField2.getText()) ;
    meinKonto.Geld_einzahlen(betrag) ; 
    jTextField4.setText(betrag + "€ einbezahlt.") ;   
} // end of jButton2_ActionPerformed
  public void jButton3_ActionPerformed(ActionEvent evt) 
  {
    double betrag = Double.parseDouble(jTextField2.getText()) ;
    double auszahlung = meinKonto.Geld_abheben(betrag) ;
    jTextField4.setText(auszahlung + "€ ausbezahlt.") ;   
  } // end of jButton3_ActionPerformed
 
  public void jButton4_ActionPerformed(ActionEvent evt) 
  {
    jTextField3.setText(String.valueOf(meinKonto.Kontostand_anzeigen())) ;
    jTextField4.setText("Kontostand abgefragt.") ;   
  } // end of jButton4_ActionPerformed
 
  // Ende Methoden
 
  public static void main(String[] args) {
    new GirokontoTest("GirokontoTest");
  } // end of main
 
} // end of class GirokontoTest

Die grafische Oberfläche enthält insgesamt vier Buttons, daher gibt es auch vier Funktionen im Quelltext, die ihnen zugeordnet sind:

Erstelle ein UML-Diagramm der Klasse „Girokonto“!

Starte das Programm und verändere es so, dass nach jeder Transaktion eine passende Meldung im Info-Fenster angezeigt wird (vgl. grafische Oberfläche). Wichtig: In der Java-Datei, die den Quelltext der Klasse „Girokonto“ enthält, dürfen keine weiteren Java-Befehle stehen!!!!!

Erzeuge ein neues Hauptprogramm (mit nur einem Button), das die drei Konten „Asterix“ (Limit 2.000€), „Obelix“ (Limit 1.000€) und „Miraculix“ (Limit 0€) einrichtet. Überweise auf diese Konten 1.000€, 2.000€ bzw. 3.000€ und hebe dann 2.000€, 1.000€ bzw. 4.000€ ab. Lass dir zum Schluss den Stand der drei Konten anzeigen.

Betrachte die Klasse „Kaffeemaschine“:

public class Kaffeemaschine
{
   String Maschinenname;
   int Kaffeefüllstand;  // Anzahl Tassen, für die Kaffeevorrat ausreicht
   int Wasserfüllstand;  // Anzahl Tassen, für die Wasservorrat ausreicht
 
   public void MaschineStarten(String Name)
   {
      Maschinenname = Name; 
      Kaffeefüllstand = 0;
      Wasserfüllstand = 0;
   }
 
   public int WasserfüllstandAnzeigen()
   {
      return Wasserfüllstand;
   } 
 
   public int Kaffeekochen(int AnzTassen)
   {
      Kaffeefüllstand -= AnzTassen;
      Wasserfüllstand -= AnzTassen;
      return AnzTassen;
   }
 
   public void KaffeeEinfüllen(int Menge)
   {
      Kaffeefüllstand += Menge;
   }
    public int KaffeefüllstandAnzeigen()
   {
      // Hier fehlt der Programmcode:
 
   }
 
   public void WasserEinfüllen(int Menge)
   {
      // Hier fehlt der Programmcode:
 
   }
}

1. Erstelle zunächst ein UML-Diagramm!
2. Ergänze die noch fehlenden Teile des Quelltextes und compiliere die Klasse!
3. Erstelle ein geeignetes Hauptprogramm mit grafischer Oberfläche, in dem das Objekt „MeineKaffeemaschine“ erzeugt wird. Verwende unterschiedliche Buttons für das Befüllen der Maschine mit Kaffee bzw. Wasser sowie das Kaffeekochen. Verwende ein Textfeld für die Kaffeeausgabe und zwei für die Anzeige von Wasser und Kaffee. Teste das Befüllen und natürlich das Kaffeekochen!
4. Zusatzaufgabe: Verbessere die Methode Kaffeekochen!