virtual/override/sealed; klasy abstrakcyjne
Poznaj metody wirtualne, przesłanianie, uszczelnianie przesłonięć i klasy abstrakcyjne; zobacz, jak referencje bazowe wywołują implementacje klas pochodnych.
virtual/override/sealed; klasy abstrakcyjne to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 1 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.
Podstawy dziedziczenia
Cel: Ponowne wykorzystywanie i dostosowywanie zachowania za pomocą dziedziczenia.
- virtual w klasie bazowej
- override w klasie pochodnej
- sealed override, aby zatrzymać dalsze zmiany
- abstract class definiuje kontrakt i współdzielony kod
virtual i override
virtual umożliwia przesłanianie. Wywołania za pośrednictwem odwołania do klasy bazowej korzystają z przesłonięcia w klasie pochodnej (dynamiczne wiązanie).
using System;
// Base method is virtual so derived classes can customize it
public class Shape
{
public virtual double Area()
{
return 0.0; // default
}
}
public class Rectangle : Shape
{
public int Width { get; private set; }
public int Height { get; private set; }
public Rectangle(int w, int h)
{
Width = w; Height = h;
}
public override double Area()
{
return Width * Height;
}
}
public class Program
{
public static void Main(string[] args)
{
Shape s = new Shape();
Shape r = new Rectangle(3, 4); // base reference
Console.WriteLine("Shape area = " + s.Area());
Console.WriteLine("Rectangle area = " + r.Area()); // calls Rectangle.Area()
}
}
sealed override
Używaj sealed override, aby zablokować metodę na określonym poziomie hierarchii.
using System;
public class BaseLogger
{
public virtual string Prefix()
{
return "[LOG]";
}
}
public class ConsoleLogger : BaseLogger
{
public sealed override string Prefix()
{
return "[CONSOLE]";
}
}
// Further derived class cannot override Prefix again:
// public class FancyLogger : ConsoleLogger
// {
// public override string Prefix() { return "[FANCY]"; } // compile error
// }
public class Program
{
public static void Main(string[] args)
{
ConsoleLogger log = new ConsoleLogger();
Console.WriteLine(log.Prefix() + " Ready");
}
}
Klasy Abstract
Klasy Abstract definiują wymagane składowe (abstract), a także mogą udostępniać współdzielony kod.
using System;
// Abstract class: cannot be instantiated; must implement abstract members
public abstract class Animal
{
public abstract string Speak(); // no body here
public string Info()
{
return "Animal says: " + Speak(); // shared code uses the abstract member
}
}
public class Dog : Animal
{
public override string Speak()
{
return "Woof";
}
}
public class Program
{
public static void Main(string[] args)
{
// Animal a = new Animal(); // compile error: abstract
Animal d = new Dog();
Console.WriteLine(d.Info()); // calls Dog.Speak()
}
}
virtual a abstract
Wybierz:
- virtual: udostępnia domyślną treść, którą typy pochodne mogą przesłonić.
- abstract: nie ma treści; typy pochodne muszą ją zaimplementować.
- sealed override: zatrzymuje dalsze przesłanianie po ustaleniu zachowania.
Wywołania polimorficzne
Polimorfizm: metoda przyjmuje typ bazowy i wywołuje przesłonięte składowe dla instancji klas pochodnych.
using System;
public class Notifier
{
public virtual string Channel() { return "Base"; }
}
public class EmailNotifier : Notifier
{
public override string Channel() { return "Email"; }
}
public class SmsNotifier : Notifier
{
public override string Channel() { return "SMS"; }
}
public class Program
{
// Works with any Notifier (polymorphism)
static void Send(Notifier n, string msg)
{
Console.WriteLine("[" + n.Channel() + "] " + msg);
}
public static void Main(string[] args)
{
Send(new EmailNotifier(), "Hello");
Send(new SmsNotifier(), "Hi");
}
}
Reguła virtual/override/sealed
Podsumowanie
Podsumowanie: Oznaczaj metody bazowe jako virtual, przesłaniaj je w typach pochodnych i używaj sealed override, aby zablokować zachowanie. Używaj klas abstract, aby wymagać implementacji i jednocześnie współdzielić wspólny kod.
Często zadawane pytania
Czy lekcja „virtual/override/sealed; klasy abstrakcyjne” jest bezpłatna?
Tak — pełny tekst „virtual/override/sealed; klasy abstrakcyjne” 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 „virtual/override/sealed; klasy abstrakcyjne”?
Poznaj metody wirtualne, przesłanianie, uszczelnianie przesłonięć i klasy abstrakcyjne; zobacz, jak referencje bazowe wywołują implementacje klas pochodnych. Ć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 1 z 3.
Ile czasu zajmuje lekcja „virtual/override/sealed; klasy abstrakcyjne”?
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