Klasse

Klassen sind der Bauplan für Objekte. Sie beschreiben die Eigenschaften und das Verhalten von Objekten und orientieren sich dabei an ihren Vorbildern aus der "realen" Welt.

Vom Chaos zur Klasse

Zur Laufzeit besteht ein Programm aus zwei Hälften: zum einen gibt es Daten, zum anderen Code um die Daten zu bearbeiten. Diese beiden Hälften müssen irgendwie in einer Programmiersprache abgebildet werden, damit ein Programmierer ein Programm schreiben kann.

Ansatz: globale Variablen und Funktionen

Eine erste Idee kann so aussehen:

// Daten: hier als Beispiel ein Rechteck.
// w und h sind Breite und Höhe (width und height)
int w = 6;
int h = 8;

// Funktion: um zwei Ganzzahlen zu bearbeiten (hier 
// wird die Fläche eines Rechteckes mit Grösse x/y berechnet)
int size( int x, int y ){
  return x*y;
}

Ansatz: Strukturen

Dass im obigen Beispiel "w" und "h" ein Rechteck darstellen, ist nicht sehr intuitiv. Im Gegenteil, "w" und "h" könnten alles mögliche sein, und müssen keinen Zusammenhang haben.

Möchte man ein zweites Rechteck haben, muss man zwei weitere Variablen einführen... mit dieser Sprache würde der Programmcode explosionsartig wachsen.

Da ist es nur naheliegend, die Variablen in einer Struktur zu kombinieren:

// Zuerst ein Rechteck als zwei Ganzzahlen definieren.
struct Rectangle{
  int w;
  int h;
};

// Daten: man erstellt sich ein Rechteck "r", und setzt
// die Breite "w" auf 6, die Höhe "h" auf 8.
Rectangle r;
r.w = 6;
r.h = 8;

// Funktion: nun wird schon klarer, was "size" benötgt
int size( Rectangle x ){
  return r.w * r.h;
}

Ansatz: Variablen und Funktionen kombinieren

Mit der zweiten Idee kommt man schon weiter. Für ein zweites Rechteck benötigt man nur eine zusätzliche Variable. Kann man auch "structs" in "structs" haben, hat man schon genug um komplizierte Datenstrukturen aufzubauen.

Allerdings sind die Daten (das Rechteck) und der bearbeitende Code (die Funktion "size") noch immer getrennt. Hat man ein grösseres Programm mit hunderten von Funktionen und Strukturen, wird es ganz schön schwierig, die richtige Funktion für eine Struktur zu finden.

So ist die nächste Idee, den Code um die Daten zu bearbeiten, ebenfalls in die Struktur zu stecken. Das nennt man dann Klasse.

// die Klasse "Rectangle"
class Rectangle{
  // die Daten dieser Klasse
  int w;
  int h;

  // Der Code um mit den Daten dieser Klasse zu arbeiten
  int size(){
    return w * h;
  }
};

Definition

Eine Klasse ist eine Struktur bestehend aus Attributen (auch "Daten", "Variablen" oder "Werte"), und Methoden (auch "Funktionen" oder "Operationen")

Die Attribute definieren den Zustand einer Instanz einer Klasse "Das Attribut h (Höhe) des Rechteckes hat den Wert 8".

Die Methoden definieren das Verhalten einer Klasse "Mit der Methode size() kann man die Fläche ausrechnen lassen".

Klassen können von anderen Klassen erben. Sie erhalten sämtliche Eigenschaften einer anderen Klasse, können eigene Eigenschaften hinzufügen oder alte Eigenschaften abändern.

Zur Laufzeit werden Instanzen (oder Objekte einer Klasse erstellt).

Typen von Klassen

In Java sind verschiedene Arten von Klassen bekannt.

Normale Klasse

...ist eine Klasse, die ein in sich abgeschlossenes Objekt repräsentiert. Der übliche Bauplan eines Objektes also.

public class MyClass {
   private int i;

   public MyClass(int i) {
      this.i = i;
   }

   public void sum(int i) {
      this.i += i;
   }

   public int getSum() {
      return this.i;
   }
}

Der Compiler erzeugt aus dieser Java-Datei eine Bytecode-Datei namens MyClass.class.

Daneben gibt's dann aber noch vier verschiedene Typen von...

Geschachtelte (innere) Klassen

In Java lassen sich Klassen in Klassen schachteln. Alle Typen dieser Form von Klassen haben also eine Gemeinsamkeit: sie sind innerhalb einer umschließenden Klasse definiert.

Elementklasse

Die Elementklasse ist als ein Element einer äußeren Klasse gekapselt.

public class MyClass {
   private int i;
   private MyInnerClass mic;
   
   public MyClass(int i) {
      this.i = i;
      mic = new MyInnerClass();
      mic.doSomething();
   }
   
   public void sum(int i) {
      this.i += i;
   }
   
   public int getSum() {
      return this.i;
   }
   
   class MyInnerClass {
      void doSomething() {
         sum(2);
         System.out.println("MyInnerClass: "+getSum());
      }
   }
}

Der Compiler erzeugt aus dieser Java-Datei zwei Bytecode-Dateien:

• MyClass.class
• MyClass$MyInnerClass.class

Lokale Klasse

Die lokale Klasse ist in einem Block, z.B. einer Methode gekapselt.

public class MyClass {
...

   public void somethingToDo {

      class MyInnerClass {
         void doSomething() {
            System.out.println("MyInnerClass");
         }
      }
   }
...
}

Anonyme Klasse

Die anonyme Klasse ist eine lokale Klasse, die an keine definierte Referenz gebunden ist. Sie hat also keinen Namen.

public class MyClass {
...

   public void somethingToDo {

      new MyInnerClass() {
         void doSomething() {
            System.out.println("MyInnerClass");
         }
      };
   }
...
}

Schnittstelle

Die Schnittstelle, oder auch static geschachtelte Klasse, verhält sich wie Klassenmethoden bzw. Klassenvariablen