Modyfikatory dziedziczenia/polimorfizmu w C
virtual - metoda z domyślną implementacją, opcjonalnie nadpisywalna
public class OrderProcessor
{
public virtual void Process(Order order)
{
Console.WriteLine("Standardowe przetwarzanie");
}
}
public class PriorityOrderProcessor : OrderProcessor
{
public override void Process(Order order) // nadpisanie OPCJONALNE
{
Console.WriteLine("Priorytetowe");
base.Process(order); // można wywołać oryginalną implementację
}
}
Klasa pochodna może, ale nie musi nadpisać - jeśli nie nadpisze, dziedziczy zachowanie bazowe. Wiązanie dynamiczne (polimorfizm) - o wersji metody decyduje faktyczny typ obiektu w runtime, nie typ zmiennej.
abstract - metoda bez implementacji, WYMUSZONE nadpisanie
public abstract class OrderProcessorBase
{
public abstract void Process(Order order); // brak ciała - żadnej implementacji
}
public class StandardOrderProcessor : OrderProcessorBase
{
public override void Process(Order order) // MUSI nadpisać, inaczej błąd kompilacji
{
Console.WriteLine("Przetwarzanie");
}
}
Klasa zawierająca metodę abstract sama musi być abstract - nie da się jej zainstancjonować (new OrderProcessorBase() to błąd kompilacji). Jak omawialiśmy przy Inversion of Control - to fundament Template Method Pattern.
override - faktyczne nadpisanie metody virtual/abstract
public class Base
{
public virtual void Method() => Console.WriteLine("Base");
}
public class Derived : Base
{
public override void Method() => Console.WriteLine("Derived"); // NADPISUJE, nie ukrywa
}
Base obj = new Derived();
obj.Method(); // "Derived" - wiązanie DYNAMICZNE, decyduje faktyczny typ obiektu w runtime
Wymagania: ta sama sygnatura (nazwa, parametry, typ zwracany), widoczność nie może być zawężona względem metody bazowej.
sealed - blokada dalszego nadpisywania/dziedziczenia
Na metodzie (musi być połączone z override) - "zapieczętowuje" konkretne nadpisanie, blokując kolejne poziomy:
public class Base
{
public virtual void Method() { }
}
public class Middle : Base
{
public sealed override void Method() { } // ostatnie możliwe nadpisanie w łańcuchu
}
public class Derived : Middle
{
public override void Method() { } // ❌ Błąd - Method jest sealed w Middle
}
Na klasie - blokuje całe dziedziczenie:
public sealed class OrderValidator
{
public void Validate(Order order) { }
}
public class CustomValidator : OrderValidator { } // ❌ Błąd - nie można dziedziczyć po sealed class
Dobra praktyka: klasy nieprzemyślane pod kątem dziedziczenia (bez virtual zaplanowanego świadomie) warto oznaczać jako sealed, żeby uniknąć nieprzewidzianych problemów przy próbie rozszerzenia.
new - ukrywanie metody (method hiding), NIE nadpisywanie
public class Base
{
public void Show() => Console.WriteLine("Base"); // BRAK virtual
}
public class Derived : Base
{
public new void Show() => Console.WriteLine("Derived"); // "new" zamiast "override"
}
Base obj = new Derived();
obj.Show(); // "Base"! - wiązanie STATYCZNE, decyduje typ ZMIENNEJ w compile-time
Derived obj2 = new Derived();
obj2.Show(); // "Derived" - bo typ zmiennej to Derived
To jest klasyczna pułapka na rozmowie - new ukrywa metodę bazową zamiast jej nadpisywać. W przeciwieństwie do override (wiązanie dynamiczne - decyduje faktyczny typ obiektu), new to wiązanie statyczne - decyduje typ zmiennej, przez którą wywołujesz metodę, niezależnie od faktycznego typu obiektu w pamięci.
Tabela zbiorcza modyfikatorów dziedziczenia
| Modyfikator | Wymaga bazowej virtual/abstract? |
Implementacja w bazie? | Nadpisanie wymagane? | Wiązanie |
|---|---|---|---|---|
virtual (na bazowej) |
- | Tak | Opcjonalne (override) |
Dynamiczne |
abstract (na bazowej) |
- | Nie | Wymagane | Dynamiczne |
override (na pochodnej) |
Tak | - | To JEST nadpisanie | Dynamiczne |
sealed override (na pochodnej) |
Tak | - | Blokuje DALSZE nadpisania | Dynamiczne, zamrożone |
new (na pochodnej) |
Nie (działa nawet bez virtual) |
- | Nie nadpisuje, tylko ukrywa | Statyczne |
Jak te dwie kategorie się łączą - pełny przykład
public abstract class ViewModelBase // klasa: nie można instancjonować bezpośrednio
{
protected readonly ILogger _logger; // private/protected - modyfikator DOSTĘPU
protected ViewModelBase(ILogger logger) => _logger = logger;
// protected + virtual: widoczne dla podklas (dostęp) ORAZ opcjonalnie nadpisywalne (dziedziczenie)
protected virtual void OnPropertyChanged(string propertyName) { }
// public + abstract: widoczne wszędzie (dostęp) ORAZ WYMUSZA nadpisanie (dziedziczenie)
public abstract void Refresh();
}
public sealed class OrderViewModel : ViewModelBase // sealed: nikt nie może dziedziczyć DALEJ po tej klasie
{
public OrderViewModel(ILogger logger) : base(logger) { }
public override void Refresh() { /* wymagana implementacja */ }
protected override void OnPropertyChanged(string propertyName)
{
Console.WriteLine($"Zmiana: {propertyName}");
base.OnPropertyChanged(propertyName);
}
}
To pokazuje, że modyfikator dostępu i modyfikator dziedziczenia to dwie niezależne, ortogonalne decyzje przy projektowaniu każdej metody - pierwsza odpowiada "kto może to zobaczyć", druga "czy i jak można to zmienić w podklasach".
Kiedy metoda może być nadpisana (override) w C
Warunek podstawowy - virtual, abstract lub override w klasie bazowej
Metoda musi być jawnie oznaczona jako możliwa do nadpisania - w C#, w przeciwieństwie do np. Javy, domyślnie metody NIE są nadpisywalne.
public class Animal
{
public void MakeSound() // zwykła metoda - NIE da się nadpisać
{
Console.WriteLine("Jakiś dźwięk");
}
public virtual void Move() // virtual - MOŻNA nadpisać
{
Console.WriteLine("Porusza się");
}
}
public class Dog : Animal
{
// ❌ Błąd kompilacji - MakeSound nie jest virtual, nie można użyć override
public override void MakeSound() { }
// ✅ OK - Move jest virtual w klasie bazowej
public override void Move()
{
Console.WriteLine("Biegnie");
}
}
Warunki, które MUSZĄ być spełnione przy override
Ta sama sygnatura (nazwa, parametry, typ zwracany)
public class Base
{
public virtual int Calculate(int x) => x * 2;
}
public class Derived : Base
{
// ❌ Błąd - inna sygnatura (inny typ parametru) to NIE override, to OVERLOAD (przeciążenie)
public override int Calculate(double x) => (int)(x * 2); // nie skompiluje się z "override"
// ✅ OK - dokładnie ta sama sygnatura
public override int Calculate(int x) => x * 3;
}
Widoczność (dostępność) nie może być zawężona
public class Base
{
public virtual void DoWork() { }
}
public class Derived : Base
{
protected override void DoWork() { } // ❌ Błąd - nie można zmniejszyć dostępności z public na protected
public override void DoWork() { } // ✅ OK - taka sama lub szersza widoczność
}
Żaden modyfikator dostępu nie wymusza nadpisania - to częsta pułapka pojęciowa
To pytanie miesza dwie różne kategorie modyfikatorów w C#, które łatwo pomylić.
Modyfikatory dostępu (access modifiers) - kontrolują widoczność (kto może zobaczyć/wywołać): public, private, protected, internal, protected internal, private protected
Modyfikatory dziedziczenia/polimorfizmu (inheritance modifiers) - kontrolują czy i jak metoda może być nadpisana: virtual, abstract, override, sealed, new
To są zupełnie osobne osie - możesz je łączyć ze sobą, ale żaden modyfikator dostępu sam z siebie nie wymusza nadpisania.
abstract to modyfikator z drugiej kategorii (dziedziczenia), nie modyfikator dostępu. Możesz go łączyć z dowolnym modyfikatorem dostępu:
public abstract void Process(Order order); // publiczne, wymuszone nadpisanie
protected abstract void Validate(Order order); // chronione, wymuszone nadpisanie
private + virtual/abstract to błąd kompilacji:
public class Base
{
private virtual void DoWork() { } // ❌ Błąd kompilacji: "virtual member cannot be private"
}
private oznacza "niewidoczne poza tą klasą", więc klasa pochodna nie może nawet zobaczyć tej metody, a co dopiero ją nadpisać. Modyfikator dostępu ogranicza możliwości modyfikatora dziedziczenia, ale go nie zastępuje.
Podsumowanie - poprawna odpowiedź na to pytanie
Żaden modyfikator dostępu (
public/protected/private/internal) nie wymusza nadpisania - to nie jest ich rola. Modyfikator dostępu odpowiada na pytanie "kto może to zobaczyć/wywołać". Wymuszenie nadpisania to rola modyfikatoraabstract(osobna kategoria - modyfikator dziedziczenia), który można łączyć z dowolnym modyfikatorem dostępu pozaprivate(boprivateczyni metodę niewidoczną dla klas pochodnych, więc nadpisanie byłoby niemożliwe fizycznie).