Objekte mit dem Operator new erstellen

1. Wie erstellt man ein Objekt richtig

Der Operator new in C# ist wie ein magischer Knopf, der aus einer schematischen "Bauzeichnung" (unserer Klasse) eine echte Instanz (Objekt) macht, mit der man arbeiten kann. Einfach gesagt: Die Klasse definiert, was das Objekt kann und welche Eigenschaften es hat, und new erstellt dieses Objekt im Speicher des Computers.

Ohne den Operator new wären unsere Klassen wie Baupläne ohne Gebäude: Man kann sie bewundern, diskutieren, aber weder darauf springen noch Tee auf den Alcantara-Sessel verschütten.

Wenn die Klasse ein Pizzarezept ist, dann ist der Operator new der Koch, der nach diesem Rezept eine echte, leckere Pizza macht. Das Objekt ist das Ergebnis seiner Arbeit: Die Pizza in der Schachtel, die du schon essen kannst.

Syntax

Schauen wir uns an, wie man diesen allmächtigen new benutzt. Hier ist die grundlegende Syntax, wenn wir eine Klasse Contact haben:

Contact cont = new Contact();

• Contact links – das ist der Typ der Variablen, die wir erstellen.
• cont – der Name der Variablen (wähle sinnvolle Namen, wenn du später beim Debuggen nicht leiden willst).
• new Contact() – Aufruf des Operators new, der ein Objekt vom Typ Contact erstellt.

Im Speicher

Wenn dieser Code ausgeführt wird, reserviert das Betriebssystem ein Stück Speicher für das neue Objekt und gibt eine Referenz (Adresse) zurück, unter der dieses Objekt "lebt". Diese Referenz wird in der Variablen cont gespeichert.

Schaubild

+------------------+             +--------------------+
|  Variable cont   | --------->  |   Objekt Contact   |
+------------------+             +--------------------+
          |
          |       (enthält Name, Telefon, Email, ...)
          |
         Adresse

2. Wir erstellen Kontaktobjekte

In den vorherigen Beispielen haben wir so eine Klasse erfunden:

public class Contact
{
    public string Name;
    public string Phone;
    public string Email;
}

Jetzt erstellen wir ein neues Objekt vom Typ Contact:

Contact friend = new Contact();
friend.Name = "Ivan Ivanov";
friend.Phone = "+1-999-123-45-67";
friend.Email = "ivan@example.com";

Console.WriteLine($"Name: {friend.Name}, Telefon: {friend.Phone}, Email: {friend.Email}");

Was passiert hier:

1. Wir erstellen ein Objekt mit new Contact().
2. Wir weisen seinen Feldern Werte zu.
3. Wir geben die Daten auf dem Bildschirm aus.

Beispiel 2:

Lass uns mit mehreren Kontakten arbeiten – wir erstellen noch ein Objekt:

Contact boss = new Contact();
boss.Name = "Anastasia Sergeevna";
boss.Phone = "+1-888-765-43-21";
boss.Email = "nastya@company.com";

Console.WriteLine($"Boss: {boss.Name}, Telefon: {boss.Phone}");

Erinnert das nicht an das Ausfüllen eines Fragebogens für jeden Bekannten? Genau so funktionieren Objekte: Jede erstellte Instanz bekommt ihre eigenen Werte und speichert sie unabhängig von den anderen!

3. Verwendung eines Objekt-Arrays

Wenn wir nicht einen oder zwei, sondern zum Beispiel zehn Kontakte speichern wollen, ist es logisch, sie in einem Array zu halten:

Contact[] contacts = new Contact[3];           // Array für 3 Objekte

contacts[0] = new Contact();
contacts[0].Name = "Denis";
contacts[0].Phone = "+7-911-111-22-33";

contacts[1] = new Contact();
contacts[1].Name = "Maria";
contacts[1].Phone = "+7-915-123-45-67";

contacts[2] = new Contact();
contacts[2].Name = "Petr";
contacts[2].Phone = "+7-921-543-21-00";

// Wir geben alle aus
for (int i = 0; i < contacts.Length; i++)
{
    Console.WriteLine($"Kontakt {i+1}: {contacts[i].Name}, {contacts[i].Phone}");
}

