Praktische Informatik 1

7.2 Klassen, Objekte, Methoden, Datenfelder, Konstruktoren

Eine Klasse ist die Java-Realisierung eines abstrakten Datentyps. In der objektorientierten Programmierung sind Klassen das grundlegende Strukturierungsmittel.

Klasse = Datenfelder + Methoden
Datenfelder sind die Zustandsvariablen des Objekts, Methoden die Operationen, Funktionen oder Prozeduren zur Zustandsänderung. Objekte sind Instanzen von Klassen, ähnlich wie Elemente Bestandteile einer Menge sind. Die folgenden Begriffe werden fast synonym verwendet (mit minimalen, subtilen Unterschiede!)

• 
  Klasse ~ Typ ~ Art
  
• 
  Objekt ~ Instanz ~ Exemplar
  
• 
  Datenfeld ~ Objektattribut ~ Instanzvariable ~ Eigenschaft (passives Merkmal)
  
• 
  Methode ~ Funktion/Prozedur ~ Operation ~ Fähigkeit (aktives Merkmal)
  
• 
  Parameter ~ Argument ~ Eingabewert
  

Beispiel für eine Klasse: Philosophen sitzen um einen Tisch, denken, werden hungrig und essen:

class Philosoph {

boolean hungrig;

void denken() {...};

void essen() {...};

}
Klassen bestehen also im Wesentlichen aus der Deklaration von Daten- und Funktionsteilen (vgl. Turing/von-Neumann Analogie zwischen Daten und Programmen). Datenfelder bestimmen durch ihren aktuellen Wert während einer Berechnung den Zustand der abgeleiteten Objekte, Methoden definieren die Aktionsmöglichkeiten der Objekte.

