Klassen und Objekte

Grundlagen

public class Song { 
    // statisches Feld 
    private static int meinStatischesFeld; 
 
    // unveränderliches Feld. Muss spätestens im Konstruktor gesetzt werden 
    // und kann dann nicht mehr geändert werden 
    private final int answer = 42; 
 
    // Konstanten werden üblicherweise in Grossbuchstaben geschrieben 
    public static final double PI = 3.1415926; 
 
    // Feld 
    public String titel; 
    private int volume; 
 
    // Statische Methode 
    public static int getStaticField () { 
        return meinStatischesFeld; 
    } 
 
    // Konstruktor: Kein Rückgabewert! 
    public Song() { 
        this.titel = "Kein Titel"; 
        this.volume = 0; 
    } 
    // öffentliche Methode, die nichts zurückgibt (void) und als Parameter eine Zahl (int) entgegennimmt 
    public void setVolume ( int volume ) { 
        this.volume = volume; 
        // Code der die Lautstärke setzt 
    } 
 
    // öffentliche Methode, die die Lautstärke (int) zurückgibt und keine Parameter hat 
    public int getVolume () { 
        return volume; 
    } 
}
  

Song aSong = new Song(); 
aSong.setVolume( 5 ); 
aSong.titel = "Hallo Welt!"; 
System.out.println(aSong.titel); // Gibt "Hallo Welt" aus.

• Klassen sind der Bauplan, mit dessen Hilfe Objekte (mit Hilfe des new Operators) gebildet werden.
• Access Modifier
  • public: Jeder darf von überall her darauf zugreifen
  • protected: Jeder im selben Package und jeder der von dieser Klasse erbt, darf zugreifen
  • (kein Access Modifier): Jeder im selben Package darf zugreifen
  • private: Nur innerhalb der Klasse darf zugegriffen werden.
• Felder enthalten die Daten der Klasse
• Methoden sind die Funktionen der Klasse
• Konstruktoren sind Methoden, die ein Objekt erstellen.
• Hat eine Klasse keinen Konstruktor definiert wird ein Standardkonstruktor automatisch erzeugt.

Vererbung

public class Tier {} 
public class Hund extends Tier {} 
public final class NoChilds {} // von dieser Klasse kann nicht geerbt werden

Die Klasse Hund erbt von der Klasse Tier. Das bedeutet.

• In der Klasse kann ich auf alle public und protected Variablen und Methoden der Klasse Tier zugreifen, als wären sie in der Klasse Hund.
• Mit einem Objekt der Klasse Hund kann ich auch alle öffentlichen Felder und Methoden der Klasse Tier nutzen.
• Methoden der Oberklasse können überschrieben werden. Dazu muss die Signatur der überschreibenden Methode exakt dieselbe sein wie die überschriebene.
• Überschriebene Methoden dürfen öffentlicher sein als das Original
• Eine überschriebene Methode kann aufgerufen werden mit super.methode().
• Achtung: Konstruktoren werden nicht vererbt
• In einem Konstruktor wird der Konstruktor der Oberklasse mit super(…) aufgerufen.
• Wird super im Konstruktor aufgerufen, muss es der erste Befehl sein.
• Ist eine Klasse final deklariert, kann von ihr nicht geerbt werden.
• Ist eine Methode final deklariert, kann sie in der Kindklasse nicht überschrieben werden.
• Jede Klasse kann nur von einer Klasse erben.

Abstrakte Klassen

public abstract class Tier { 
    public abstract String gibLaut(); 
}

• Von einer abstrakten Klasse kann keine Instanz erzeugt werden.
• Eine Klasse die von einer abstrakten Klasse erbt, muss alle abstrakten Methoden implementieren.
• Eine abstrakte Klasse muss keine abstrakten Methoden haben.
• Sobald eine Klasse eine abstrakte Methode hat, muss die Klasse abstrakt sein

Interfaces

public interface Pflanzenfresser { 
    public void friss ( Pflanze futter ); 
}

public class Hund extends Tier implements Pflanzenfresser, Fleischfresser {}

• Interfaces sind abstrakten Klassen ähnlich, die nur abstrakte Methoden hat.
• Eine Klasse kann mehrere Interfaces implementieren. Die Klasse muss dann alle Methoden der Interfaces implementieren.

Innere Klassen

public class Aussen { 
    // Öffentliche statische innere Klasse 
    public static class PublicStaticInnen {} 
 
    // Nichtöffentliche statische innere Klasse 
    private static class PrivateStaticInnen {} 
 
    // Nichtstatische Klasse 
    // Sie hat Zugriff auf Methoden und Felder der Klasse Aussen! 
    public class PublicInnen {} 
    private class PrivateInnen {} 
 
    // Anonyme Klasse. Nur an der Stelle ihrer Erzeugung verfügbar. 
    System.out.println(new Object(){ 
        @Override 
        public String toString() { 
            return "Hello from Anonymous"; 
        } 
    }); 
}

// Ausserhalb der Klasse Aussen (hier sind nur öffentliche Klassen erreichbar!) 
PublicStaticInnen publicStaticInnen = new Aussen.PublicStaticInnen(); 
 
Aussen aussen = new Aussen(); 
PublicInnen PublicInnen = aussen.new PublicInnen(); 
 
// Innerhalb der Klasse Aussen 
PublicStaticInnen publicStaticInnen = new PublicStaticInnen(); 
PrivateStaticInnen privateStaticInnen = new PrivateStaticInnen(); 
PublicInnen publicInnen = new PublicInnen(); 
PrivateInnen privateInnen = new PrivateInnen();

Enumerationen

public enum Kartenfarbe { 
    KARO, HERZ, PIK, KREUZ; 
}

• Der Variablentyp einer Enumeration kann nur die definierten Werte annehmen.

Kartenfarbe herz = Kartenfarbe.HERZ;