Klasy i obiekty — dane, które wiedzą, do kogo należą

Czego się dziś nauczysz

Przygotowanie: lekcje 01–36. Przewidywany czas: 45–90 minut z zadaniami. Przykłady wymagają .NET 8 lub nowszego, z włączonymi ImplicitUsings i Nullable.

Dane, które nie wiedzą, do kogo należą

Turniej ma dwóch graczy. Każdy ma imię i punkty. Bez klas wygląda to tak:

string imie1 = "Ala";
int punkty1 = 0;

string imie2 = "Olek";
int punkty2 = 0;

punkty1 += 5;

Console.WriteLine($"{imie1}: {punkty1}");
Console.WriteLine($"{imie2}: {punkty2}");

Przy dwóch graczach jeszcze się da. Przy pięciu mamy dziesięć zmiennych z numerkami, a przy każdej operacji trzeba pamiętać, żeby zmieniać te z tym samym numerem. Zapis punkty1 += 5 obok imie2 skompiluje się bez mrugnięcia okiem.

Klasa pozwala powiedzieć: imię i punkty to nie są dwie osobne zmienne, tylko jedna rzecz — gracz.

class Gracz
{
    public string Imie;
    public int Punkty;
}

Gracz a = new Gracz();
a.Imie = "Ala";
a.Punkty = 0;

Gracz b = new Gracz();
b.Imie = "Olek";
b.Punkty = 0;

a.Punkty += 5;

Console.WriteLine($"{a.Imie}: {a.Punkty}");
Console.WriteLine($"{b.Imie}: {b.Punkty}");

Wynik jest identyczny. Zmieniło się co innego: teraz nie da się przez pomyłkę dopisać punktów Ali do imienia Olka, bo punkty należą do konkretnego gracza.

Klasa to przepis, obiekt to wypiek

To rozróżnienie wraca na każdym sprawdzianie, więc warto je zapamiętać obrazkiem.

Gracz a = new Gracz();     // pierwszy obiekt
Gracz b = new Gracz();     // drugi, zupelnie niezalezny

a.Punkty = 5;

Console.WriteLine(a.Punkty);   // 5
Console.WriteLine(b.Punkty);   // 0  - b nic o tym nie wie

Słowo new robi dwie rzeczy: rezerwuje w pamięci miejsce na nowy obiekt i zwraca do niego odwołanie, które zapisujemy w zmiennej. Każde new to nowy, osobny egzemplarz.

Czynności też należą do obiektu

Na razie klasa trzyma tylko dane. Prawdziwa zmiana przychodzi wtedy, gdy trafiają do niej także czynności wykonywane na tych danych.

class Gracz
{
    public string Imie;
    public int Punkty;

    public void Dodaj(int ile)
    {
        Punkty += ile;
    }

    public string Opis()
    {
        return $"{Imie}: {Punkty} pkt";
    }
}

Gracz a = new Gracz();
a.Imie = "Ala";

a.Dodaj(5);
a.Dodaj(3);

Console.WriteLine(a.Opis());     // Ala: 8 pkt

Zwróć uwagę na dwie rzeczy w metodzie Dodaj. Po pierwsze: nie ma słowa static — to metoda obiektu, więc wywołujemy ją na konkretnym graczu, a nie samodzielnie. Po drugie: w środku piszemy po prostu Punkty, bez żadnego przedrostka. Metoda działa na polach tego obiektu, na którym ją wywołano.

Gracz a = new Gracz { Imie = "Ala" };
Gracz b = new Gracz { Imie = "Olek" };

a.Dodaj(5);      // rosna punkty Ali
b.Dodaj(2);      // rosna punkty Olka

Console.WriteLine(a.Opis());   // Ala: 5 pkt
Console.WriteLine(b.Opis());   // Olek: 2 pkt

Gdzie w pliku zapisać klasę

class Gracz
{
    public string Imie;
    public int Punkty;

    public void Dodaj(int ile)
    {
        Punkty += ile;
    }
}

class Program
{
    static void Main()
    {
        Gracz a = new Gracz();
        a.Imie = "Ala";
        a.Dodaj(5);

        Console.WriteLine($"{a.Imie}: {a.Punkty}");
    }
}

Obie klasy stoją na tym samym poziomie, jedna obok drugiej. Klasa Gracz nie jest w środku klasy Program ani w środku Main.

Przykład: dwóch graczy w jednym turnieju

class Gracz
{
    public string Imie;
    public int Punkty;

    public void Dodaj(int ile)
    {
        if (ile <= 0)
        {
            Console.WriteLine($"  {Imie}: odrzucono {ile} pkt");
            return;
        }

        Punkty += ile;
    }

    public bool Wygrywa(Gracz inny)
    {
        return Punkty > inny.Punkty;
    }

    public string Opis()
    {
        return $"{Imie,-6} {Punkty,3} pkt";
    }
}

class Program
{
    static void Main()
    {
        Gracz ala = new Gracz { Imie = "Ala" };
        Gracz olek = new Gracz { Imie = "Olek" };

        ala.Dodaj(5);
        ala.Dodaj(3);
        olek.Dodaj(6);
        olek.Dodaj(-2);          // odrzucone

        Console.WriteLine(ala.Opis());
        Console.WriteLine(olek.Opis());

        Console.WriteLine();
        Console.WriteLine($"Ala wygrywa z Olkiem: {ala.Wygrywa(olek)}");
        Console.WriteLine($"Olek wygrywa z Ala:   {olek.Wygrywa(ala)}");

        Gracz kopia = ala;       // UWAGA: to nie jest nowy gracz
        kopia.Dodaj(100);
        Console.WriteLine($"\nPo dodaniu do kopii: {ala.Opis()}");
    }
}

Olek: odrzucono -2 pkt
Ala      8 pkt
Olek     6 pkt

Ala wygrywa z Olkiem: True
Olek wygrywa z Ala:   False

Po dodaniu do kopii: Ala    108 pkt

Co dzieje się po kolei

• Metoda Dodaj sama pilnuje sensu danych — ujemna liczba punktów zostaje odrzucona. Wcześniej takie sprawdzenie musiałby powtarzać każdy, kto zmienia punkty.
• Wygrywa przyjmuje innego gracza jako parametr. Klasa może być typem parametru tak samo jak int czy string.
• Wewnątrz Wygrywa zapis Punkty oznacza punkty obiektu, na którym metodę wywołano, a inny.Punkty — punkty przekazanego gracza.
• Ostatnie trzy wiersze to najważniejsza pułapka tej lekcji: kopia = ala nie tworzy nowego gracza. Obie nazwy wskazują na ten sam obiekt, więc Ala ma nagle 108 punktów. Dlaczego tak jest, wyjaśnia lekcja 43.

Co robi każdy użyty element

Zanim utkniesz

Zadania

Co trzeba zapamiętać

• Klasa to opis typu, obiekt to konkretny egzemplarz utworzony przez new.
• Każdy obiekt ma własny komplet pól — zmiana w jednym nie dotyczy drugiego.
• Metoda bez static należy do obiektu i wywołujemy ją przez kropkę.
• Wewnątrz metody obiektu odwołujemy się do pól po samej nazwie; this jest opcjonalne.
• Sama deklaracja zmiennej nie tworzy obiektu — bez new jest tam null.
• Przypisanie obiektu do drugiej zmiennej nie kopiuje go; obie nazwy wskazują to samo.

Dokumentacja: Microsoft Learn — temat tej lekcji.