Beispiel: das Objekt `Sokrates´ ist eine Instanz der Klasse `Mensch´, kann im Zustand `hungrig´ sein und beherrscht die Methode `denken´ mit Ergebnistyp `Erkenntnis´ (void).
Objekte können von anderen Objekten erzeugt und aufgerufen werden:

public static void main(String[] args) {

Philosoph sokrates;

sokrates = new Philosoph();

sokrates.denken();

if(sokrates.hungrig) sokrates.essen();

System.out.println(sokrates.hungrig);

}
Objektorientierte Modellierung

Klassen modellieren ein Konzept eines Anwendungsbereiches oder eine Gemeinsamkeit mehrerer Dinge (platonische „Idee“); Objekte modellieren die konkreten Akteure oder Gegenstände des betrachteten Bereiches. Berechnungen entstehen dadurch, dass Objekte miteinander und mit dem Benutzer kommunizieren, das heisst,

• 
  sich gegenseitig aufrufen
  
• 
  Nachrichten austauschen
  
• 
  neue Objekte erzeugen
  

Wurzel der Interaktion ist die public class Main mit der Methode
public static void main(String[] args) {…}
Beispiele

Wichtig: Klassen können hierarchisch strukturiert sein!

Lebewesen – Mensch – Berliner

Fahrzeug – Auto – Porsche

usw.
Darüber hinaus gibt es statische Datenfelder (Schlüsselwort static): Diese beschreiben Attribute, die alle Objekte der Klasse gemeinsam haben

Beispiel: static int anzahl_Finger = 10;

als Attribut von class Philosoph

Solange kein Objekt einer Klasse erzeugt wurde, muss nur der Speicherplatz für statische Variablen angelegt werden. Der Speicherplatz für Objekte wird erst beim Aufruf von new reserviert. Mit new wird (dynamisch) ein neues Objekt erzeugt. Man nennt diesen Vorgang auch “instanziieren” und das Objekt eine „Instanz“ der Klasse. z.B.

Philosoph aristoteles = new Philosoph();

• 
  Dadurch werden die objektspezifischen Datenfelder angelegt, d.h., es wird ausreichend Speicherplatz im Adressraum reserviert.
  
• 
  Dieser Speicherplatz wird automatisch wieder freigegeben, wenn das Objekt nicht mehr erreichbar ist („garbage collection“)
  
• 
  Primitive Datenobjekte (Zahlen oder Zeichen) müssen nicht erzeugt werden, sie existieren sowieso.
  

Vom Instanziieren zu unterscheiden ist das Initialisieren von Objekten: den Datenfeldern werden Anfangswerte zugewiesen; z.B., int x = 0;

Eine nichtinitialisierte Variable enthält u.U. einen unvorhersagbaren Wert (was zufällig an dieser Stelle im Speicher stand…)
Für die Erzeugung von neuen Objekten kann jede Klasse Konstruktor-Methoden zur Verfügung stellen, die genauso wie die Klasse selbst heißen (im Beispiel Philosoph()), und in denen die Datenfelder der Klasse initialisiert werden können.
void Philosoph (){

hungrig = true;

}

Der Konstruktor wird bei der Erzeugung eine Instanz der Klasse automatisch aufgerufen und dient dazu, das betreffende Objekt zu initialisieren. Der Konstruktor hat denselben Namen wie die Methode selbst und kann auch Eingabeparameter enthalten, liefert jedoch kein Ergebnis.

class Student { ...

String matrikelnummer;

int scheine;

Student (String matrNr){ // Konstruktor- Methode

matrikelnummer = matrNr; ...

scheine = 0;

}

...
Klassen dienen zur Realisierung von abstrakten Datentypen. Dabei sind nur die Zugriffsfunktionen (in der Signatur) sichtbar („public“). Beispiel: Klasse „Stack“ zur Realisierung von Stapeln (nach Bothe):

class Stack {

private char[] stackElements;

private int top;

public Stack(int n) {

stackElements = new char [n];

top = -1; }

public boolean isempty() {

return top == -1; }

public void push(char x) { // Methode

if (top + 1 == stackElements.length){

System.out.println (“Stack ist voll”);

return;

}

top++; stackElements[top] = x; }

public char top() {

if (isempty()) {

System.out.println("Stack leer");

return ' ';

} else

return stackElements [top];

}

public void pop() {

if (isempty())

System.out.println("Stack leer");

else

top--;

}

}

Anwendung der Klasse: z.B. zum Überprüfen von Klammerstrukturen:

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;
public class Klammerstruktur {

public static void main(String[] args) {

System.out.println("Geben Sie eine Klammerstruktur ein");

BufferedReader inputReader =

new BufferedReader(new InputStreamReader(System.in)) ;

String eingabeZeile = "";

try {eingabeZeile = inputReader.readLine();}

catch (IOException e){}

int n = eingabeZeile.length();

Stack s = new Stack(n);

for (int i = 0; i < n; i++) {

char ch = eingabeZeile.charAt(i);

if (ch == '(' || ch == '{' || ch == '[')

s.push(ch);

else if (ch==')' && s.top() =='(' ||

ch=='}' && s.top() =='{' ||

ch==']' && s.top() =='[')

s.pop();

else if (ch==')' || ch=='}' || ch==']' ) {

System.out.println("schließende Klammer passt nicht"); return;

}

}

if (!s.isempty())

System.out.println("schließende Klammer fehlt");

else

System.out.println("Klammerstruktur korrekt");

}

}

(Achtung: Auch hier prüfen wir nicht ob der Keller leer ist.)

Anwendungsbeispiel ist z.B. der Term (()([]{})) oder der Term
if ( x < ( a [ ( i ) ] / 2 )) { x += f () ;}
Natürlich kann man auch mehrere Objekte einer Klasse erzeugen:

Stack s7 = new Stack(7);

Stack s9 = new Stack(9);

Dadurch werden verschiedene Instanzen der Klasse, jeweils mit eigenen Instanzvariablen und –methoden, erzeugt. Der Zugriff erfolgt über Qualifikatoren:

s7.push('a');

s9.push('b');

Modifikatoren:

Klassen, Datenfelder und Operationen können durch Modifikatoren näher attributiert werden. Diese betreffen vorwiegend die Zugriffsmöglichkeiten auf die betreffende Komponente. Folgende Modifikatoren sind erlaubt:

• 
  final (für ein Datenfeld): Das Datenfeld ist eine Konstante, hat also für alle Objekte der Klasse stets den gleichen, unveränderlichen Wert.
  
• 
  final (für eine Operation): Die Operation kann in Unterklassen nicht verändert (überschrieben) werden.
  

• 
  static : Die Komponente ist klassenbezogen, d.h. für alle Objekte der Klasse in gleicher Weise verfügbar und wertgleich. Für eine Operation bedeutet das: Die betreffende Operation darf nur static-Datenfelder benutzen.
  

• 
  private : Die Komponente darf nur innerhalb der aktuellen Klasse benutzt werden (aber von beliebigen Objekten der Klasse).
  
• 
  public : Die Komponente ist öffentlich, darf also unbeschränkt von außen benutzt werden.
  
• 
  protected : Auf die Komponente kann man nur innerhalb des Pakets zugreifen, das die betreffende Klasse enthält, und zusätzlich von deren Unterklassen.
  
• 
  package (default-Einstellung): Zugriff wie bei protected, aber auf das aktuelle Paket beschränkt.
  

Auch bei der Verwendung von Modifikatoren sollte man die Sichtbarkeitsregel „so lokal wie möglich, so global wie nötig“ berücksichtigen.