OOP Konstruktoren Erklärung

[WalterSobchak]

Hallo,

ich habe ein paar Fragen, die ich mir selbst nicht mit dem Internet ausarbeiten kann. Zum Beispiel:

import java.lang.*;

public class Pool{
  
  double laenge;
  double breite;
  double radius;
  
  
    Pool(double l, double b)
    {
      laenge = l;
      breite = b;
    }


    Pool(double r)
    {
      radius = r;
    }

Warum braucht man den Konstruktor? ich weiß, dass er die Klasse instanziert. Verstehe aber nicht ganz was das bedeutet. Und warum sind in dem Beispiel 2 Konstruktoren?

Außerdem möchte ich wissen, warum man Konstruktoren überlädt. Zum Beispiel:

Radio(String band, int lautstaerke, int kanal){
      if(band.equals("UKW") || band.equals("MW") || band.equals("LW")){
      this.band = band;
    }
       else{
       this.band = "UKW";
       }
       
       if(kanal >= 1 && kanal <= 5)
       {
         this.kanal = kanal;
       }
       else{
         this.kanal = 1;
       }
  }
  
  Radio(String band){
    this(band, 1, 1);
  }

Was hat das für einen Sinn. Am Besten wäre eine leicht verständliche Erklärung.

 

[bygones]

Mit Konstruktoren erstellst du ein Objekt der Klasse, mit dem du dann arbeiten kannst.

Sozusagen die Eingangstuer.

Man kann mehrere Konstruktoren haben wie man mehrere Methoden mit dem selben Namen haben kann, solange sie untersch. Parameter haben. Man hat unterschiedl. Konstruktoren wenn man sein Objekt untersch. instanziieren kann bzw will.

Bei deinem Pool bsp wird einmal das objekt mit laenge und breite erstellt, einmal mit dem radius

 

[WalterSobchak]

@bygones

also erstellt man mit dem Konstruktor schon das Objekt? Und warum schreibt man die Parameter sind gleich die attribute?

 

[langhaar!]

also erstellt man mit dem Konstruktor schon das Objekt? Und warum schreibt man die Parameter sind gleich die attribute?

Ich würde es anders formulieren: Beim Erstellen eines Objektes wird ein Konstruktor aufgerufen. Du kannst auch auf einen Konstruktor verzichten.

Durch Konstruktoren kann sichergestellt werden, dass ein instanziiertes Objekt in einem konsistenten Zustand ist, indem z.B. Instanzvariablen initialisiert werden. Wenn du für dich selbst programmierst, scheint das zunächst nicht so wichtig zu sein, jedoch wenn du Klassen an andere Personen gibts oder fremde Klassen benutzt, gewinnt es an Bedeutung.

Den Satz mit den Parametern sind die Attribute verstehe ich nicht. Wer schreibt denn das?

 

[WalterSobchak]

@langhaar

ok nochmal für mich ganz von vorn und langsam😀

also. So wie ich es bis jetzt verstanden habe: Man hat eine Klasse (Pool). Dort werden Attribute deklariert, also Eigenschaften (laenge, breite, ...). Dann hat man Konstruktoren. Diese haben den selben Namen wie die Klasse. Man kann ihnen Parameter übergeben. Jetzt die Frage

also erstellt man mit dem Konstruktor schon das Objekt? Und warum schreibt man die Parameter sind gleich die attribute?

nochmal verständlich: Man übergibt dem Konstruktor Parameter. Und in dem Konstruktor-Block schreibt ma ja z. B. l = laenge, setzt also den Parameter 'l' gleich laenge. Warum macht man das? Was hat das für einen Sinn?

 

[Camino]

Man übergibt dem Konstruktor Parameter. Und in dem Konstruktor-Block schreibt ma ja z. B. l = laenge, setzt also den Parameter 'l' gleich laenge. Warum macht man das? Was hat das für einen Sinn?

laenge ist das zur Klasse bzw. dem Objekt gehörende Attribut. Damit weist du diesem Attribut den Wert des Parameters l zu, und das neu entstandene Objekt kann nun damit weiter arbeiten...
Das

=

heisst nicht gleich, sondern ist eine Zuweisung.

 

[Plopo]

Im Grunde weist der Konstruktor nur Werte den Klassenvariablen zu, damit diese NICHT "null" sind.
Er legt sozusagen ein Grundgerüst deines Objectes an.
Das Grundgerüst enthält dann Standart Werte:
z.B.
Klasse Auto
Konstruktor legt fest farbe = "schwarz";

Ob du nun die Farbe fest in deinen Code reinschreibst, oder diese über einen Parameter übergibst (Beim erzeugen des Objektes - ist dir überlassen)

Ob du die Werte nun im nachhinein veränderst (mit "getter"-Methoden) oder nicht, ist dir überlassen.

Um es auf dein "Pool-Beispiel" anzuwenden.
Du willst ja keinen Pool bauen (new Pool()) der keine länge/breite/radius hat. Das ergäbe keinen Sinn.
Deshalb gibt es den Konstruktor. Dieser stellt sicher dass du diese Werte angeben MUSST !!! und sie nicht vergisst.
Eine nicht initialisierte Variable kann später zu einer "NullPointerException" führen welche dein Programm einer abschießt.

 

[WalterSobchak]

laenge ist das zur Klasse bzw. dem Objekt gehörende Attribut. Damit weist du diesem Attribut den Wert des Parameters l zu, und das neu entstandene Objekt kann nun damit weiter arbeiten...
Das = heisst nicht gleich, sondern ist eine Zuweisung.

Ok habe mich gerade nochmal ein wenig in Instanzvariablen eingelesen.

Man könnte praktisch auch

