1. Wprowadzenie
Dzisiejszy temat może wydawać się trochę abstrakcyjny, ale serio, bez niego ani rusz dalej. Pogadamy o dziedziczeniu w programowaniu. Dziś tylko go lekko dotkniemy, a w przyszłości rozkminimy już na grubo.
Wyobraź sobie, że piszesz apkę do ewidencji zwierzaków w zoo. Masz różne gatunki: lwy, tygrysy, słonie, papugi. Wszystkie to zwierzaki. Ale każdy ma swoje bajery:
- Lew ma grzywę.
- Tygrys jest w paski.
- Słoń jest mega duży i ma trąbę.
- Papuga umie gadać.
Gdybyśmy opisywali każde zwierzę osobno, kod byłby bardzo podobny:
// Lew
public class Lion
{
public string Name { get; set; }
public int Age { get; set; }
public string Species { get; set; } = "Lew"; // Zawsze "Lew"
public void Eat() { Console.WriteLine("Lew je mięso."); }
public void Sleep() { Console.WriteLine("Lew śpi."); }
public void Roar() { Console.WriteLine("Lew ryczy!"); }
public string ManeColor { get; set; } // Bajer lwa - grzywa
}
// Tygrys
public class Tiger
{
public string Name { get; set; }
public int Age { get; set; }
public string Species { get; set; } = "Tygrys"; // Zawsze "Tygrys"
public void Eat() { Console.WriteLine("Tygrys je mięso."); }
public void Sleep() { Console.WriteLine("Tygrys śpi."); }
public void Stride() { Console.WriteLine("Tygrys skrada się."); }
public string StripePattern { get; set; } // Bajer tygrysa - paski
}
Widzisz ile tu powtarzającego się kodu? Name, Age, Eat(), Sleep() – to przecież wspólne dla wszystkich zwierzaków! A jakby było 100 gatunków? Masakra!
I tu właśnie wchodzi dziedziczenie.
2. Czym jest dziedziczenie klas w C#?
Dziedziczenie — to jeden z fundamentów programowania obiektowego (OOP). Pozwala tworzyć nowe klasy na bazie już istniejących. Nowa klasa (potomek, klasa dziecka, klasa pochodna) dostaje (dziedziczy) wszystkie właściwości (pola) i zachowania (metody) swojej klasy rodzica (klasa bazowa, klasa rodzicielska).
To jak w życiu: dziedziczysz jakieś cechy po rodzicach, ale masz też swoje unikalne bajery.
W C# dziedziczenie zapisuje się dwukropkiem : po nazwie klasy dziecka:
// Klasa rodzicielska (bazowa) - Animal
public class Animal
{
public string Name { get; set; } // Imię zwierzaka
public int Age { get; set; } // Wiek zwierzaka
public void Eat()
{
Console.WriteLine($"{Name} je.");
}
public void Sleep()
{
Console.WriteLine($"{Name} śpi.");
}
}
// Klasa dziecka (pochodna) - Lion dziedziczy po Animal
public class Lion : Animal // <-- O to chodzi, dziedziczenie!
{
public string ManeColor { get; set; } // Unikalna cecha lwa
public void Roar() // Unikalne zachowanie lwa
{
Console.WriteLine($"{Name} ryczy: RRRRRR!");
}
}
// Jeszcze jedna klasa dziecka - Tiger dziedziczy po Animal
public class Tiger : Animal
{
public string StripePattern { get; set; } // Unikalna cecha tygrysa
public void Stride() // Unikalne zachowanie tygrysa
{
Console.WriteLine($"{Name} skrada się bezszelestnie.");
}
}
Teraz, jeśli stworzymy obiekt Lion albo Tiger, będą miały automatycznie właściwości Name i Age, a także metody Eat() i Sleep(), bo odziedziczyły je po Animal.
class Program
{
static void Main(string[] args)
{
Lion simba = new Lion();
simba.Name = "Simba";
simba.Age = 5;
simba.ManeColor = "Złoty";
simba.Eat(); // Metoda odziedziczona po Animal
simba.Sleep(); // Metoda odziedziczona po Animal
simba.Roar(); // Własna metoda Lion
Console.WriteLine($"{simba.Name} - wiek: {simba.Age}, kolor grzywy: {simba.ManeColor}");
Tiger shereKhan = new Tiger();
shereKhan.Name = "Shere Khan";
shereKhan.Age = 7;
shereKhan.StripePattern = "Klasyczny";
shereKhan.Eat(); // Metoda odziedziczona po Animal
shereKhan.Sleep(); // Metoda odziedziczona po Animal
shereKhan.Stride(); // Własna metoda Tiger
Console.WriteLine($"{shereKhan.Name} - wiek: {shereKhan.Age}, wzór: {shereKhan.StripePattern}");
}
}
Kluczowe idee dziedziczenia:
- Wykorzystanie kodu ponownie (Code Reusability): Unikasz powielania kodu, wrzucając wspólną logikę do klasy bazowej.
- Hierarchia (Hierarchy): Tworzysz logiczną strukturę "ogólne-szczegółowe" (Animal → Lion/Tiger).
- Polimorfizm (Polymorphism): (Na razie tylko wspomnę, więcej później) Możesz pracować z obiektami klas dzieci, używając referencji do ich klasy bazowej. Na przykład mieć listę Animal i wrzucić tam lwy, tygrysy, a potem wywoływać na nich metodę Eat().
3. Wywołanie konstruktorów klas bazowych (base)
Gdy tworzysz obiekt klasy dziecka (np. new Lion()), C# automatycznie odpala konstruktor klasy bazowej (u nas Animal) przed konstruktorem klasy dziecka. To daje pewność, że bazowa część obiektu będzie dobrze zainicjalizowana.
Czasem musisz przekazać parametry do konstruktora klasy bazowej. Do tego służy słowo kluczowe base po sygnaturze konstruktora klasy dziecka.
public class Animal
{
public string Name { get; set; }
public int Age { get; set; }
// Konstruktor klasy bazowej
public Animal(string name, int age)
{
Name = name;
Age = age;
Console.WriteLine($"Konstruktor Animal: Stworzono zwierzaka {Name}, wiek {Age}.");
}
public void Eat()
{
Console.WriteLine($"{Name} je.");
}
public void Sleep()
{
Console.WriteLine($"{Name} śpi.");
}
}
public class Lion : Animal
{
public string ManeColor { get; set; }
// Konstruktor Lion, który wywołuje konstruktor klasy bazowej Animal
public Lion(string name, int age, string maneColor) : base(name, age) // <-- O to chodzi, 'base'!
{
ManeColor = maneColor;
Console.WriteLine($"Konstruktor Lion: Kolor grzywy {ManeColor}.");
}
public void Roar()
{
Console.WriteLine($"{Name} ryczy: RRRRRR!");
}
}
class Program
{
static void Main(string[] args)
{
// Przy tworzeniu Lion, najpierw odpala się konstruktor Animal, potem Lion
Lion simba = new Lion("Simba", 5, "Złoty");
simba.Roar();
}
}
Co się stanie przy wykonaniu new Lion("Simba", 5, "Złoty"):
- Odpali się konstruktor Lion(string name, int age, string maneColor).
- Dzięki : base(name, age), sterowanie pójdzie do konstruktora Animal(string name, int age).
- Wykona się kod konstruktora Animal i zobaczysz Konstruktor Animal: Stworzono zwierzaka Simba, wiek 5.
- Potem sterowanie wróci do konstruktora Lion.
- Wykona się kod konstruktora Lion i zobaczysz Konstruktor Lion: Kolor grzywy Złoty.
To mega ważne: klasa bazowa zawsze inicjalizuje się pierwsza!
4. Operatory is i as
W świecie programowania w C# często będziesz musiał sprawdzić typ obiektu albo spróbować go rzutować na inny typ. Tu wchodzą operatory is i as. Są szczególnie przydatne przy pracy z dziedziczeniem i polimorfizmem, o których pogadamy później, ale podstawy ogarniesz już teraz.
Operator is (sprawdzanie typu)
Operator is pozwala sprawdzić, czy obiekt jest zgodny z danym typem. Zwraca true, jeśli obiekt można rzutować na wskazany typ, i false w przeciwnym wypadku.
Składnia: wyrażenie is Typ
static void AnalyzeObject(object obj)
{
if (obj is string)
{
Console.WriteLine("To jest string!");
}
else if (obj is int)
{
Console.WriteLine("To jest liczba całkowita!");
}
else
{
Console.WriteLine("To coś innego.");
}
}
static void Main()
{
AnalyzeObject("Cześć, świecie!"); // To jest string!
AnalyzeObject(123); // To jest liczba całkowita!
AnalyzeObject(3.14); // To coś innego.
AnalyzeObject(new int[] { 1, 2 }); // To coś innego.
}
is z pattern matchingiem:
Nowoczesny C# pozwala używać is nie tylko do sprawdzania typu, ale też od razu do stworzenia zmiennej tego typu, jeśli typ się zgadza. To się nazywa "pattern matching" i robi kod dużo zgrabniejszym.
static void AnalyzeObjectWithPatternMatching(object obj)
{
if (obj is string message) // Jeśli obj to string, przypisz do zmiennej message
{
Console.WriteLine($"To jest string, jego długość: {message.Length}");
}
else if (obj is int number) // Jeśli obj to int, przypisz do zmiennej number
{
Console.WriteLine($"To liczba, razy 2: {number * 2}");
}
else
{
Console.WriteLine("Typ nierozpoznany.");
}
}
static void Main()
{
AnalyzeObjectWithPatternMatching("Przykład"); // To jest string, jego długość: 8
AnalyzeObjectWithPatternMatching(50); // To liczba, razy 2: 100
AnalyzeObjectWithPatternMatching(new object()); // Typ nierozpoznany.
}
Ten sposób z is i pattern matchingiem jest dużo lepszy niż tradycyjne rzutowanie z późniejszym sprawdzaniem null, bo jest bezpieczniejszy i czytelniejszy.
Operator as (bezpieczne rzutowanie typu)
Operator as próbuje rzutować obiekt na wskazany typ. Jeśli się uda, zwraca obiekt już w tym typie. Jeśli nie (czyli obiekt nie jest zgodny z typem docelowym), as zwraca null zamiast rzucać wyjątek. Dzięki temu as jest "bezpiecznym" rzutowaniem.
Składnia: wyrażenie as Typ
static void ProcessData(object data)
{
string text = data as string; // Próbujemy rzutować data na string
if (text != null) // Sprawdzamy, czy się udało
{
Console.WriteLine($"Przetwarzanie stringa: {text.ToUpper()}");
}
else
{
Console.WriteLine("Dane nie są stringiem.");
}
}
static void Main()
{
ProcessData("hello"); // Przetwarzanie stringa: HELLO
ProcessData(123); // Dane nie są stringiem.
ProcessData(null); // Dane nie są stringiem.
}
Kiedy używać as zamiast zwykłego rzutowania (Typ)wyrażenie:
- Bezpieczeństwo: Jeśli nie masz pewności, że obiekt jest danego typu, as pozwoli uniknąć InvalidCastException i zamiast tego dostaniesz null, który możesz obsłużyć.
- Dla typów referencyjnych: as działa tylko z typami referencyjnymi (klasy, interfejsy, delegaty, tablice). Nie można go użyć do rzutowania typów wartościowych (np. int na double).
Ważne: Jeśli masz pewność, że obiekt zawsze będzie danego typu, albo musisz rzutować typ wartościowy, użyj zwykłego rzutowania (Typ)wyrażenie. Jeśli rzutowanie się nie uda, zwykłe rzutowanie rzuci błąd (InvalidCastException), co może być pożądane, jeśli zły typ to błąd w logice programu.
GO TO FULL VERSION