Składnia deklaracji klasy i jej struktura

1. Ogólna struktura deklaracji klasy

No więc wyobraź sobie: klasa w C# to jak projekt budynku. W projekcie opisujemy, ile jest pokoi, jaki kolor mają ściany, gdzie są drzwi i okna. W klasie — jakie obiekt ma właściwości (np. imię, wiek) i co potrafi robić (np. "przywitać się", "poprosić o wypłatę").

Deklaracja klasy zawsze zawiera trzy główne bloki:

1. Modyfikator dostępu (public, private, internal, protected) — kto może korzystać z tej klasy. Dla uproszczenia teraz będziemy używać public, żeby klasa była "widoczna" wszędzie.
2. Słowo kluczowe class — żeby kompilator wiedział, że faktycznie opisujemy klasę.
3. Nazwa klasy — z wielkiej litery, zgodnie z konwencją.
4. Ciało klasy w klamrach — tu opisujemy wszystko, z czego składa się nasza klasa: pola, właściwości, metody.

Schematycznie wygląda to tak:

public class NazwaKlasy
{
    // Tutaj będą pola, właściwości i metody klasy
}

Przykład: Klasa studenta

public class Student
{
    // Pola (zmienne należące do obiektu)
    public string Name;
    public int Age;
}

Na razie ta klasa to jak puste pudło: opisaliśmy, że student ma mieć imię i wiek, ale jeszcze niczego go nie nauczyliśmy.

2. Pola klasy (fields)

Pola — to zmienne, które należą do obiektu klasy. Na przykład, każdy student powinien mieć swoje imię i swój wiek — dlatego opisujemy je jako pola:

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

Teraz, gdy tworzysz obiekt typu Student, każdy obiekt będzie miał swoje własne imię i wiek.

Przykład tworzenia obiektu:

Student sasha = new Student();
sasha.Name = "Sasza";
sasha.Age = 20;

Tutaj stworzyliśmy obiekt sasha, a potem osobno przypisaliśmy jego polom wartości. Takie podejście jest używane na sam początek (o konstruktorach pogadamy bardzo dokładnie na następnym wykładzie).

3. Metody klasy (functions)

Metody — to "czasowniki" obiektu, czyli jego zachowanie. Akcje, które potrafi wykonać. Na przykład student może się przywitać. Do tego opisujemy metodę wewnątrz klasy:

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

    public void SayHello()
    {
        Console.WriteLine($"Cześć, mam na imię {Name}, mam {Age} lat!");
    }
}

Teraz każdy student może się "przywitać" — i użyje swojego imienia i wieku.

Przykład użycia metody:

Student sasha = new Student();
sasha.Name = "Sasza";
sasha.Age = 20;
sasha.SayHello(); // Wypisze: Cześć, mam na imię Sasza, mam 20 lat!

4. Właściwości klasy (properties)

Właściwości — to "sprytne" pola, którym można nadać specjalne akcje przy odczycie lub zapisie wartości. W nowoczesnym C# właściwości są używane częściej niż pola, bo dają więcej kontroli i elastyczności. To jak prąd: wydaje się proste, a możliwości — masa.

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

Tutaj get; set; tworzą automatycznie pole, ale pozwalają w przyszłości dodać logikę przy zmianie wartości. Dla użytkownika klasy właściwości wyglądają prawie tak samo jak pola.

Przykład:

Student katya = new Student();
katya.Name = "Katia";
katya.Age = 18;
Console.WriteLine(katya.Name); // Katia

Więcej o właściwościach klasy — w kolejnych wykładach :P

5. Komentarze

Nudny, ale ważny temat! Tak jak w reszcie kodu, wewnątrz klasy można i trzeba pisać komentarze, żeby wyjaśnić, po co jest dane pole czy metoda:

public class Student
{
    // Imię studenta
    public string Name { get; set; }
    
    // Wiek studenta (w latach)
    public int Age { get; set; }

    // Student się wita
    public void SayHello()
    {
        Console.WriteLine($"Cześć, mam na imię {Name}, mam {Age} lat!");
    }
}

To poprawia czytelność i pomaga się nie pogubić nawet w dużym projekcie.

6. Modyfikatory dostępu

Modyfikatory dostępu — prawie jak drzwi z różnymi zamkami. Określają, kto i skąd może sięgać do członów klasy. Główne modyfikatory:

• public: dostępne wszędzie (nasz przypadek domyślny).
• private: dostępne tylko wewnątrz tej klasy.
• internal: dostępne w obrębie bieżącego assembly (projekty, biblioteki).
• protected: dostępne wewnątrz klasy i jej potomków.

Przykład dla pola, które jest ukryte przed światem zewnętrznym:

public class Student
{
    private int age; // Tylko wewnątrz Student
    public string Name { get; set; }

    public void SetAge(int value)
    {
        if (value > 0)
            age = value;
    }

    public int GetAge()
    {
        return age;
    }
}

Na początku często wszystkie człony deklaruje się jako public, żeby się nie pogubić, ale w prawdziwych projektach to zła praktyka: niektóre szczegóły implementacji lepiej ukryć.

7. Statyczne człony klasy

Czasem klasa ma takie dane lub metody, które należą nie do pojedynczego obiektu, ale do całej klasy naraz. To są statyczne człony (static members).

Na przykład: chcemy prowadzić wspólny licznik studentów.

public class Student
{
    public static int StudentsCount = 0;

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

Dostęp do statycznego członu uzyskujemy przez nazwę klasy:

Student.StudentsCount = 0;

Każdy obiekt ma swoje właściwości/pola, a statyczne — są wspólne dla wszystkich. W powyższym przykładzie, jeśli mamy 10 studentów, każdy ma swoje Name, ale StudentsCount — jest jeden dla wszystkich.

8. Przykład: Pełna klasa studenta (wersja z metodami)

Zbierzmy wszystko razem i stwórzmy klasę studenta, która wszystko potrafi i jest poprawnie napisana:

public class Student
{
    // Statyczny licznik studentów - dotyczy wszystkich studentów
    public static int Count = 0;

    // Imię i wiek - właściwości
    public string Name { get; set; }
    public int Age { get; set; }

    // Konstruktor (o konstruktorach — w następnym wykładzie)
    public Student(string name, int age)
    {
        Name = name;
        Age = age;
        Count++; // Za każdym razem przy tworzeniu obiektu zwiększamy licznik
    }

    // Metoda do przywitania się
    public void SayHello()
    {
        Console.WriteLine($"Cześć! Jestem {Name}. Mam {Age} lat.");
    }
}

Użycie w głównej aplikacji:

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

        sasha.SayHello();
        katya.SayHello();

        Console.WriteLine($"Łącznie studentów: {Student.Count}");
    }
}

9. Organizacja kodu: jeden plik = jedna klasa

W .NET przyjęło się umieszczać każdą publiczną klasę w osobnym pliku o nazwie zgodnej z nazwą klasy. Na przykład:

Student.cs
|
|__ public class Student

A w głównym pliku programu (Program.cs) — punkt wejścia i główny kod. To ułatwia nawigację po projekcie, zwłaszcza gdy klas robi się dużo.

10. Typowe błędy przy pracy z klasami i obiektami

Błąd nr 1: zapomniane klamry lub napisane nie tam gdzie trzeba.
Kompilator od razu wywali błąd, ale nie zawsze wiadomo, o co chodzi. Zwłaszcza jeśli klamry się rozjechały w długiej konstrukcji — znaleźć, gdzie się wszystko posypało, bywa trudno.

Błąd nr 2: zadeklarowano dwie klasy o tej samej nazwie w jednym namespace.
Taka "kreatywność" kompilator odrzuci. I dobrze — bo sam byś się pogubił, do której klasy się odwołujesz.

Błąd nr 3: przypadkowo nadano polu tę samą nazwę co właściwości.
To powoduje zamieszanie przy odwołaniach do członów klasy. Nawet doświadczeni programiści czasem łapią się za głowę: "To ja się odwołuję do pola czy do właściwości?"

Błąd nr 4: brak modyfikatora dostępu.
Domyślnie klasa staje się internal, i jeśli piszesz bibliotekę — to może niespodziewanie ograniczyć dostęp do klasy z zewnątrz.

Błąd nr 5: odwołanie do statycznych członów przez instancję.
Jeśli napiszesz student.Count zamiast Student.Count, kompilator może i nie zabroni, ale to wprowadza zamieszanie. Tak jakbyś mówił, że Count dotyczy konkretnego studenta, a tak naprawdę — wszystkich naraz.