    Pool(double l)
    {
      laenge = l;
      breite = 30;
    }

schreiben. Also werden dort die die Instanzvariablen initialisiert. Heißt

breite = 30;

dass die Instanzvariable breite dauerhaft auf 30 gesetzt wird? und was, wenn ich noch einen Konstruktor

Pool(double b)
    {
      laenge = 30;
      breite = b;
    }

Was bedeutet es genau, wenn ich 2 Konstruktoren schreibe? Kann ich dann 2 verschiedene Instanzen erzeugen z. B. so

Pool p1 = new Pool(30)

Wenn es so ist, wie erkennt der Compiler dann, welchen Kosntruktor er nehmen soll?

 

[langhaar!]

Man übergibt dem Konstruktor Parameter. Und in dem Konstruktor-Block schreibt ma ja z. B. l = laenge, setzt also den Parameter 'l' gleich laenge. Warum macht man das? Was hat das für einen Sinn?

Du möchtest doch, dass dein Pool irgendwelche konkrete Werte hat.
Z.B. 10 Meter lang, 3 Meter breit.

Das muss an irgendeiner Stelle zugewiesen werden.
Wenn du ein Objekt Pool anlegst, bist du durch den Kontruktor gezwungen, diese Werte mitzugeben.

Pool meinPool = new Pool(10,3);

Falls du aber einen runden Pool hast, machen Länge und Breite keinen Sinn.
Also geht auch:

Pool meinPool = new Pool(12);

Das ergibt einen Pool, bei dem der Radius gesetzt ist.

Was bedeutet es genau, wenn ich 2 Konstruktoren schreibe? Kann ich dann 2 verschiedene Instanzen erzeugen z. B. so

Pool p1 = new Pool(30)

Wenn es so ist, wie erkennt der Compiler dann, welchen Kosntruktor er nehmen soll?

Du kannst immer mehrere Instanzen erzeugen. Du kannst mit 2 Konstruktoren die Instanzen auf verschiedene Arten erzeugen.

Konstruktoren müssen immer verschiedene Signaturen haben; d.h., die Parameter müssen sich unterscheiden. Du kannst nicht 2 Konstruktoren mit einem Double als Parameter machen, aber z.B. ein Konstruktor mit einem Double und einen weiteren mit 2 Double Parametern.

 

[Camino]

Die Parameterlisten der Konstruktoren müssen unterschiedlich sein, also eindeutig, damit klar ist, welchen Konstruktor du meinst. Es geht also nicht, dass du zwei Konstruktoren mit jeweils 1 double-Wert hast.

 

[WalterSobchak]

Die Parameterlisten der Konstruktoren müssen unterschiedlich sein, also eindeutig, damit klar ist, welchen Konstruktor du meinst. Es geht also nicht, dass du zwei Konstruktoren mit jeweils 1 double-Wert hast.

Ach ok danke. Und wenn man verschiedene Parametertypen übergibt. z. B. ein Konstruktor mit 2 int und ein Konstruktor mit einem int und einem String? Müsste ja auch gehen, da sie sich ja dann unterscheiden.


Die Instanzvariablen können also immer wieder verwendet werden und sind quasi eine Schablone für die Paramter in einem Konstruktor, es sei denn man initialisiert sie auf feste Werte wie z .B.

public class Pool{
    double laenge = 30;
    double breite = 30;
}

?

Und was passiert wenn ich einer Instanzvariable in einem Konstruktor einen festen Wert zuweise (z. B. 30)

public Pool(double l){
    breite = 30;
    laenge = l;
}

Liegt der Unterschied darin, dass im obigen Beispiel der Wert für jedes Objekt konstant ist und im Unteren der Wert nur für Objekte dieses Konstruktors konstant ist?

Und tut mir Leid, dass das hier ein wenig Anstrengend ist. Aber ich möchte es halt wirklich verstehen.

 

[faetzminator]

Also, stellen wir uns vor, du hast folgende Klasse:

public class Pool {

