0Pricing
C# Academy · Lektion

Konstruktoren definieren

Erstellen Sie Instanzen mit parametrisierten Konstruktoren.

Konstruktoren definieren ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Konstruktor?

Ein Konstruktor ist eine spezielle Methode, die ausgeführt wird, wenn ein Objekt mit new erstellt wird. Er trägt denselben Namen wie die Klasse und hat keinen Rückgabetyp. Seine Aufgabe besteht darin, das Objekt in einen gültigen Ausgangszustand zu versetzen.

using System;

class Dog
{
    public Dog()
    {
        Console.WriteLine("A dog was created");
    }
}

class Program
{
    static void Main()
    {
        var d = new Dog();
    }
}

Konstruktoren mit Parametern

Ein Konstruktor kann Parameter entgegennehmen, sodass der aufrufende Code Anfangswerte bereitstellt. Dies ist das häufigste Muster zum Festlegen erforderlicher Daten.

using System;

class Person
{
    public string Name;
    public int Age;

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

class Program
{
    static void Main()
    {
        var p = new Person("Ada", 36);
        Console.WriteLine(p.Name + " is " + p.Age);
    }
}

Das Schlüsselwort this in Konstruktoren

Wenn ein Parameter denselben Namen wie ein Feld hat, verwenden Sie this., um auf das Feld zu verweisen und es vom Parameter zu unterscheiden.

using System;

class Book
{
    public string Title;

    public Book(string title)
    {
        this.Title = title;
    }
}

class Program
{
    static void Main()
    {
        var b = new Book("C# Basics");
        Console.WriteLine(b.Title);
    }
}

Der Standardkonstruktor

Wenn Sie keinen Konstruktor schreiben, stellt der Compiler einen parameterlosen Konstruktor bereit. Sobald Sie jedoch einen beliebigen Konstruktor definieren, entfällt dieser Standardkonstruktor, sofern Sie ihn nicht selbst hinzufügen.

using System;

class Empty
{
    // No constructor written -> compiler supplies a default one
    public int Value;
}

class Program
{
    static void Main()
    {
        var e = new Empty();
        Console.WriteLine("Default Value: " + e.Value);
    }
}

Validierung in einem Konstruktor

Ein Konstruktor kann seine Argumente validieren und so garantieren, dass das Objekt niemals in einem ungültigen Zustand erstellt wird.

using System;

class Account
{
    public decimal Balance;

    public Account(decimal initial)
    {
        if (initial < 0)
            throw new ArgumentException("Initial balance cannot be negative");
        Balance = initial;
    }
}

class Program
{
    static void Main()
    {
        var a = new Account(100m);
        Console.WriteLine("Balance: " + a.Balance);
    }
}

Konstruktorüberladung

Eine Klasse kann mehrere Konstruktoren mit unterschiedlichen Parameterlisten besitzen. Der Compiler wählt denjenigen aus, der zu den übergebenen Argumenten passt.

using System;

class Point
{
    public int X;
    public int Y;

    public Point()
    {
        X = 0;
        Y = 0;
    }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

class Program
{
    static void Main()
    {
        var origin = new Point();
        var p = new Point(3, 4);
        Console.WriteLine(origin.X + "," + origin.Y + " | " + p.X + "," + p.Y);
    }
}

Eigenschaften in einem Konstruktor festlegen

Konstruktoren weisen häufig automatisch implementierten Eigenschaften Werte zu, einschließlich Eigenschaften mit init oder privaten Settern.

using System;

class Product
{
    public string Name { get; }
    public decimal Price { get; }

    public Product(string name, decimal price)
    {
        Name = name;
        Price = price;
    }
}

class Program
{
    static void Main()
    {
        var p = new Product("Pen", 1.50m);
        Console.WriteLine(p.Name + ": " + p.Price);
    }
}

Standardwerte für Parameter

Konstruktorparameter können Standardwerte besitzen, sodass der aufrufende Code sie weglassen kann. Dadurch werden häufig mehrere Überladungen überflüssig.

using System;

class Circle
{
    public double Radius;
    public string Color;

    public Circle(double radius, string color = "black")
    {
        Radius = radius;
        Color = color;
    }
}

class Program
{
    static void Main()
    {
        var c1 = new Circle(2);
        var c2 = new Circle(3, "red");
        Console.WriteLine(c1.Color + " | " + c2.Color);
    }
}

Arbeit in einem Konstruktor ausführen

Zusätzlich zum Zuweisen von Feldern kann ein Konstruktor abgeleitete Daten berechnen oder die vom Objekt benötigten Ressourcen vorbereiten.

using System;

class Rectangle
{
    public double Width;
    public double Height;
    public double Area;

    public Rectangle(double w, double h)
    {
        Width = w;
        Height = h;
        Area = w * h;
    }
}

class Program
{
    static void Main()
    {
        var r = new Rectangle(4, 5);
        Console.WriteLine("Area: " + r.Area);
    }
}

Konstruktoren und erforderliche Daten

Wenn Sie erforderliche Werte im Konstruktor festlegen, werden sie verpflichtend: Sie können das Objekt nicht erstellen, ohne diese Werte bereitzustellen.

using System;

class User
{
    public string Id;
    public string Email;

    public User(string id, string email)
    {
        Id = id;
        Email = email;
    }
}

class Program
{
    static void Main()
    {
        var u = new User("u1", "a@b.com");
        Console.WriteLine(u.Id + " / " + u.Email);
    }
}

Alles zusammenführen

Ein gut entworfener Konstruktor validiert Eingaben, weist Feldern Werte zu und hinterlässt ein vollständig einsatzbereites Objekt.

using System;

class Temperature
{
    public double Celsius { get; }
    public double Fahrenheit { get; }

    public Temperature(double celsius)
    {
        if (celsius < -273.15)
            throw new ArgumentException("Below absolute zero");
        Celsius = celsius;
        Fahrenheit = celsius * 9 / 5 + 32;
    }
}

class Program
{
    static void Main()
    {
        var t = new Temperature(25);
        Console.WriteLine(t.Celsius + "C = " + t.Fahrenheit + "F");
    }
}

Schnelltest

Testen Sie Ihr Verständnis von Konstruktoren.

Zusammenfassung

Ein Konstruktor trägt denselben Namen wie die Klasse, hat keinen Rückgabetyp und wird bei new ausgeführt. Parametrisierte Konstruktoren übernehmen Anfangswerte; this. unterscheidet Felder von Parametern. Sie können Konstruktoren überladen und Standardwerte für Parameter verwenden. Sobald Sie einen Konstruktor definieren, wird der automatisch generierte Standardkonstruktor entfernt.

using System;

class Demo
{
    public string Name;
    public Demo(string name = "anon")
    {
        this.Name = name;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(new Demo().Name);
        Console.WriteLine(new Demo("Kai").Name);
    }
}

Häufig gestellte Fragen

Ist die Lektion „Konstruktoren definieren“ kostenlos?

Ja — der vollständige Text von „Konstruktoren definieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Konstruktoren definieren“?

Erstellen Sie Instanzen mit parametrisierten Konstruktoren. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Konstruktoren definieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Konstruktoren definieren
  2. Konstruktorverkettung mit this
  3. Objekt- und Collection-Initialisierer
  4. Statische Konstruktoren
← Zurück zu C# Academy