1. Das Schlüsselwort new
In Java verwendet man das Schlüsselwort new, um ein Objekt einer beliebigen Klasse zu erzeugen. Dieses „magische“ Wort weist die JVM an: Speicher für das neue Objekt zu reservieren und seinen Konstruktor aufzurufen.
Analogie:
Wenn eine Klasse der Bauplan eines Autos ist, dann ist new die Fabrik, die nach diesem Plan ein echtes Auto zusammenbaut.
Beispiel
Person person = new Person();Was hier passiert:
- new Person() – es wird ein neues Objekt des Typs Person erzeugt (der Konstruktor wird aufgerufen).
- person – die Variable, die die Referenz auf das erzeugte Objekt speichert.
Wie das im Speicher aussieht
Wenn Sie Person person = new Person(); schreiben, wird im Speicher ein Bereich für die Felder des Objekts reserviert (z. B. Name und Alter), und die Variable person enthält die Adresse dieses Bereichs – eine Referenz.
Achtung:
Wenn Sie new weglassen, ist die Variable nur eine Referenz, die auf nichts zeigt (null). Der Versuch, auf Felder oder Methoden eines solchen „leeren“ Objekts zuzugreifen, führt zu einer NullPointerException.
2. Konstruktoraufruf: Wie funktioniert das?
Ein Konstruktor ist eine spezielle Methode, die beim Erzeugen eines Objekts aufgerufen wird und dessen Felder initialisiert – sie bereitet die Instanz auf die Arbeit vor.
Syntax
ClassName variableName = new ClassName(arguments);- Wenn eine Klasse einen Konstruktor mit Parametern hat, müssen diese unbedingt übergeben werden.
- Wenn der Konstruktor keine Parameter hat (oder der Standardkonstruktor verwendet wird), bleiben die Klammern leer.
Beispiel: Konstruktor mit Parametern
public class Person {
String name;
int age;
// Konstruktor mit Parametern
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
Wir erzeugen ein Objekt:
Person peter = new Person("Peter", 25);Die Werte "Peter" und 25 werden in die Felder name und age des neuen Objekts geschrieben.
Konstruktor ohne Parameter
public Person() {
this.name = "Unbenannt";
this.age = 0;
}
Jetzt kann man schreiben:
Person mysteryMan = new Person(); // name="Unbenannt", age=03. Mit Objekten arbeiten: Felder und Methoden
Nach dem Erzeugen eines Objekts greifen Sie über den Punktoperator (.) auf seine Felder und Methoden zu:
peter.name = "Peter";
System.out.println(peter.name); // Peter
peter.sayHello();
Wenn die Klasse eine Methode hat:
public void sayHello() {
System.out.println("Hallo, ich heiße " + name + "!");
}
Dann gibt der Aufruf peter.sayHello(); aus: Hallo, ich heiße Peter!
Beispiel: vollständige Klasse
public class Person {
String name;
int age;
public Person(String name, int age) { // Konstruktor
this.name = name;
this.age = age;
}
public void sayHello() { // Methode
System.out.println("Hallo, ich heiße " + name + "!");
}
}
Verwendung:
Person person = new Person("John", 30);
person.sayHello(); // Hallo, ich heiße John!
4. Referenzvariablen: Was ist das?
Eine Variable vom Klassentyp in Java ist eine Referenz auf ein Objekt im Speicher, nicht das Objekt selbst.
Demonstration
Person person = new Person("John", 30);
Person anotherJohn = person;
Nun zeigen sowohl person als auch anotherJohn auf dasselbe Objekt im Speicher. Wenn Sie ein Feld über eine Variable ändern, ändert es sich auch für die andere:
anotherJohn.age = 31;
System.out.println(person.age); // 31
Wichtiger Punkt:
Wenn Sie zwei verschiedene Objekte erzeugen, sind sie unabhängig:
Person peter = new Person("Peter", 25);
Person mary = new Person("Mary", 22);
peter.age = 99;
System.out.println(mary.age); // 22 (unverändert!)
5. Beispiel: Erzeugen und Verwenden mehrerer Objekte
Fügen wir der Anwendung mehrere Objekte hinzu. Nehmen wir die Klasse Person, und erzeugen wir in main mehrere Personen und geben ihre Begrüßungen aus.
Klasse Person
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("Hallo, ich heiße " + name + ", ich bin " + age + " Jahre alt!");
}
}
Verwendung in main
public class Main {
public static void main(String[] args) {
Person person = new Person("John", 25);
Person peter = new Person("Peter", 27);
person.sayHello(); // Hallo, ich heiße John, ich bin 25 Jahre alt!
peter.sayHello(); // Hallo, ich heiße Peter, ich bin 27 Jahre alt!
// Demonstration der Unabhängigkeit von Objekten:
person.age = 100;
person.sayHello(); // Hallo, ich heiße John, ich bin 100 Jahre alt!
peter.sayHello(); // Hallo, ich heiße Peter, ich bin 27 Jahre alt!
}
}
Programmausgabe:
Hallo, ich heiße John, ich bin 25 Jahre alt!
Hallo, ich heiße Peter, ich bin 27 Jahre alt!
Hallo, ich heiße John, ich bin 100 Jahre alt!
Hallo, ich heiße Peter, ich bin 27 Jahre alt!
6. Häufige Fehler beim Erzeugen von Objekten
Fehler Nr. 1: new vergessen
Person person;
person.name = "John"; // NullPointerException!
Die Variable person verweist auf kein Objekt (null). Das Objekt muss unbedingt mit new erzeugt werden.
Fehler Nr. 2: Parameter für den Konstruktor nicht übergeben
Person peter = new Person(); // Kompilierfehler, wenn es keinen parameterlosen Konstruktor gibt
Wenn die Klasse nur einen Konstruktor mit Parametern hat, müssen diese beim Erzeugen des Objekts angegeben werden.
Fehler Nr. 3: Denken, dass die Variable das Objekt selbst enthält
Person a = new Person("Anne", 20);
Person b = a;
b.age = 99;
System.out.println(a.age); // 99, weil a und b Referenzen auf dasselbe Objekt sind!
In Java ist eine Variable eines Klassentyps immer eine Referenz, nicht das Objekt selbst.
Fehler Nr. 4: Felder eines Objekts ändern und erwarten, dass sich das andere nicht ändert
Person x = new Person("X", 1);
Person y = x;
x.age = 42;
System.out.println(y.age); // 42
Wenn Sie zwei unabhängige Objekte brauchen – erzeugen Sie sie getrennt!
GO TO FULL VERSION