Klasy abstrakcyjne – szablony, które wymuszają implementację

public class Postac
{
    public string Imie { get; set; }
    public int PunktyZycia { get; set; }
    
    public virtual void Atakuj()
    {
        Console.WriteLine("Atakuję jakoś...");  // 🤔 Jak? Czym?
    }
}

// Klasy pochodne mają sens:
Wojownik conan = new Wojownik();   // ✅ OK - wojownik atakuje mieczem
Mag gandalf = new Mag();           // ✅ OK - mag rzuca czary

// Ale co z tym?
Postac ktos = new Postac();         // 🤔 Kim jest "Postac"?
ktos.Atakuj();                       // "Atakuję jakoś..." - bez sensu!

// Klasa abstrakcyjna – nie można utworzyć jej instancji
public abstract class Postac
{
    // Zwykłe pola i właściwości – działają normalnie
    public string Imie { get; set; }
    public int PunktyZycia { get; set; }
    
    // Zwykła metoda – działa normalnie, dziedziczona przez klasy pochodne
    public void PrzedstawSie()
    {
        Console.WriteLine($"Jestem {Imie}, mam {PunktyZycia} HP");
    }
    
    // Metoda abstrakcyjna – BEZ ciała! Klasy pochodne MUSZĄ ją zaimplementować
    public abstract void Atakuj();  // Zwróć uwagę: średnik zamiast { }
}

// Klasa konkretna – dziedziczy i MUSI zaimplementować Atakuj()
public class Wojownik : Postac
{
    public int Sila { get; set; }
    
    // MUSIMY nadpisać metodę abstrakcyjną!
    public override void Atakuj()
    {
        Console.WriteLine($"{Imie} atakuje mieczem z siłą {Sila}!");
    }
}

// ❌ TO NIE ZADZIAŁA:
// Postac postac = new Postac();  // BŁĄD KOMPILACJI!
// "Cannot create an instance of the abstract type 'Postac'"

// ✅ TO DZIAŁA:
Wojownik conan = new Wojownik();
conan.Imie = "Conan";
conan.PunktyZycia = 100;
conan.Sila = 15;

conan.PrzedstawSie();  // Działa – odziedziczona metoda
conan.Atakuj();        // Działa – nasza implementacja

// Możemy też użyć zmiennej typu Postac (polimorfizm):
Postac p = new Wojownik();  // ✅ OK – zmienna bazowa, obiekt pochodny
p.Atakuj();                 // Wywoła Wojownik.Atakuj()

public abstract class Ksztalt
{
    public string Nazwa { get; set; }
    public string Kolor { get; set; }
    
    // Każdy kształt MUSI umieć obliczyć swoje pole
    public abstract double ObliczPole();
    
    // Każdy kształt MUSI umieć obliczyć swój obwód
    public abstract double ObliczObwod();
    
    // Zwykła metoda – wspólna dla wszystkich
    public void WyswietlInfo()
    {
        Console.WriteLine($"{Nazwa} ({Kolor})");
        Console.WriteLine($"Pole: {ObliczPole():F2}");
        Console.WriteLine($"Obwód: {ObliczObwod():F2}");
    }
}

public class Prostokat : Ksztalt
{
    public double Szerokosc { get; set; }
    public double Wysokosc { get; set; }
    
    public override double ObliczPole()
    {
        return Szerokosc * Wysokosc;
    }
    
    public override double ObliczObwod()
    {
        return 2 * (Szerokosc + Wysokosc);
    }
}

public class Kolo : Ksztalt
{
    public double Promien { get; set; }
    
    public override double ObliczPole()
    {
        return Math.PI * Promien * Promien;
    }
    
    public override double ObliczObwod()
    {
        return 2 * Math.PI * Promien;
    }
}

Prostokat p = new Prostokat 
{ 
    Nazwa = "Prostokąt", 
    Kolor = "Niebieski", 
    Szerokosc = 5, 
    Wysokosc = 3 
};

Kolo k = new Kolo 
{ 
    Nazwa = "Koło", 
    Kolor = "Czerwony", 
    Promien = 4 
};

p.WyswietlInfo();
// Prostokąt (Niebieski)
// Pole: 15.00
// Obwód: 16.00

k.WyswietlInfo();
// Koło (Czerwony)
// Pole: 50.27
// Obwód: 25.13

public class Postac  // Zwykła klasa
{
    public string Imie { get; set; }
    public int PunktyZycia { get; set; }
    
    public virtual void Atakuj()
    {
        Console.WriteLine("Atakuję jakoś...");  // 😕 Bezsensowna implementacja
    }
}

public class Wojownik : Postac
{
    public override void Atakuj()
    {
        Console.WriteLine($"{Imie} atakuje mieczem!");
    }
}

public class Mag : Postac
{
    // 😱 Programista ZAPOMNIAŁ nadpisać Atakuj()!
    // Kod się skompiluje, ale Mag będzie "atakował jakoś..."
}

// Problemy:
Postac p = new Postac();  // 😕 Można utworzyć – a nie powinno się dać!
Mag m = new Mag();
m.Atakuj();            // 😕 "Atakuję jakoś..." – błąd logiczny!

public abstract class Postac  // Klasa abstrakcyjna
{
    public string Imie { get; set; }
    public int PunktyZycia { get; set; }
    
    // Metoda wspólna – ma implementację
    public void PrzedstawSie()
    {
        Console.WriteLine($"Jestem {Imie}");
    }
    
    public abstract void Atakuj();  // ✅ Brak implementacji – MUSI być nadpisana!
}

public class Wojownik : Postac
{
    public int Sila { get; set; }
    
    public override void Atakuj()  // ✅ MUSI być – inaczej błąd kompilacji
    {
        Console.WriteLine($"{Imie} atakuje mieczem!");
    }
}

public class Mag : Postac
{
    public int Mana { get; set; }
    
    public override void Atakuj()  // ✅ Musi być – kompilator wymusza!
    {
        Console.WriteLine($"{Imie} rzuca kulę ognia!");
    }
}

// Teraz:
// Postac p = new Postac();  // ❌ BŁĄD KOMPILACJI! Nie można utworzyć
Wojownik w = new Wojownik();  // ✅ OK
Mag m = new Mag();              // ✅ OK – Mag MA Atakuj() (musiał zaimplementować!)

public abstract class Zwierze
{
    public string Nazwa { get; set; }
    
    // ABSTRACT: Każde zwierzę wydaje INNY dźwięk – nie ma sensownego domyślnego
    public abstract void WydajDzwiek();
    
    // VIRTUAL: Większość zwierząt je podobnie, ale niektóre mogą inaczej
    public virtual void Jedz()
    {
        Console.WriteLine($"{Nazwa} je.");  // Sensowne domyślne zachowanie
    }
    
    // ZWYKŁA: Wszystkie zwierzęta śpią tak samo
    public void Spij()
    {
        Console.WriteLine($"{Nazwa} śpi. Zzz...");
    }
}

public class Pies : Zwierze
{
    // MUSI nadpisać WydajDzwiek() – abstract
    public override void WydajDzwiek()
    {
        Console.WriteLine("Hau hau!");
    }
    
    // MOŻE nadpisać Jedz() – virtual (ale nie musi)
    // Jeśli nie nadpisze, użyje domyślnej wersji
}

public class Waz : Zwierze
{
    public override void WydajDzwiek()
    {
        Console.WriteLine("Sss...");
    }
    
    // Wąż je inaczej – nadpisujemy virtual
    public override void Jedz()
    {
        Console.WriteLine($"{Nazwa} połyka ofiarę w całości!");
    }
}

public abstract class Pojazd
{
    public string Marka { get; set; }
    
    // Właściwość abstrakcyjna – każdy pojazd MUSI określić liczbę kół
    public abstract int LiczbaKol { get; }
    
    // Właściwość abstrakcyjna z get i set
    public abstract double MaxPredkosc { get; set; }
    
    public void WyswietlInfo()
    {
        Console.WriteLine($"{Marka}: {LiczbaKol} koła, max {MaxPredkosc} km/h");
    }
}

public class Samochod : Pojazd
{
    // Implementacja właściwości abstrakcyjnej (tylko get)
    public override int LiczbaKol => 4;  // Zawsze 4
    
    // Implementacja właściwości abstrakcyjnej (get i set)
    private double _maxPredkosc;
    public override double MaxPredkosc
    {
        get => _maxPredkosc;
        set => _maxPredkosc = value > 0 ? value : 0;
    }
}

public class Motocykl : Pojazd
{
    public override int LiczbaKol => 2;  // Zawsze 2
    
    public override double MaxPredkosc { get; set; }
}

public class Trojkolowiec : Pojazd
{
    public override int LiczbaKol => 3;  // Zawsze 3
    
    public override double MaxPredkosc { get; set; }
}

Samochod auto = new Samochod { Marka = "Toyota", MaxPredkosc = 180 };
Motocykl motor = new Motocykl { Marka = "Yamaha", MaxPredkosc = 220 };

auto.WyswietlInfo();   // Toyota: 4 koła, max 180 km/h
motor.WyswietlInfo();  // Yamaha: 2 koła, max 220 km/h

public abstract class Dokument
{
    public string Tytul { get; set; }
    public DateTime DataUtworzenia { get; set; } = DateTime.Now;
    
    // ABSTRACT – każdy dokument ma INNY format, MUSI być nadpisana
    public abstract string Formatuj();
    
    // VIRTUAL – domyślne zachowanie, ale MOŻNA nadpisać
    public virtual void Drukuj()
    {
        Console.WriteLine("=== DRUKOWANIE ===");
        Console.WriteLine(Formatuj());
        Console.WriteLine("===================");
    }
    
    // ZWYKŁA – wspólna dla wszystkich, NIE MOŻNA nadpisać
    public void WyswietlMetadane()
    {
        Console.WriteLine($"Tytuł: {Tytul}");
        Console.WriteLine($"Utworzono: {DataUtworzenia:d}");
    }
}

public class Raport : Dokument
{
    public string Autor { get; set; }
    public string Tresc { get; set; }
    
    // MUSI zaimplementować Formatuj() – abstract
    public override string Formatuj()
    {
        return $"RAPORT: {Tytul}\nAutor: {Autor}\n\n{Tresc}";
    }
    
    // MOŻE nadpisać Drukuj() – virtual
    public override void Drukuj()
    {
        Console.WriteLine("*** RAPORT OFICJALNY ***");
        base.Drukuj();  // Wywołaj bazową wersję
        Console.WriteLine("*** KONIEC RAPORTU ***");
    }
}

public class Notatka : Dokument
{
    public string Tresc { get; set; }
    
    // MUSI zaimplementować
    public override string Formatuj()
    {
        return $"[Notatka] {Tytul}: {Tresc}";
    }
    
    // NIE nadpisuje Drukuj() – użyje domyślnej wersji
}

// Poziom 1: Najbardziej ogólna klasa abstrakcyjna
public abstract class Istota
{
    public string Nazwa { get; set; }
    
    public abstract void Zyj();  // Każda istota żyje jakoś
}

// Poziom 2: Nadal abstrakcyjna – dodaje nowe wymagania
public abstract class Zwierze : Istota
{
    public int Wiek { get; set; }
    
    // Implementuje Zyj() z Istota
    public override void Zyj()
    {
        Console.WriteLine($"{Nazwa} żyje jako zwierzę");
    }
    
    // Dodaje NOWĄ metodę abstrakcyjną
    public abstract void WydajDzwiek();
}

// Poziom 3: Nadal abstrakcyjna – bardziej szczegółowa
public abstract class Ssak : Zwierze
{
    public bool MaSiersc { get; set; } = true;
    
    // NIE implementuje WydajDzwiek() – nadal abstract!
    // Dodaje nową metodę abstrakcyjną
    public abstract void KarmMlodem();
}

// Poziom 4: Klasa KONKRETNA – musi zaimplementować WSZYSTKO!
public class Pies : Ssak
{
    public string Rasa { get; set; }
    
    // MUSI zaimplementować WydajDzwiek() (z Zwierze)
    public override void WydajDzwiek()
    {
        Console.WriteLine("Hau hau!");
    }
    
    // MUSI zaimplementować KarmMlodem() (z Ssak)
    public override void KarmMlodem()
    {
        Console.WriteLine($"{Nazwa} karmi szczenięta mlekiem");
    }
}

// KLASA ABSTRAKCYJNA – ma wspólny kod
public abstract class Zwierze
{
    public string Nazwa { get; set; }  // Pole!
    
    public void Oddychaj()              // Wspólna implementacja!
    {
        Console.WriteLine("Oddycham...");
    }
    
    public abstract void WydajDzwiek();
}

// INTERFEJS – tylko kontrakt
public interface IPlywa
{
    void Plyn();  // Tylko deklaracja – brak implementacji
}

// Klasa może dziedziczyć po 1 klasie i implementować WIELE interfejsów
public class Delfin : Zwierze, IPlywa
{
    public override void WydajDzwiek()
    {
        Console.WriteLine("Iii iii!");
    }
    
    public void Plyn()
    {
        Console.WriteLine("Płynę!");
    }
}

public abstract class KlasaBazowa
{
    // Zwykłe pola i właściwości
    public string Pole { get; set; }
    
    // Metoda abstrakcyjna – MUSI być nadpisana
    public abstract void MetodaWymagana();
    
    // Metoda virtual – MOŻE być nadpisana
    public virtual void MetodaOpcjonalna() { }
    
    // Zwykła metoda – NIE można nadpisać
    public void MetodaWspolna() { }
}

public class KlasaKonkretna : KlasaBazowa
{
    public override void MetodaWymagana()
    {
        // Implementacja WYMAGANA
    }
    
    // MetodaOpcjonalna – możemy nadpisać lub nie
    // MetodaWspolna – używamy jak jest
}