Embed Size (px)
Citation preview
Konstruktoren
Um beim Anlegen eines Objekts gleichzeitig die
Attribute mit Werten vorzubelegen (initialisieren), gibt es dazu eine besondere
Möglichkeit:
Dies geschieht durch den sogenannten Konstruktor.
Dies ist eine spezielle Methode in der Klasse mit
dem gleichen Namen wie die Klasse, aber ohne einen
Rückgabewert (auch nicht void).
Ein Konstruktor kann (wie jede andere Methode auch) überladen sein, d.h. es kann mehrere Konstruktoren mit dem gleichen Namen, aber verschiedenen Parametern
-bezogen auf die Anzahl und den Datentyp - geben
Konstruktor wird immer dann aufgerufen, wenn ein Objekt der
Klasse instanziert (=angelegt) wird. Da ein und dasselbe
Objekt nur einmal angelegt werden kann, kann für dieses
Objekt auch der Konstruktor nur einmal aufgerufen werden.
Aufgabe:Erzeugen Sie für die uns
bekannte Klasse Hund einen Konstruktor, einmal mit keinem bzw. mit zwei
Parametern.
class Hund{ private String name; private double gewicht;
public Hund(){ name="Musterhund"; gewicht=10; }
public Hund(String pName, double pGewicht){ name=pName; gewicht=pGewicht; }
// restliche get und set-Methoden// wie früher
Konstruktor kann überladen sein
Konstruktor hat keinen (auch nicht void) Rückgabewert.
Anschaulich: Mit dem Konstruktor kann man die Daten des Objekts "formatieren".
Beispiele für das Instanzieren von Objekten:
public class MainKlassen3 { public static void main(String[] args){ Hund myh1, myh2; String n1, n2; double g1, g2;
myh1=new Hund(); myh2=new Hund("Goldi",12); n1=myh1.getName(); g1=myh1.getGewicht(); n2=myh2.getName(); g2=myh2.getGewicht(); }}
Konstruktor ohne Parameter wird mit
Klammer (ohne Parameter) aufgerufen
Konstruktor mit Parameter wird mit Klammern (mit 2
Parametern) aufgerufen
public class MainKlassen3 { public static void main(String[] args){ Hund myh1, myh2; String n1, n2; double g1, g2;
myh1=new Hund(); myh2=new Hund("Goldi",12); n1=myh1.getName(); g1=myh1.getGewicht(); n2=myh2.getName(); g2=myh2.getGewicht(); }}
Welchen Wert hat das Objekt, auf das n1 zeigt?
"Musterhund"
Welchen Wert hat g1?
10
Welchen Wert hat das Objekt, auf das n2 zeigt?
"Goldi"
Welchen Wert hat g2?
12
public class MainKlassen3 { public static void main(String[] args){ Hund myh1, myh2; String n1, n2; double g1, g2;
myh1=new Hund(); myh2=new Hund("Goldi",12); n1=myh1.getName(); g1=myh1.getGewicht(); n2=myh2.getName(); g2=myh2.getGewicht(); }}
Welchen Wert hat myh1.name ?
"Musterhund"
Welchen Wert hat myh1.gewicht ?
10
Welchen Wert hat myh2.name ?
"Goldi"
Welchen Wert hat myh2.gewicht ?
12
Da der Hund "Goldi" zu viel bellt soll er in "Bello"
umbenannt werden. Da er außerdem zu viel frißt, wiegt
er mittlerweile 30 Kg.Realisieren Sie dies durch
zwei Anweisungen.
public class MainKlassen3 { public static void main(String[] args){ Hund myh1, myh2; String n1, n2; double g1, g2;
myh1=new Hund(); myh2=new Hund("Goldi",12); n1=myh1.getName(); g1=myh1.getGewicht(); n2=myh2.getName(); g2=myh2.getGewicht();
}}
myh2.setGewicht(30);myh2.setName("Bello");
Welchen Wert hat myh1.name ?
"Musterhund"
Welchen Wert hat myh1.gewicht ?
10
Welchen Wert hat myh2.name ?
"Bello"
Welchen Wert hat myh2.gewicht ? 30
Die Attribute des Objekts, auf das myh2 zeigt wurden
geändert. Die Attribute des Objekts, auf das myh1 zeigt
wurden nicht geändert.
Ein Konstruktor ohne Argumente (Parameter) wie z.B. Hund () heisst Standard-Konstruktor.
Implementiert der Programmierer für eine Klasse überhaupt keinen Konstruktor, dann erzeugt der Compiler automatisch einen Standard-Konstruktor, der als einzige Anweisung super() besitzt.
Bemerkung:Mit super() wird der Konstruktor der sogenannten Oberklasse aufgerufen. Dies wird später besprochen und braucht uns hier nicht zu interessieren.
Bei unseren bisherigen Beispielen hatten wir keine Konstruktoren implementiert. Deshalb wurde automatisch der Standardkonstruktor erzeugt.
Hat der Programmierer dagegen mindestens einen Konstruktor (egal mit 0, 1, 2,..., n Parametern) implementiert, erzeugt der Compiler keinen Standard-Konstruktor.
Beispiel:
public class Maintest1 { public static void main(String[] args){ double g1; String n1; Hund myh1;
myh1=new Hund(); g1=myh1.getGewicht(); n1=myh1.getName(); }}
// Klasse Hund wie früher, aber// ohne Konstruktor
Ist dies korrekt ?Warum ?
Ja, weil der Compiler automatisch einen Standard-Konstruktor erzeugt.
Welche Werte haben g1 und n1 ?
Da der Programmierer keinen Konstruktor implementiert hat, wird vom Compiler der Standard-Konstruktor erzeugt. Dieser hat keine Anweisung (außer super()). Deswegen haben die Attribute gewicht und name die Standardwerte. Das bedeutet bei einer double-Zahl der Wert 0.0 und bei einem Zeiger auf ein Objekt den Wert null.
0.0
null
Datentyp standardmäßige Vorbelegung
boolean false
char \u0000
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0
Referenz null
Beispiel:
public class Maintest1 { public static void main(String[] args){ double g1; String n1; Hund myh1;
myh1=new Hund(); g1=myh1.getGewicht(); n1=myh1.getName(); }}
// Klasse Hund kommt gleich ...
class Hund{ private String name; private double gewicht;
public Hund(String pName, double pGewicht){ name=pName; gewicht=pGewicht; }
// weitere get- und set // Methoden wie früher} // Jetzt schauen wir uns nochmals // die Klasse MainTest1 an...
Nur ein Konstruktor mit 2 Parametern, aber kein Standardkonstruktor.
public class Maintest1 { public static void main(String[] args){ double g1; String n1; Hund myh1;
myh1=new Hund(); g1=myh1.getGewicht(); n1=myh1.getName(); }}
Ist dies korrekt ?Warum ?
Nein, weil der Compiler keinen Standard-Konstruktor erzeugt.(da der Programmierer einen Konstruktor mit 2 Parametern erstellt hat). Ein Standard-Konstruktor wird aber beim Instanzieren bei:myh1=new Hund();benötigt !
WICHTIGEBEMERKUNGEN:
Innerhalb einer Methode einer Klasse soll nicht etwas
berechnet (bzw. Variablen verarbeitet) werden und
gleichzeitig eine Bildschirmausgabe z.B. mit
System.out.println(...) veranlaßt werden. Warum?
Weil dann diese Methode nicht in einer grafischen Oberfläche
benutzt werden kann (keine Ausgabe in einem Textfeld oder
einem eigenen Fenster).
Deswegen werden Eingaben bzw. Ausgaben in jeweils
eigenen Methoden gemacht.
Deswegen werden Eingaben bzw. Ausgaben in jeweils
eigenen Methoden gemacht.
Beispiel:
class Hund{ private String name; private double gewicht;
public void setName(String pName){ name = pName; System.out.println("Name = "+name); System.out.println("Gewicht = "+gewicht); } public String getName(){ System.out.println("Name = "+name); System.out.println("Gewicht = "+gewicht); return(name); } // Konstruktoren und Methoden wie früher...
Warum sind dies schlechte Lösungen?
class Hund{ private String name; private double gewicht;
public void setName(String pName){ name = pName; System.out.println("Name = "+name); System.out.println("Gewicht = "+gewicht); } public String getName(){ System.out.println("Name = "+name); System.out.println("Gewicht = "+gewicht); return(name); } // Konstruktoren und Methoden wie früher...
Weil sich das "Verarbeiten" der Daten und die Ausgabe innerhalb der gleichen Methode abspielen.
class Hund{ private String name; private double gewicht;
public void setName(String pName){ name = pName; System.out.println("Name = "+name); System.out.println("Gewicht = "+gewicht); } public String getName(){ System.out.println("Name = "+name); System.out.println("Gewicht = "+gewicht); return(name); } // Konstruktoren und Methoden wie früher...
Was ist eine bessere Lösung?
class Hund{ private String name; private double gewicht;
public void setName(String pName){ name = pName; } public String getName(){ return(name); }
public void printAllAttributes(){ System.out.println("Name = "+name); System.out.println("Gewicht = "+gewicht); }
// Konstruktoren und Methoden wie früher...
Es gibt keine Mischung aus der Verarbeitung von Daten und Eingaben bzw. Ausgaben.
public class Maintest1 { public static void main(String[] args){ Hund myh1;
myh1=new Hund(); myh1.setGewicht(123); myh1.printAllAttributes(); }}
Wie wird der Wert aller Attribute auf dem Bildschirm ausgegeben?
Was wird durch diese Anweisung auf dem Bildschirm ausgegeben?
Name = MusterhundGewicht = 123
