Polimorfizm i dynamiczne wywołania
Poznaj polimorfizm: wywołuj wirtualne elementy przez referencję bazową, używaj kolekcji typowanych bazową klasą, unikaj ukrywania metod i w razie potrzeby bezpiecznie rzutuj typy.
Polimorfizm i dynamiczne wywołania to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.
Przegląd polimorfizmu
Cel: Używanie jednego typu bazowego i umożliwianie typom pochodnym dostosowywania zachowania.
- Odwołanie bazowe, obiekt pochodny
- virtual + override → dynamiczne wiązanie
- Kolekcje typowane typem bazowym
- Unikanie ukrywania metod za pomocą new
Podstawy dynamicznego wiązania
Wywołanie metody virtual korzysta z typu obiektu w czasie wykonywania, a nie z typu zmiennej znanego w czasie kompilacji.
using System;
public class Animal
{
public virtual string Speak() { return "???"; }
}
public class Cat : Animal
{
public override string Speak() { return "Meow"; }
}
public class Dog : Animal
{
public override string Speak() { return "Woof"; }
}
public class Program
{
public static void Main(string[] args)
{
Animal a1 = new Cat(); // base reference
Animal a2 = new Dog();
Console.WriteLine(a1.Speak()); // Meow
Console.WriteLine(a2.Speak()); // Woof
}
}
Polimorfizm w kolekcjach
Przechowuj różne typy pochodne na liście typu List<Base> i wywołuj w jednolity sposób składowe virtual.
using System;
using System.Collections.Generic;
public class Shape
{
public virtual double Area() { return 0.0; }
}
public class Rectangle : Shape
{
private readonly int _w, _h;
public Rectangle(int w, int h) { _w = w; _h = h; }
public override double Area() { return _w * _h; }
}
public class Circle : Shape
{
private readonly int _r;
public Circle(int r) { _r = r; }
public override double Area() { return 3.14159 * _r * _r; }
}
public class Program
{
public static void Main(string[] args)
{
List<Shape> shapes = new List<Shape>();
shapes.Add(new Rectangle(3, 4));
shapes.Add(new Circle(2));
foreach (Shape s in shapes)
{
Console.WriteLine("Area = " + s.Area()); // calls correct override
}
}
}
Ukrywanie a override
Unikaj ukrywania metod (new). Używaj override przy rzeczywistym polimorfizmie; ukrywanie powoduje wywołanie wersji bazowej za pośrednictwem odwołania bazowego.
using System;
public class Printer
{
public virtual void Print() { Console.WriteLine("[Base]"); }
}
public class LoudPrinter : Printer
{
public override void Print() { Console.WriteLine("[LOUD]"); }
}
public class HiddenPrinter : Printer
{
// Hides the base method instead of overriding (BAD fit for polymorphism)
public new void Print() { Console.WriteLine("[HIDDEN]"); }
}
public class Program
{
public static void Main(string[] args)
{
Printer a = new LoudPrinter();
Printer b = new HiddenPrinter();
a.Print(); // [LOUD] (override works)
b.Print(); // [Base] (hiding fails via base reference)
}
}
Bezpieczne rzutowanie (as + sprawdzenie)
Preferuj wywołania bazowe/virtual. Jeśli musisz użyć składowych dostępnych tylko w klasie pochodnej, rzutuj bezpiecznie (as + sprawdzenie null).
using System;
public class Vehicle
{
public virtual string Info() { return "Vehicle"; }
}
public class Car : Vehicle
{
public bool HasAirConditioning;
public override string Info() { return "Car"; }
}
public class Program
{
public static void Main(string[] args)
{
Vehicle v = new Car();
Console.WriteLine(v.Info()); // polymorphic call
// Need a Car-only member? Cast carefully using 'as'
Car c = v as Car;
if (c != null)
{
c.HasAirConditioning = true;
Console.WriteLine("AC set: " + c.HasAirConditioning);
}
else
{
Console.WriteLine("Not a Car");
}
}
}
Wskazówki dotyczące polimorfizmu
Wskazówki:
- Najpierw projektuj rozwiązania oparte na wywołaniach bazowych/virtual.
- Używaj override, a nie new, aby zmieniać zachowanie.
- Utrzymuj małe i stabilne interfejsy API klas bazowych.
- Rzutuj rzadko; preferuj polimorfizm lub interfejsy.
Znaczenie dynamicznego wiązania
Podsumowanie
Podsumowanie: Polimorfizm pozwala, aby jedno wywołanie bazowe docierało do wielu zachowań klas pochodnych za pośrednictwem virtual/override. Używaj kolekcji typowanych typem bazowym, unikaj ukrywania za pomocą new i rzutuj tylko wtedy, gdy jest to konieczne.
Często zadawane pytania
Czy lekcja „Polimorfizm i dynamiczne wywołania” jest bezpłatna?
Tak — pełny tekst „Polimorfizm i dynamiczne wywołania” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.
Co nauczysz się w „Polimorfizm i dynamiczne wywołania”?
Poznaj polimorfizm: wywołuj wirtualne elementy przez referencję bazową, używaj kolekcji typowanych bazową klasą, unikaj ukrywania metod i w razie potrzeby bezpiecznie rzutuj typy. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć C# Academy?
Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.
Ile czasu zajmuje lekcja „Polimorfizm i dynamiczne wywołania”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?
Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- virtual/override/sealed; klasy abstrakcyjne
- Interfejsy (wprowadzenie) i implementowanie wielu interfejsów
- Polimorfizm i dynamiczne wywołania