Syntax der Klassendeklaration und ihre Struktur

1. Allgemeine Struktur einer Klassendeklaration

Stell dir vor: Eine Klasse in C# ist wie ein Bauplan für ein Gebäude. Im Bauplan beschreiben wir, wie viele Zimmer es gibt, welche Farbe die Wände haben, wo Türen und Fenster stehen. In der Klasse – welche Eigenschaften ein Objekt hat (zum Beispiel Name, Alter) und was es tun kann (zum Beispiel "grüßen", "nach Gehalt fragen").

Eine Klassendeklaration besteht immer aus drei Hauptblöcken:

1. Zugriffsmodifikator (public, private, internal, protected) – wer darf diese Klasse benutzen. Zur Vereinfachung nehmen wir jetzt public, damit die Klasse überall "sichtbar" ist.
2. Das Schlüsselwort class – damit der Compiler versteht, dass wir wirklich eine Klasse beschreiben.
3. Klassenname – mit großem Anfangsbuchstaben, nach Konvention.
4. Der Klassenrumpf in geschweiften Klammern – hier beschreiben wir alles, woraus unsere Klasse besteht: Felder, Properties, Methoden.

Schematisch sieht das so aus:

public class Klassenname
{
    // Hier kommen Felder, Properties und Methoden der Klasse hin
}

Beispiel: Klasse Student

public class Student
{
    // Felder (Variablen, die zum Objekt gehören)
    public string Name;
    public int Alter;
}

Bis jetzt ist diese Klasse wie eine leere Box: Wir haben beschrieben, dass ein Student einen Namen und ein Alter haben soll, aber wir haben ihm noch nichts beigebracht.

2. Felder der Klasse (fields)

Felder sind Variablen, die zu einem Objekt der Klasse gehören. Zum Beispiel sollte jeder Student seinen eigenen Namen und sein eigenes Alter haben – deshalb werden sie als Felder beschrieben:

public class Student
{
    public string Name;
    public int Alter;
}

Jetzt, wenn du ein Objekt vom Typ Student erstellst, hat jedes Objekt seinen eigenen Namen und sein eigenes Alter.

Beispiel für das Erstellen eines Objekts:

Student sasha = new Student();
sasha.Name = "Sascha";
sasha.Alter = 20;

Hier haben wir das Objekt sasha erstellt und dann die Felder einzeln belegt. So macht man das für den einfachsten Einstieg (über Konstruktoren sprechen wir ganz ausführlich in der nächsten Vorlesung).

3. Methoden der Klasse (functions)

Methoden sind die "Verben" des Objekts, also sein Verhalten. Aktionen, die es ausführen kann. Zum Beispiel kann ein Student grüßen. Dafür wird eine Methode innerhalb der Klasse beschrieben:

public class Student
{
    public string Name;
    public int Alter;

    public void SagHallo()
    {
        Console.WriteLine($"Hallo, ich heiße {Name}, ich bin {Alter} Jahre alt!");
    }
}

Jetzt kann jeder Student "grüßen" – und dabei seinen eigenen Namen und sein eigenes Alter verwenden.

Beispiel für die Verwendung der Methode:

Student sasha = new Student();
sasha.Name = "Sascha";
sasha.Alter = 20;
sasha.SagHallo(); // Gibt aus: Hallo, ich heiße Sascha, ich bin 20 Jahre alt!

4. Properties der Klasse (properties)

Properties sind "smarte" Felder, bei denen man spezielle Aktionen beim Lesen oder Schreiben des Wertes festlegen kann. In modernem C# werden Properties öfter verwendet als Felder, weil sie mehr Kontrolle und Flexibilität bieten. Das ist wie Strom: Sieht einfach aus, aber die Möglichkeiten sind riesig.

public class Student
{
    public string Name { get; set; }
    public int Alter { get; set; }
}

Hier erzeugen get; set; automatisch ein Feld, aber erlauben es, später Logik beim Ändern des Wertes hinzuzufügen. Für den Nutzer der Klasse sehen Properties fast genauso aus wie Felder.

Beispiel:

Student katya = new Student();
katya.Name = "Katja";
katya.Alter = 18;
Console.WriteLine(katya.Name); // Katja

Mehr zu Properties der Klasse – in den nächsten Vorlesungen :P

5. Kommentare

Langweilig, aber wichtig! Wie auch im restlichen Code sollte man innerhalb der Klasse Kommentare schreiben, um zu erklären, wofür ein Feld oder eine Methode da ist:

public class Student
{
    // Name des Studenten
    public string Name { get; set; }
    
    // Alter des Studenten (in Jahren)
    public int Alter { get; set; }

    // Student grüßt
    public void SagHallo()
    {
        Console.WriteLine($"Hallo, ich heiße {Name}, ich bin {Alter} Jahre alt!");
    }
}

Das erhöht die Lesbarkeit und hilft, sich auch in großen Projekten nicht zu verirren.

6. Zugriffsmodifikatoren

