Welche Attribute kommen in den Konstruktor?

[GregDev]

Hallo Community,

ich habe eine kleine Anfänger Frage bei der ich mir oft sehr unsicher bin. Und zwar welche Attribute kommen in den Konstruktor und welche sollten über Methoden übergeben werden.
Angenommen es gibt zwei Klassen: Auto und Main

public class Auto {
    private int strecke, benzinstand;
    
    public Auto(int strecke, int benzinstand) {
        this.strecke = strecke;
        this.benszinstand = benzinstand;
        // Weiterer Code
    }
    
    public getStrecke() {
        return strecke;
    }
}

public class Main {
    Auto auto;
    public Main() {
        auto = new Auto(5, 5);
        System.out.println(auto.getStrecke());
    }
}

Oder die Auto Klasse so:

public class Auto {
    private int strecke, benzinstand;
    
    public Auto() {
        // Weitere Code
    }
    
    public getStrecke() {
        return strecke;
    }

    public setStrecke(int strecke) {
                this.strecke = strecke;
    }
}

Viele Grüße

 

[yfons123]

was ist denn der unterschied zwischen den Auto klassen

was kann man tun mit der 2ten klasse und was kann man tun mit der ersten im vergleich

 

[mihe7]

Das ist auch nicht immer so eindeutig. Der Konstruktor dient dazu, das Objekt zu initialisieren, so dass es in einem sinnvollen Zustand ist. Was man als sinnvoll erachtet, liegt ein Stück weit in der Entscheidungsfreiheit des Entwicklers.

Der Code, den Du hier zeigst, erfüllt unterschiedliche Aufgaben: die erste Klasse beschreibt unveränderliche (immutable) Auto-Objekte, während die zweite Klasse Änderungen zulässt.

Du kannst Konstruktoren auch überladen und in einem Konstruktor einen anderen aufrufen:

public class Auto {
    private int strecke, benzinstand;
    
    public Auto() {
        this(0, 0);
    }

    public Auto(int benzinstand) {
        this(0, benzinstand);
    }

    public Auto(int strecke, int benzinstand) {
        this.strecke = strecke;
        this.benzinstand = benzinstand;
    }
    
    public getStrecke() {
        return strecke;
    }

    public setStrecke(int strecke) {
        this.strecke = strecke;
    }
}

 

[KonradN]

Auf die eigentliche Frage ist @mihe7 schon gut eingegangen. Evtl. als weiterführender Hinweis der wichtig wird für komplexere Klassen:

So ein Konstruktor kann bei komplexen Klassen natürlich recht umfangreich werden. Hier kann es ggf. unübersichtlich werden und da kommen dann weitere Optionen ins Spiel, die man ggf. bedenken kann:

a) Factory Methoden. Du stellst Dann nicht (nur) Konstruktoren zur Verfügung sondern erstellst dann Methoden, die dafür zuständig sein. Diese sind dann statisch und erstellen eine Instanz und geben diese zurück. Ein Vorteil kann z.B. sein, wenn zwei Parameter den gleichen typ haben und es macht Sinn nur den einen oder nur den anderen anzugeben. Die Konstruktoren wären dann nicht zu unterscheiden, aber diese Methoden könnten dann helfen a.la. createWithStrecke, createWithBenzinstand.

b) Wenn man mehrere Parameter hat und viele Kombinationen erlauben will/muss, dann wird das natürlich unübersichtlich. Wie viele Konstruktoren oder Factory Methoden willst Du schreiben? Hier kommt dann schnell das Builder Pattern in Spiel. Du hast eine weitere Klasse, die die möglichen Werte umfassen kann. Diese haben alle den Default Wert des Attributs. Und eine statische Methode builder() gibt Dir eine Instanz dieser Builder Klasse. Dann hast Du viele Setter, die aber alle diesen Builder zurück geben. Und es gibt eine Methode build, die dann die eigentliche Instanz erzeugt. Und dazu gibt es dann in der klasse einen nicht öffentlichen Konstruktor, der einen Builder als Parameter hat.

Also nur mit einem Element skizziert sähe das so aus:

public class Auto {
    private Auto (AutoBuilder builder) {
        strecke = builder.strecke;
    }
    
    static class AutoBuilder {
        int strecke = 0;
    
        public AutoBuilder withStrecke(int strecke) {
            this.strecke = strecke;
            return this;
        }
        
        public Auto build() {
            return new Auto(this);
        }
    }
    
    public static builder() {
        return new AutoBuilder();
    }
}

Und nutzen kann man das dann in der Art:

Auto meinAuto = Auto.builder()
                .withStrecke(19)
                .withHersteller("BMW")
                .withBenzinstand(57)
                .withSitzplätze(7)
                .build();

Sowas kann man selbst schreiben oder man kann sich sowas auch generieren lassen, also z.B. mit Lombok.

 

[GregDev]

Ah ok. Danke erstmal. Das ist sehr interressant, daher es wie schon @mihe7 gesagt hat diese Entscheidung bei dem Entwickler liegt. Und ich deshalb keine eindeutige Lösung gefunden haben, jetzt aber dank euch weiß, dass es auch keine eindeutige Lösung gibt.

Der Satz "Der Konstruktor setzt die Variable in einen nutzbaren Zustand" sehr hilfreich, so kann man schon ein wenig filtern.

Das Prinzip des Überladens war mir noch nicht so bewusst, macht in Nachhinein aber sehr viel Sinn.
Und auch das nutzen von Buildern ist sehr raffiniert.

Danke euch beiden. Ich glaube meine Frage hätte sich damit beantwortet.
Viele Grüße.

 

[temi]

Der Satz "Der Konstruktor setzt das Objekt in einen nutzbaren Zustand" sehr hilfreich

Das ist auch die wichtigste Aussage gewesen.

Danach ist die Regel, dass der Konstruktor nicht zu viele Parameter haben sollte, um nicht unübersichtlich zu werden. Dazu können Parameter in Gruppen zusammenfasst werden (z. B. anstatt von zwei int Werten x und y wird der Typ Point verwendet) oder man verwendet das Builder-Pattern. Beim Builder-Pattern gilt auch wieder die erste Regel, so dass man für das Objekt unbedingt notwendige Parameter direkt der builder() Methode mit gibt. Alle weiteren Parameter sind dann optional.