    // da diese Felder final sind, müssen sie in einen Konstruktor gesetzt werden!
    private final double laenge;
    private final double breite;

    public Pool(double l, double b) {
        laenge = l;
        breite = b;
    }

    public Pool(double l) {
        this(l, 30); // ruft Pool(double, double) auf
    }

    public Pool() {
        this(20); // ruft Pool(double) auf
    }
}

Da kannst du [c]new Pool()[/c] machen, dieser wird 20 lang und 30 breit sein.
Du kannst aber auch [c]new Pool(123)[/c] aufrufen, dann hast du einen Pool mit Länge 123 und Breite 30.
Oder schlussendlich noch [c]new Pool(1, 2)[/c], dann wird der Pool 1 lang und 2 breit sein.

 

[Camino]

Schau dir am besten nochmal die Themen Klassen- und Objektvariablen an, sowie die Sichtbarkeiten der Variablen (private, public) und die getter- und setter-Methoden (mit denen du die Variablen ändern kannst).

 

[langhaar!]

Die Instanzvariablen können also immer wieder verwendet werden und sind quasi eine Schablone für die Paramter in einem Konstruktor

Das mit der Wiederverwendung verstehe ich nicht.

Eine 1-1 Abbildung von Parametern in einem Kontruktor und Instanvariablen gibt es nicht; also keine Schablone.
Eine Instanzvariable beschreibt den internen Zustands eine Objekts, Instanzvariablen können - aber müssen nicht! - durch Konstruktoren initialisiert werden.
Weiterhin können Instanzvariablen ihren Zustand ändern; der ist nicht auf alle Zeiten festgeschrieben.

Ein Konstruktor kann auch andere Aufgaben durchführen, als Instanzvariablen zu initialisieren (auch wenn dies die Haupaufgabe ist)


Ich rate zu einem Buch, dass du - auch wenn nicht alles sofort klar ist- durcharbeitest, sonst hangelst du dich von Frage zu Frage ohne das Gesamtbild zu sehen.

 

[WalterSobchak]

Also, stellen wir uns vor, du hast folgende Klasse:

public class Pool {

    // da diese Felder final sind, müssen sie in einen Konstruktor gesetzt werden!
    private final double laenge;
    private final double breite;

    public Pool(double l, double b) {
        laenge = l;
        breite = b;
    }
 
    public Pool(double l) {
        this(l, 30); // ruft Pool(double, double) auf
    }

    public Pool() {
        this(20); // ruft Pool(double) auf
    }
}

Da kannst du [c]new Pool()[/c] machen, dieser wird 20 lang und 30 breit sein.
Du kannst aber auch [c]new Pool(123)[/c] aufrufen, dann hast du einen Pool mit Länge 123 und Breite 30.
Oder schlussendlich noch [c]new Pool(1, 2)[/c], dann wird der Pool 1 lang und 2 breit sein.

Ach ok da ist die Sache mit dem Überladen drin. Gutes Beispiel danke.


Naja ich werde euch dann mal nicht weiter nerven😀. Hat mir aber schonmal sehr geholfen in Sachen Verständnis. Also Danke an euch alle.