Zugriffsmodifikatoren sind fast wie Türen mit verschiedenen Schlössern. Sie bestimmen, wer und von wo auf die Member der Klasse zugreifen kann. Die wichtigsten Modifikatoren:

• public: überall zugänglich (unser Standardfall).
• private: nur innerhalb dieser Klasse zugänglich.
• internal: innerhalb des aktuellen Assemblys (Projekte, Bibliotheken) zugänglich.
• protected: innerhalb der Klasse und ihrer Nachfolger zugänglich.

Beispiel für ein Feld, das von außen versteckt ist:

public class Student
{
    private int alter; // Nur innerhalb von Student
    public string Name { get; set; }

    public void SetzeAlter(int wert)
    {
        if (wert > 0)
            alter = wert;
    }

    public int HoleAlter()
    {
        return alter;
    }
}

Am Anfang deklariert man oft alle Member als public, um sich nicht zu verwirren, aber in echten Projekten ist das schlechte Praxis: Manche Implementierungsdetails sollte man lieber verstecken.

7. Statische Member der Klasse

Manchmal hat eine Klasse solche Daten oder Methoden, die nicht zu einem einzelnen Objekt, sondern zur ganzen Klasse gehören. Das sind statische Member (static members).

Zum Beispiel: Wir wollen einen gemeinsamen Zähler für Studenten führen.

public class Student
{
    public static int StudentenAnzahl = 0;

    public string Name { get; set; }
    public int Alter { get; set; }
}

Auf statische Member greift man über den Klassennamen zu:

Student.StudentenAnzahl = 0;

Jedes Objekt hat seine eigenen Properties/Felder, aber die statischen sind für alle gemeinsam. Im Beispiel oben: Wenn wir 10 Studenten haben, hat jeder sein eigenes Name, aber StudentenAnzahl gibt es nur einmal für alle.

8. Beispiel: Komplette Klasse Student (Version mit Methoden)

Lass uns alles zusammenbauen und eine Student-Klasse erstellen, die alles kann und richtig aufgebaut ist:

public class Student
{
    // Statischer Zähler für Studenten – gilt für alle Studenten
    public static int Anzahl = 0;

    // Name und Alter – Properties
    public string Name { get; set; }
    public int Alter { get; set; }

    // Konstruktor (über Konstruktoren – in der nächsten Vorlesung)
    public Student(string name, int alter)
    {
        Name = name;
        Alter = alter;
        Anzahl++; // Bei jedem neuen Objekt erhöhen wir den Zähler
    }

    // Methode zum Grüßen
    public void SagHallo()
    {
        Console.WriteLine($"Hallo! Ich bin {Name}. Ich bin {Alter} Jahre alt.");
    }
}

Verwendung im Hauptprogramm:

class Program
{
    static void Main()
    {
        Student sasha = new Student("Sascha", 20);
        Student katya = new Student("Katja", 22);

        sasha.SagHallo();
        katya.SagHallo();

        Console.WriteLine($"Insgesamt Studenten: {Student.Anzahl}");
    }
}

9. Code-Organisation: eine Datei = eine Klasse

In .NET ist es üblich, jede öffentliche Klasse in eine eigene Datei zu legen, deren Name mit dem Klassennamen übereinstimmt. Zum Beispiel:

Student.cs
|
|__ public class Student

Und in der Hauptdatei des Programms (Program.cs) – der Einstiegspunkt und der Hauptcode. Das macht die Navigation im Projekt leichter, besonders wenn es viele Klassen gibt.

10. Typische Fehler beim Arbeiten mit Klassen und Objekten

Fehler Nr. 1: Geschweifte Klammern vergessen oder an der falschen Stelle geschrieben.
Der Compiler gibt sofort einen Fehler aus, aber es ist nicht immer klar, woran es liegt. Besonders wenn die Klammern in einer langen Konstruktion verrutscht sind – es ist manchmal echt schwer zu finden, wo alles kaputt gegangen ist.

Fehler Nr. 2: Zwei Klassen mit demselben Namen im selben Namespace deklariert.
So viel "Kreativität" mag der Compiler nicht. Und das ist auch gut so – sonst würdest du selbst nicht mehr wissen, auf welche Klasse du dich beziehst.

Fehler Nr. 3: Einem Feld versehentlich denselben Namen wie einer Property gegeben.
Das führt zu Verwirrung beim Zugriff auf die Member der Klasse. Selbst erfahrene Entwickler greifen sich manchmal an den Kopf: "Greife ich jetzt auf das Feld oder auf die Property zu?"

Fehler Nr. 4: Zugriffsmodifikator nicht angegeben.
Standardmäßig wird die Klasse dann internal, und wenn du eine Bibliothek schreibst – kann das den Zugriff auf die Klasse von außen unerwartet einschränken.

Fehler Nr. 5: Zugriff auf statische Member über eine Instanz.
Wenn du student.Anzahl statt Student.Anzahl schreibst, verbietet der Compiler das vielleicht nicht, aber es verwirrt. So sieht es aus, als ob Anzahl zu einem bestimmten Studenten gehört, dabei gilt es für alle.