Objekte und Klassen in Java

Bevor man ein Java-Programm schreibt, ist es immer sinnvoll, sich zunächst die Objekte und Klassen zu überlegen, und z. B. in der UML-Notation darzustellen. Auf dieser Grundlage ist es einfach, das Java-Programmgerüst zu implementieren.

Der von uns im Unterricht verwendete Java-Editor bietet ein Werkzeug, welches aus einer erzeugten UML-Notation automatisch das Java-Programmgerüst erstellt.

Klassen in Java

Eine Klassendeklaration besteht - wie eine Klasse in der UML-Notation - aus drei Teilen:

• dem Klassennamen (identifier)
• dem Klassenrumpf (class body) mit

• den Attributdeklarationen (field declarations) und
• den Methodendeclarationen (method declarations)

Damit andere Klassen die Werte von Attributen nicht sehen können - und das Geheimnisprinzip (information hiding) eingehalten wird - wird durch das Schlüsselwort private festgelegt, dass diese Attribute Privatbesitz der jeweiligen Klasse sind. Um auf die einzelnen Attribute lesend und schreibend zugreifen zu können, werden Methoden benötigt, die von anderen Klassen / Objekten aufgerufen werden können, daher sind diese mit dem Schlüsselwort public gekennzeichnet. Für das Schreiben von einzelnen Attributwerten wird als Methodenname setAttributname verwendet, für das Lesen der Methodenname getAttributname.

Jede Klasse muss durch einen oder mehrere Konstruktoren festlegen, wie Objekte von ihr erzeugt werden können. Konstruktoren haben als Methodenname den Namen der Klasse. Da Konstruktoren einer Klasse von außerhalb aufgerufen werden müssen, müssen diese auch durch das Schlüsselwort public gekennzeichnet sein. In runden Klammern kann eine Parameterliste aufgeführt werden, in der angegeben wird, mit welchen Werten die Attribute des zu erzeugenden Objekts initialisiert werden sollen.

Die einzelnen Anweisungen in den Methoden des erzeugten Java-Programmrumpfes müssen >>von Hand<< eingebunden werden, diese stehen nicht im UML-Diagramm.

Beispiel

Betrachten wir als Beispiel die Klasse Kunde, die durch das folgende UML-Diagramm gegeben ist:

Wird diese Klasse Kunde im Java-Editor erstellt, wird gleichzeitig das folgende Java-Programmgerüst implementiert:

 01 public class Kunde {
 02 
 03   // Anfang Attribute
 04   private String firmenname;
 05   private String firmenadresse;
 06   private int auftragssumme;
 07   // Ende Attribute
 08 
 09   public Kunde() {
 10     this.firmenname = "";
 11     this.firmenadresse = "";
 12     this.auftragssumme = 0;
 13   }
 14 
 15   public Kunde(String firmenname) {
 16     this.firmenname = firmenname;
 17     this.firmenadresse = "";
 18     this.auftragssumme = 0;
 19   }
 20 
 21   // Anfang Methoden
 22   public int getAuftragssumme() {
 23     return auftragssumme;
 24   }
 25 
 26   public void setAuftragssumme(int Auftragssumme) {
 27     this.auftragssumme = auftragssumme;
 28   }
 29 
 30   public String getFirmenadresse() {
 31     return firmenadresse; 
 32   }
 33
 34   public String getFirmenname() {
 35     return firmenname;
 36   }
 37 
 38   public void setFirmenname(String Firmenname) {
 39     this.firmenname = firmenname;
 40   }
 41 
 42   public void setFirmenadresse(String Firmenadresse) {
 43     this.firmenadresse = firmenadresse;
 44   }
 45 
 46   // Ende Methoden
 47 }

Visualisierung von Objekten

Der Java-Editor bietet die Möglichkeit, Klassen in UML-Notation anzulegen und das Erstellen und Manipulieren von Objekten zu Simulieren. Damit lässt sich z. B. (einfach) die schon diskutierte Klasse Kunde mit zwei Objekten erzeugen.

GUI-Klassen

Die simulierte Arbeit mit Klassen und Objekten ist in Java-Programmen natürlich nicht möglich. Um mit einer Fachkonzept-Klasse arbeiten zu können benötigt man mindestens eine weiter Klasse, von der aus Botschaften verschickt werden, um erstens Objekte von der Fachkonzept-Klasse zu erzeugen und zweitens, um diese erzeugten Objekte manipulieren zu können.

Eine dieser zusätzlichen Klassen stellt die Verbindung der Klasse zur Benutzeroberfläche her, solchen Klassen werden GUI-Klassen genannt.

Ein grundlegendes Prinzip beim Entwurf von Software-Systemen besteht heute in einer klaren Trennung zwischen Benutzeroberfläche und Fachkonzept (Daten).

Die Fachkonzept-Klassen dürfen nicht direkt mit dem GUI-System kommunizieren, sondern nur über die GUI-Klassen, die den Fachkonzept-Klassen Botschaften senden. In der Regel kennen die Fachkonzept-Klassen die GUI-Klassen nicht, d. h. von den Fachkonzept-Klassen werden keine Botschaften an die GUI-Klassen geschickt.

In Java sollte jede Klassen in einer eigenen Datei abgespeichert werden. Um am Klassennamen eindeutig zu erkennen, um welche Art von Klasse es sich handelt, sollten GUI-Klassen am Ende immer den Zusatz GUI angehängt bekommen. Zu der oben dargestellten Klasse Kunde müsste es also eine GUI-Klasse KundeGUI geben.