Wichtig: Wir benutzen new für jedes Element im Array! Nur das Erstellen des Arrays erzeugt nicht die Objekte selbst, sondern reserviert nur Platz für Referenzen auf sie.

4. Operator new und Standardwert

Manchmal kommt die Frage auf – was passiert, wenn ich einfach eine Variable vom Typ Contact deklariere, aber ihr kein Objekt mit new zuweise?

Contact someContact;
someContact.Name = "Fehler";    // Kompilierfehler!

Wenn du aber schreibst:

Contact someContact = null;

dann bekommst du beim Zugriff auf someContact.Name einen der berühmtesten Fehler:

System.NullReferenceException: Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt.

Um das zu vermeiden, initialisiere Objekte immer mit new, bevor du sie benutzt.

5. Aufruf des Konstruktors

Wenn du new Contact() schreibst, wird dabei eine spezielle Methode aufgerufen – der Konstruktor. Im Moment enthält unsere Klasse keinen expliziten Konstruktor, also wird der implizite (Standard-)Konstruktor aufgerufen, der das Objekt erstellt und alle Felder mit Standardwerten füllt (null für Referenztypen und null für Zahlen).

In der nächsten Vorlesung lernst du, wie du eigene Konstruktoren erstellst – zum Beispiel gleich Name und Telefon übergeben kannst. Im Moment funktioniert nur der parameterlose Konstruktor.

Beispiele aus dem echten Leben

Mit Objekten über den Operator new zu arbeiten, ist Alltag für jeden C#-Entwickler. Stell dir vor, du:

• Erstellst einen User auf einer Website – im Code erscheint ein neues Objekt User.
• Öffnest eine Bestellung im Online-Shop – es erscheint ein neues Order.
• Trägst Daten zu einem Buch ein – ein neues Objekt Book.

In jedem modernen C#-Programm findest du tausende Zeilen mit dem Operator new.

Speicher vor der Objekterstellung

            Contact firstContact; // Variable, aber zeigt auf nichts

+--------------------------+
|   firstContact           |---->  null (nichts!)
+--------------------------+

Nach der Objekterstellung

Contact firstContact = new Contact();

+--------------------------+                 +----------------------+
|   firstContact           |---------------->|   Objekt Contact     |
+--------------------------+                 +----------------------+

6. Praktisches Beispiel

Angenommen, wir wollen dem User erlauben, neue Kontakte über die Tastatur einzugeben:

Console.WriteLine("Gib den Namen ein:");
string name = Console.ReadLine();

Console.WriteLine("Gib das Telefon ein:");
string phone = Console.ReadLine();

Contact newContact = new Contact();
newContact.Name = name;
newContact.Phone = phone;

Console.WriteLine($"Kontakt gespeichert: {newContact.Name}, {newContact.Phone}");

Jetzt wird jede Eingabe des Users ein eigenes Objekt im Speicher erstellen, das du speichern, ändern, ausgeben – einfach alles damit machen kannst!

7. Typische Fehler und lustige Stolperfallen

Fehler Nr. 1: new vor der Arbeit mit dem Objekt vergessen.
Wenn du eine Variable deklarierst, aber sie nicht initialisierst, bekommst du entweder einen Kompilierfehler oder eine NullReferenceException zur Laufzeit. Klassiker: Objekt deklariert – sofort mit new erstellen, wenn du es wirklich brauchst.

Fehler Nr. 2: Array von Objekten erstellt, aber die Objekte selbst nicht erstellt.
Hier eine typische Falle: Du erstellst ein Array vom Typ Contact[], vergisst aber, dass darin nur null steht. Versuchst du dann auf contacts[0].Name zuzugreifen, stürzt das Programm ab. Erst jedes Element einzeln initialisieren: contacts[i] = new Contact();.

Fehler Nr. 3: Methode mit Eigenschaft verwechselt.
Manchmal denken Anfänger, dass man eine Methode wie ein Feld benutzen kann: Sie schreiben student.GetName statt student.GetName(). Das funktioniert, solange du das Ergebnis nicht sofort benutzt – aber der Compiler meckert, wenn du versuchst, die "Methode" dort einzusetzen, wo ein Wert erwartet wird. Immer dran denken: Methoden werden mit runden Klammern aufgerufen, auch wenn sie keine Parameter haben.