Erste Schritte Konstruktor - wie genau funktioniert der Code?

[Sendo - Takeshi]

Guten Tag,
ich arbeite gerade das Thema unserer Vorlesung nach und stoße dabei auf einige Schwierigkeiten. Ich habe zwar schon die Lösung zu der Aufgabenstellung, allerdings verstehe ich nicht, wie genau die Lösung (Konstruktor) abläuft bzw. was genau in der Anwendung vorgeht und hoffe, dass mir jemand dabei etwas helfen könnte. Die Aufgabenstellung ist folgende:
"Entwickeln Sie eine Klasse, welche einen Ziegelstein darstellt mit drei double Attributen: die Abmessungen x, y, z. Die Klasse soll einen Konstruktor besitzen mit Hilfe dessen alle diese Attribute initialisiert werden können und eine Methode volume()zur Berechnung des Volumens des Ziegelsteins."

Eine Lösung die uns vorgestellt wurde, ist diese:

package Uebungsblatt06;

 public class uebung06_02 {
     public static void main(String[] args) {

         Brick meinBrick = new Brick();

         System.out.println("Ihr erster initialisierter Wert ist " + meinBrick.x);
         System.out.println("Ihr zweiter initialisierter Wert ist " + meinBrick.y);
         System.out.println("Ihr dritter initialisierter Wert ist " + meinBrick.z);
         System.out.println("Ihre initialiserten Werte ensprechen ein Volumen von: " + meinBrick.berechneVolumen());
     }
 }

 class Brick {
     
     Brick() {
         x = 1.9;
         y = 2.5;
         z = 1.2;
     }

     double x; double y; double z; double preis; double volumen;

     double berechneVolumen() {
         return this.volumen = x * y * z;
     }
 }

Leider muss ich zugeben, das ich gar nicht erkenne, wo genau hier der "Konstruktor" liegt? Ebenso verwirrt mich folgende Codezeile "Brick meinBrick = new Brick();"
Ich hoffe jemand kann mir etwas Licht in diesen "düsteren" Code bringen, sodass ich ihn leichter verstehen und eventuel ähnliches selbst erstellen könnte!

Vielen Dank im Vorraus!

 

[SlaterB]

das gibt es nicht viel zu erkennen oder zu verstehen,
die aller ersten Grundlagen sind eigentlich reines Lernen,

ein Konstruktor ist das was einer Methode ähnelt, nur ohne Rückgabewert und wie die Klasse heißt,
meist recht früh in der Klasse, hier Zeile 17,

das hätte dir ein Lehrbuch oder irgendein Standardbeispiel auch gesagt, oder was genau weißt du denn ansonsten über Konstruktoren?
wenn du dafür 15 Min. einen Forum-Eintrag schreiben musst..

Galileo Computing :: Java ist auch eine Insel - 5 Eigene Klassen schreiben

 

[faetzminator]

Der Konstruktor ist [c]Brick() { ... }[/c], dieser wird bei Erstellung eines Bricks [c]new Brick()[/c] aufgerufen. Zeile 6 erstellt also einen neuen Brick und weist ihn der Variable [c]meinBrick[/c] des Types [c]Brick[/c] hinzu.
Du kannst auch Konstruktoren mit Parametern erstellen:

Brick(int x) {
    this.x = x; // speichere den Parameter x in dem gleichnamigen Attribut x
    y = 53;
    z = 34.1;
}

 

[akimoon]

Konstruktoren erkennst du immer daran, dass sie keinen Rückgabetyp haben und den Namen der Klasse tragen. In diesem Fall wäre dies

 Brick()

.

Mit

new  Brick();

wird genau dieser Konstruktor aufgerufen, und ein Brick-Objekt erzeugt.
Anschließend wird dieser mit Brick

Brick meinBrick = new Brick();

der Variablen meinBrick zugeordnet, welche den Typ Brick hat

Typ variablenname =

--->
meinBrick referenziert auf das Brick-Objekt, das mit

new Brick();

erzeugt wurde.

Hoffe das ist halbwegs verständlich so?

 

[irgendjemand]

mal davon abgesehen : wann das der "lösungsvorschlag" sein soll .. dann ist das aber ein verdammt schlechter ...

ich hätte im "null"-konstruktor überhaupt keine werte gesetzt sondern einen zweiten mit parametern verwendet *so wie ichs aus der aufgabenstellung auch gelesen habe* ..

dann ist zeile 23 ja mal totaler murks ... der der das geschrieben hat sollte sich vllt selbst noch mal ins 1te semester setzen ...

auch sollte man getter/setter verwenden statt public-fields ...


alles in allem sehr schwammige lösung

 

[Sendo - Takeshi]

