Konstruktoren

• Anwendung von Konstruktoren
• Standardkonstruktor

Ohne Konstruktor

class Coordinates2D {
    int x;
    int y;
}

// Verwendung
c1 = new Coordinates2D();
c1.x = 5;
c1.y = 1;

Objekt wird zuerst erzeugt, dann werden die Attribute initialisiert

Mit Konstruktor

class Coordinates2D {
    int x;
    int y;

    Coordinates2D(int pX, int pY) {
        x = pX;
        y = pY;
    }
}

// Verwendung
c1 = new Coordinates2D(5, 1);

• Konstruktor intialisiert das erzeugte Objekt
• Konstruktor hat keinen Rückgabewert

Standardkonstruktor

• Nur wenn kein eigener Konstruktor definiert wird erstellt der Compiler einen Standardkonstruktor
• Der Standardkonstruktor
  • akzeptiert keine Parameter
  • hat einen leeren Methodenrumpf

For a fistful of keywords…

• Sichtbarkeit
• this
• static

Sichtbarkeit

public class Coordinates2D {
    private int x;
    private int y;

    public Coordinates2D(int pX, int pY) {
        x = pX;
        y = pY;
    }
}

• private: Nur aus Objekten der selben Klasse sichtbar
• public: Keine Einschränkung der Sichtbarkeit
• Später noch weitere Abstufungen der Sichtbarkeit

Shadowing

public class Shadowing {
    private String s = "Attribute";

    public void printString(String s) {
        System.out.println(s);
    }

    static public void main(String[] args) {
        new Shadowing().printString("Parameter");
    }
}

• Was passiert?

„This“ is madness

public class Coordinates2D {
    private int x;
    private int y;

    public Coordinates2D(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

• this bezieht sich immer auf das aktuelle Objekt
• Wenn kein Empfänger angegeben ist, wird this verwendet
• Vorher werden aber lokale Variablen in Betracht gezogen!

Statische Member

public class Coordinates2D {
    private int x;
    private int y;
    private static int count = 0;

    public Coordinates2D(int x, int y) {
        this.x = x;
        this.y = y;
        count++;
    }

    public static int getCount() { return count; }
}

// In the meantime somewhere else
Coordinates2D.getCount();

• Werden auch Klassenattribute bzw. -methoden genannt
• Können an Objekten und der Klassse selbst aufgerufen werden
• Können nicht auf reguläre Attribute zugreifen
• Sehr sparsam einsetzen, wenn überhaupt! Meist ist eine bessere „objektorientiertere“ Lösung möglich

Methoden

• Signatur
• Getter und Setter
• Überladen

Methodensignatur

public class Poser {
    public String getShowOffString(String noun) {
        return String.format("Look at my %1$s, my %1$s is amazing!", noun);
    }
}

• Die Signatur besteht aus
  • Name der Methode
  • Anzahl, Typ und Reihenfolge der Parameter
  • Rückgabetyp

Getter und Setter

public class Coordinates2D {
    private int x;
    private int y;

    // Constructor goes here

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    // Getter and Setter for y go here
}

• Zugriffskontrolle (Datenkapselung)
• Formatierung von Werten (Getter)
• Validierung von Werten (Setter)
• void steht für „Kein Rückgabewert“

Überladen - Konstruktoren

public class Coordinates2D {
    private int x;
    private int y;

    public Coordinates2D(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public Coordinates2D() {
        this(0, 0);
    }
}

• Mehrere Konstruktoren mit unterschiedlichen Parameterlisten möglich

Überladen - Methoden

public class FatOrangeCat {
    private String lastMeal;

    public void eat(String food) {
        lastMeal = food;
    }

    public void eat() {
        lastMeal = "Lasagna";
    }
}

• Methodenvarianten mit unterschiedlicher Signatur (aber gleichem Namen)
• Vorsicht: Methoden dürfen sich in Java nicht nur im Rückgabetyp unterscheiden

Main-Methode auf den zweiten Blick

public class DoesNotMatter {
    public static void main(String[] args) {
        // Method body here
    }
}

• Jetzt Alles klar?