Eine GUI-Klasse baut die Benutzeroberfläche auf, liest die Eingaben von den Benutzern ein und gibt Ergebnisse aus. Um spätere Änderungen an den Daten eines erzeugten Objektes vornehmen zu können, muss sich die GUI-Klasse Referenzen bzw. Zeiger auf die erzeugten Fachklassen-Objekte speichern.

Beispiel

Eine (einfache) GUI-Klasse zur oben dargestellten Fachklasse Kunde könnte ein Label-Objekt für eine Überschrift, ein Textfeld zum Darstellen der Daten und einen Button zum Start gewünschter Aktionen (hier: Erzeugen von zwei Objekten und Anzeigen deren Daten) enthalten.

Im Java-Editor kann ein solcher jFrame einfach und unkompliziert erzeugt werden.

Im Klasseneditor können dann die notwendigen Attribute ersterKunde und zweiterKunde hinzugefügt werden. Zudem sollte es noch eine Methode start() geben, die durch jBtnStart_Action() (Klick auf den Button) aufgerufen wird.

Damit erhält man die folgende Klasse KundeGUI in UML-Notation. Da die Klasse KundeGUI die Objekte der Klasse Kunde referenzieren möchte, muss zwischen diesen Klassen eine KENNT-Beziehung (Assoziation) bestehen. Diesen Sachverhalt stellt der Java-Editor automatisch dar:

Zudem wurde (auch automatisch) der notwendige Java-Programmrumpf erzeugt. Es müssen nun lediglich noch die notwendigen Programmzeilen >>per Hand<< eingefügt werden, damit das Programm auch die gewünschten Aktionen ausführt (Zeilen 57..74 und 78):

 01 import java.awt.*;
 02 import java.awt.event.*;
 03 
 04 import javax.swing.*;
 05 import javax.swing.event.*;
 06 
 07 
 08 public class KundeGUI extends JFrame {
 09   // Anfang Attribute
 10   private Kunde ersterKunde;
 11   private Kunde zweiterKunde;
 12   private JTextArea myTextArea = new JTextArea("");
 13   private Label label1 = new Label();
 14 
 15   private JButton jBtnStart = new JButton();
 16   // Ende Attribute
 17   public KundeGUI(String title) {
 18     // Frame-Initialisierung
 19     super(title);
 20     setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
 21 
 22     int frameWidth = 300;
 23     int frameHeight = 265;
 24     setSize(frameWidth, frameHeight); 
 25 
 26     Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
 27     int x = (d.width - getSize().width) / 2;
 28     int y = (d.height - getSize().height) / 2;
 29     setLocation(x, y);
 30 
 31     Container cp = getContentPane();
 32     cp.setLayout(null);
 33     // Anfang Komponenten
 34     myTextArea.setBounds(8, 32, 265, 153);
 35     myTextArea.setText("");
 36     cp.add(myTextArea);
 37     label1.setBounds(8, 8, 115, 16);
 38     label1.setText("Kunden der Firma");
 39     label1.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
 40     cp.add(label1);
 41     jBtnStart.setBounds(88, 192, 75, 25);
 42     jBtnStart.setText("Start");
 43     jBtnStart.setMargin(new Insets(2, 2, 2, 2));
 44     jBtnStart.addActionListener(new ActionListener() {
 45       public void actionPerformed(ActionEvent evt) {
 46         jBtnStart_ActionPerformed(evt);
 47       }
 48     });
 49     cp.add(jBtnStart);
 50     // Ende Komponenten
 51     setResizable(false);
 52     setVisible(true);
 53   }
 54 
 55   // Anfang Methoden
 56   public void start() {
 57     //Attribute zum Merken der Ergebnissse der Botschaften
 58     String merkeText;
 59     int merkeZahl;
 60     //Erzeugen von zwei Objekten durch Aufruf des Konstruktors
 61     ersterKunde = new Kunde("KFZ-Zubehör GmbH");
 62     zweiterKunde = new Kunde("Schrottverwertung AG");
 63     //Adressen eintragen
 64     ersterKunde.setFirmenadresse("36037 Fulda, Adalbertstraße 234a");
 65     zweiterKunde.setFirmenadresse("44867 Bochum, Fuldaer Straße 2");
 66     //Auftragssumme eintragen
 67     ersterKunde.setAuftragssumme(15000);
 68     //Anzeigen der Attributinhalte im Textbereich
 69     myTextArea.append(ersterKunde.getFirmenname()+"\n");
 70     myTextArea.append(ersterKunde.getFirmenadresse()+"\n");
 71     myTextArea.append("Auftragssumme: " + String.valueOf(ersterKunde.getAuftragssumme())+"\n\n");
 72     myTextArea.append(zweiterKunde.getFirmenname()+"\n");
 73     myTextArea.append(zweiterKunde.getFirmenadresse()+"\n");
 74     myTextArea.append("Auftragssumme: " + String.valueOf(zweiterKunde.getAuftragssumme())+"\n\n");
 75   }
 76 
 77   public void jBtnStart_ActionPerformed(ActionEvent evt) {
 78     start();
 79   }
 80 
 81   // Ende Methoden
 82   public static void main(String[] args) {
 83     new KundeGUI("Kunden");
 84   }
 85 }

Damit erhalten wir nach dem Start des Programms und einem Mausklick auf den Button folgendes Ergebnis: