C# / .NET Kompendium PLEN
.NET / C# / C# — fundamenty języka

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 modyfikatora abstract (osobna kategoria - modyfikator dziedziczenia), który można łączyć z dowolnym modyfikatorem dostępu poza private (bo private czyni metodę niewidoczną dla klas pochodnych, więc nadpisanie byłoby niemożliwe fizycznie).

Postaw mi kawę