Vielen Dank für die Antworten!
Ich konnte ein paar der Aussagen mit meinen Sprict abgleichen und dadurch schon einiges mehr über den Code in Erfahrung bringen wie ich z.B. die Parameter im Klassen/Konstrukterbereich verschieben bzw. ändern kann. Die Methode mit ihren Rückgabewert ist ebenfalls verständlich sowie auch die Ausgabe und wie ich die Werte abrufe.

Allerdings habe ich noch immer ein Problem mit der Zeile

Brick meinBrick = new Brick();

Ich hatte vor, ein eigenes Beispiel zu erstellen was diesen hier sehr ähnlich sieht: Ich habe wieder etwas mit 3 Werten ausgewählt (in diesenFall eine heizung). Theoretisch hätte ich das Problem mit Copy + Paste lösen können indem ich einfach nur die Namen umbenenne. Das wäre aber schwachsinn, weswegen ich alles neu getippt hatte mit hilfe meines Scriptes aber nicht wusste, wie ich die oben benannte Zeile ändern müsste, dass das Programm läuft? Irgendwo oder irgendwie habe ich noch einen knick im Gehirn das ich nicht den Ansatz verstehe was ihr mir versucht habt zu erklären

Wenn ich es richtig verstanden habe, ist der 0815 Konstruktor "heizung" unten erstellt, aber es fehlt dem Programm noch der Befehl das er ihn auch aufruft/benutzt ist das richtig?

package uebung6;

public class testaufgabe2 {



	public static void main(String[] args) {
	       
	    	   
		
       System.out.println("erster Wert " + heizung.x);
       System.out.println("zweiter Wert" + heizung.y);
       System.out.println("dritter Wert" + heizung.z);
       
       class heizung{
    	   
    	   heizung(double x, double y, double z){
    		   x = 2.5;
    		   y = 2;
    		   z = 0.5;
    	   		} 
       		}
    }
}

Werde auch gleich einen Blick in der Buch werfen. Hoffe ich finde im Kapitel "5.5.1 Konstruktoren schreiben" die Lösung für das Problem.

 

[erster]

aber es fehlt dem Programm noch der Befehl das er ihn auch aufruft/benutzt ist das richtig?

Richtig erkannt du das hast^^.

Mit Hilfe eines Konstruktors wird eine Instant einer Klasse erstellt und mit (Standard-)Werten belegt. D.h. im Fall deines Ziegelsteines: mit

Brick meinBrick = new Brick();

erstellst du einen neuen Ziegelstein mit Namen meinBrick (das ist genau genommen nicht der Name des Steines sondern nur der Refenerenz auf eben diesen einen Stein). Willst du ein Steinchen mit bestimmten Maßen neu anlegen, musst du sowas verwenden wie

Brick andererBrick = Brick(1.0, 2.0. 3.0)

.

Das selbe kannst du mit deiner Heizung machen:

Heizung myHeizung = new Heizung(...)

. Damit sagst du also dem Compiler, dass du eine neue Heizung bauen willst, die die in der Klammer angegeben Eigenschaften besitzt...


Hoffe, das war vertsändlich^^

 

[akimoon]

Was mir noch auffällt:
Du musst aufpassen, dass du eine Klasse nicht in eine andere Klasse oder eine Methode schreibst.
Das sollte so aussehen:

public class 1 { ..
...
}
class 2 {
...
}

 

[bygones]

Was mir noch auffällt:
Du musst aufpassen, dass du eine Klasse nicht in eine andere Klasse

public class Outer {
   private Inner inner = new Inner();

   // methoden von Outer

   class Inner() {
     // alles von Inner
   }
}

innerhalb einer Klasse geht - innerhalb einer Methode dann als anonyme Klasse

 

[Sendo - Takeshi]

Langsam aber sicher kommen wir der Lösung immer näher : )

Ich hatte sogar folgendes bereits im Programmcode stehen

heizung heizung1 = new heizung();

allerdings wurde mir von Eclipse gesagt, dass er so nicht arbeiten kann, aufgrund eines "compilation problem" weswegen ich die Idee wieder verworfen hatte aber scheinbar ging sie doch in die richtige Richtung.

 

[erster]

allerdings wurde mir von Eclipse gesagt, dass er so nicht arbeiten kann, aufgrund eines "compilation problem" weswegen ich die Idee wieder verworfen hatte aber scheinbar ging sie doch in die richtige Richtung.

Weil du schlichtweg keinen Konstruktor hast, der Heizung() heißt, sondern nur einen, der Heizung(double, double, double) heißt. Du müsstest also einen leeren Konstruktor ohne Argumente erstellen (um z.B. einige Standardwerte für die Heizung zu verwedenen bietet sich dieser an)

 

[Mikrowelle]

Noch ein Tip, Klassen Namen schreibt man groß.

class Heizung....
class TestAufgabe..

 

[Sendo - Takeshi]

Weil du schlichtweg keinen Konstruktor hast, der Heizung() heißt, sondern nur einen, der Heizung(double, double, double) heißt. Du müsstest also einen leeren Konstruktor ohne Argumente erstellen (um z.B. einige Standardwerte für die Heizung zu verwedenen bietet sich dieser an)

Tut mir leid, aber ich habe Schwierigkeiten das zu verstehen. Meinst du, ich muss den Absatz

            Heizung(double x, double y, double z){
                x = 2.5;
                y = 2;
                z = 0.5;
                 }

wiefolgt umändern

Heizung(){

}

Ansonsten verstehe ich leider nicht, wie ich mein Projekt umändern müsste, damit es Funktionieren kann : (

@Mikrowelle
Danke für den Ratschlag, habe die Namen abgeändert.

 

[Crian]

Generell geht da noch viel durcheinander. Am besten wäre es, du liest dir das Thema in einem guten Buch (Insel z.B.) durch, ich sage trotzdem ein wenig dazu:

Bei deiner Heizungsklasse

[java=15] class heizung{

heizung(double x, double y, double z){
x = 2.5;
y = 2;
z = 0.5;
}
}[/code]

fehlen der Klasse die Attribute. Du übergibst dem Konstruktor drei Werte, die werden dann umbelegt und es wird nichts mehr damit gemacht.

Schritt 1 (inklusive Großschreibung):

public class Heizung {

    private double x;
    private double y;
    private double z;

    public Heizung(double x, double y, double z) {
        this.x = x;
        this.y = y;
        this.z = z;
    } 

    public Heizung() {
        x = 2.5;
        y = 2;
        z = 0.5;
    }

}

Jetzt hat die Klasse Heizung drei Attribute x, y und z und zwei Konstruktoren. Der erste bekommt drei Werte übergeben, mit denen die Attribute befüllt werden, der zweite bekommt keine Werte, sondern initialisiert die Heizung mit Standardwerten.
Um hier die Attribute der Klasse und die übergebenen Werte zur Initialisierung auseinanderhalten zu können, wird "this." verwendet.

Beide Konstruktoren sind von außen zu verwenden ("public"), auf die Attribute soll von außen aber keiner Zugriff haben, deshalb sind sie als privat markiert ("private").

Schritt 2: Damit man von außen zumindest die Werte der Heizung ablesen kann, schreiben wir Getter für die Werte:

public class Heizung {

    private double x;
    private double y;
    private double z;

    public Heizung(double x, double y, double z) {
        this.x = x;
        this.y = y;
        this.z = z;
    } 

    public Heizung() {
        x = 2.5;
        y = 2;
        z = 0.5;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public double getZ() {
        return z;
    }

}

Soweit klar?

Ein Aufruf von außen könnte dann so aussehen:

public class HeizungTesten {

    public static void main(String[] args) {
        // Ein Heizungsobjekt erzeugen:
        Heizung h1 = new Heizung();

        // Ein anderes Heizungsobjekt erzeugen:
        Heizung h2 = new Heizung(17.3, 22.6, 2.5);

        // Werte ausgeben:
        System.out.println("Heizung 1: x=" + h1.getX() + ", y=" + h1.getY() + ", z=" + h1.getZ());
        System.out.println("Heizung 2: x=" + h2.getX() + ", y=" + h2.getY() + ", z=" + h2.getZ());
    }

}

Vielleicht macht das die Sache klarer?

P.S. Ungetestet, Eclipse ist gerade beschäftigt....

 

[Sendo - Takeshi]

Vielen Dank für die Geduld!

Die große Auflistung hat noch ein paar ungereimtheiten aufgeklärt =)

Werd noch bisschen daran basteln um das ganze etwas zu festigen aber ich denke die nächste Aufgabe sollte ich vorerst alleine schaffen : )

 

[Crian]

Die große Auflistung hat noch ein paar ungereimtheiten aufgeklärt =)

Das freut mich. Viel Erfolg!

 

[faetzminator]

Statt

public Heizung() {
   x = 2.5;
    y = 2;
    z = 0.5;
}

Könnte man dort auch den zweiten Konstruktor aufrufen, also so:

public Heizung() {
    this(2.5, 2, 0.5);
}

Das macht vor allem Sinn, wenn man zig Konstruktoren hat, bei welchen einer der Master ist:

// erstellt eine Person
public Person(String name, String vorname) {
    // "Masterkonstruktor", setzt die Variablen, validiert, ...
    // ...
}

// erstellt einen Peter
public Person(String name) {
    this(name, "Peter");
}

// erstellt einen Peter Müller
public Person() {
    this("Müller");
}

Wenn ich nun einen Peter Müller mit dem dritten Konstruktor erzeuge, ruft dieser den zweiten und der zweite wiederum den ersten auf. Somit muss ich Standardparameter nicht mehrfach angeben - auch wenn diese meist als Konstanten ausgelagert werden.