Navigation überspringen

Konstruktor vs. setter / getter

Ziele

In diesem Kapitel geht es darum, Instanzen zu deklarieren. Instanzen sind konkrete Objekte einer Klasse, die zur Laufzeit generiert werden. Instanzen sind vollständig beschrieben durch ihre Attribute und Fähigkeiten (Methoden).  Diese beiden Klassen-Merkmale müssen festgelegt werden. Dafür stehen drei Grundsätze zur Verfügung.

  1. direktes deklarieren
  2. setter- und getter-Methoden
  3. Konstruktoren

 

Textseite

direktes deklarieren

public class ClassA {
    public static void main(String[] args) {
        ClassB klasseB = new ClassB();
        klasseB.nameClassB = "Test";
        klasseB.laufzeitClassB = 8;
    }
}
class ClassB{
    public String nameClassB;
    public int laufzeitClassB;
}

In ClassA ist die main() Methode enthalten. In dieser Methode wird die ClassB instaziert mit klasseB. Die Attribute in klasseB werden nach der Instanzierung durch direkten Attributaufruf deklariert. Dafür müssen die Attribute in ClassB mindestens als protected modifiziert sein.

Vorteile Nachteile

sehr einfache Programmierung

simple Implementierung

Kein Schutz bzw. keine Kapselung

 

 

setter- und getter-Methoden

public class ClassA {
    public static void main(String[] args) {
        ClassB klasseB = new ClassB();
        klasseB.setNameClassB("Test");
        klasseB.setLaufzeitClassB(8);
    }
}
class ClassB{
    private String nameClassB;
    private int laufzeitClassB;
    public void setNameClassB(String nameClassBSet){
        this.nameClassB=nameClassBSet;
    }
    public String getNameClassB(){
        return this.nameClassB;
    }
    public void setLaufzeitClassB(int laufzeitClassBSet){
        this.laufzeitClassB=laufzeitClassBSet;
    }
    public int getLaufzeitClassB(){
        return this.laufzeitClassB;
    }
}

Die Attribute werden nun mittels setter-Methode deklariert. Hier kommt das Prinzip der Kapselung der objektorientierten Programmierhaltung. Gekapselt sind die Attribute durch den Modifizierer private. Das heißt, dass die Attribute durch direktes deklarieren nicht weiter zugänglich sind.

Vorteile Nachteile

Attribute sind geschützt und können nur durch den setter-Methoden änderbar

Die setter-Methoden können durch Fehlerauswertung, Kontrollinstanzen erweitert werden, damit willkürliche Attributbelegung verhindert wird.

komplexere Programmierung

umfangreicherer Quelltext


Konstruktoren

der Ausdruck

ClassB klasseB = new ClassB();

aus der main()-Methode instanziert klasseB aus der Klasse ClassB. Hierbei ruft der new-Operator den Konstruktor von ClassB auf. In den obigen Beispielen wird kein eigener Konstruktor definiert, also wird der default Konstruktor aufgerufen. Das erkennt man an den leeren Klammern von Class(). Es wird kein Parameter übergeben. Der Java Compiler fügt stillschweigend den Konstruktor hinzu:

class ClassB{
    private String nameClassB;
    private int laufzeitClassB;
    public ClassB(){
        //leer = default Constructor
    }
}

Diesen Konstruktor können wir mit Inhalt füllen und somit die Kapselung weiter verstärken. Dieser Zusammenhang wird plausibel, weil Konstruktoren nur einmal zum Instanzieren aufrufbar sind. Sämtliche Attribute, die nur über mit Konstruktor deklariert werden können, bleiben zur Laufzeit fix.

public class ClassA {
    public static void main(String[] args) {
        ClassB klasseB = new ClassB("Test",8);
        System.out.println(klasseB.getNameClassB()); //Ausgabe Test
    }
}
class ClassB{
    private String nameClassB;
    private int laufzeitClassB;
    public ClassB(String nameClassBSet,int laufzeitClassBSet){
        this.nameClassB = nameClassBSet;
        this.laufzeitClassB = laufzeitClassBSet;
    }
    public String getNameClassB(){
        return this.nameClassB;
    }
    public int getLaufzeitClassB(){
        return this.laufzeitClassB;
    }
}


 

Vorteile Nachteile

Attribute sind vollständig geschützt

Es können weiterhin setter-Methoden erzeugt werden

vollständig objektorientierter Ansatz

komple Programmierung

umfangreicher Quelltext