Kurs Python · Moduł 3: Programowanie obiektowe

Dziedziczenie - ewolucja gatunków

12 min czytania ·
W tej lekcji11

Witaj znowu! Tu Darwin, mam dla Ciebie fascynujący temat.

W poprzednich lekcjach nauczyłeś/aś się tworzyć klasy reprezentujące gatunki. Ale w naturze gatunki nie są izolowane - są częścią hierarchii taksonomicznej! Lwy i tygrysy to różne gatunki, ale oba są kotowatymi. Kotowate i psowate to różne rodziny, ale oba są ssakami.

W programowaniu obiektowym ta hierarchia to dziedziczenie (inheritance) - jeden z najpotężniejszych mechanizmów OOP!

Czym jest dziedziczenie?

Dziedziczenie pozwala tworzyć nowe klasy na podstawie istniejących:

  • Klasa bazowa (parent, superclass) - ogólniejsza, np. "Ssak"
  • Klasa pochodna (child, subclass) - bardziej specyficzna, np. "Lew"

Klasa pochodna dziedziczy atrybuty i metody klasy bazowej, a następnie może:

  • Używać dziedziczonych metod bez zmian
  • Rozszerzać klasy bazowe (dodawać nowe metody)
  • Nadpisywać metody (override) - zmienić zachowanie
# Klasa bazowa - ogólny Ssak
class Mammal:
    def __init__(self, name):
        self.name = name

    def breathe(self):
        return f"{self.name} oddycha powietrzem"

    def move(self):
        return f"{self.name} porusza się"

# Klasa pochodna - Lew dziedziczy z Mammal
class Lion(Mammal):
    def __init__(self, name, pride_name):
        super().__init__(name)  # Wywołaj konstruktor rodzica
        self.pride_name = pride_name  # Dodaj własny atrybut

    def roar(self):
        """Nowa metoda - tylko dla lwów"""
        return f"{self.name} ryczy: RRROAAR!"

    def move(self):
        """Nadpisanie metody rodzica"""
        return f"{self.name} biegnie przez sawannę"

# Użycie
simba = Lion("Simba", "Pride Rock")

# Dziedziczone z Mammal
print(simba.breathe())  # "Simba oddycha powietrzem"

# Nadpisane w Lion
print(simba.move())  # "Simba biegnie przez sawannę"

# Własna metoda Lion
print(simba.roar())  # "Simba ryczy: RRROAAR!"

# Własny atrybut Lion
print(simba.pride_name)  # "Pride Rock"

Składnia dziedziczenia

Nazwę klasy bazowej wpisujesz w nawiasie po nazwie nowej klasy. Klasa pochodna od razu dostaje wszystkie metody rodzica, a może też dodać własne:

# Podstawowa składnia
class ChildClass(ParentClass):
    pass

# Dziedziczenie z rozszerzeniem
class Animal:
    def eat(self):
        return "Jem"

class Dog(Animal):  # Dog dziedziczy z Animal
    def bark(self):
        return "Hau hau!"

dog = Dog()
print(dog.eat())   # Dziedziczone: "Jem"
print(dog.bark())  # Własne: "Hau hau!"

Funkcja super()

super() pozwala odwołać się do klasy bazowej - używaj jej do:

  • Wywołania konstruktora rodzica
  • Rozszerzenia metody rodzica (nie całkowitego nadpisania)
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print(f"Tworzę zwierzę: {name}")

    def describe(self):
        return f"{self.name}, wiek: {self.age}"

class Bird(Animal):
    def __init__(self, name, age, wingspan):
        # Wywołaj konstruktor Animal
        super().__init__(name, age)
        # Dodaj własny atrybut
        self.wingspan = wingspan
        print(f"Rozpiętość skrzydeł: {wingspan}m")

    def describe(self):
        # Rozszerz metodę rodzica
        base_desc = super().describe()  # Wywołaj Animal.describe()
        return f"{base_desc}, rozpiętość: {self.wingspan}m"

eagle = Bird("Orzeł", 5, 2.3)
# Drukuje:
# Tworzę zwierzę: Orzeł
# Rozpiętość skrzydeł: 2.3m

print(eagle.describe())  # "Orzeł, wiek: 5, rozpiętość: 2.3m"

Nadpisywanie metod (Method Overriding)

Klasa pochodna może całkowicie zastąpić metodę rodzica:

class Animal:
    def speak(self):
        return "Zwierzę wydaje dźwięk"

class Dog(Animal):
    def speak(self):
        """Nadpisz całkowicie"""
        return "Hau hau!"  # Całkowicie nowe zachowanie

class Cat(Animal):
    def speak(self):
        """Nadpisz całkowicie"""
        return "Miau!"

dog = Dog()
cat = Cat()

print(dog.speak())  # "Hau hau!" - nie "Zwierzę wydaje dźwięk"
print(cat.speak())  # "Miau!"

Hierarchia klas - drzewo taksonomiczne

W naturze hierarchia jest głęboka: Królestwo → Typ → Klasa → Rząd → Rodzina → Rodzaj → Gatunek

# 1. Królestwo Animalia
class Animal:
    kingdom = "Animalia"

    def __init__(self, name):
        self.name = name

    def is_alive(self):
        return True

    def __str__(self):
        return f"{self.name} ({self.__class__.__name__})"

# 2. Typ Chordata
class Chordate(Animal):
    phylum = "Chordata"

    def has_notochord(self):  # struna grzbietowa
        return True

# 3. Klasa Mammalia (Ssaki)
class Mammal(Chordate):
    class_name = "Mammalia"

    def __init__(self, name, fur_color):
        super().__init__(name)
        self.fur_color = fur_color

    def nurse_young(self):
        return f"{self.name} karmi młode mlekiem"

    def regulate_temperature(self):
        return f"{self.name} utrzymuje stałą temperaturę ciała"

# 4. Rząd Carnivora (Drapieżniki)
class Carnivore(Mammal):
    order = "Carnivora"

    def __init__(self, name, fur_color, hunting_style):
        super().__init__(name, fur_color)
        self.hunting_style = hunting_style

    def hunt(self):
        return f"{self.name} poluje używając: {self.hunting_style}"

# 5. Rodzina Felidae (Kotowate)
class Feline(Carnivore):
    family = "Felidae"

    def retract_claws(self):
        return f"{self.name} chowa pazury"

    def purr(self):
        return f"{self.name} mruczy"

# 6. Gatunek Panthera leo (Lew)
class Lion(Feline):
    species = "Panthera leo"

    def __init__(self, name, fur_color, pride_name):
        super().__init__(name, fur_color, "polowanie stadne")
        self.pride_name = pride_name

    def roar(self):
        return f"{self.name} ryczy głośno!"

    def lead_pride(self):
        return f"{self.name} przewodzi stadzie {self.pride_name}"

# Użycie - lew ma dostęp do WSZYSTKICH metod hierarchii!
simba = Lion("Simba", "złoty", "Pride Rock")

# Z Animal
print(simba.is_alive())  # True

# Z Chordate
print(simba.has_notochord())  # True

# Z Mammal
print(simba.nurse_young())  # "Simba karmi młode mlekiem"
print(simba.regulate_temperature())  # "Simba utrzymuje stałą temperaturę ciała"

# Z Carnivore
print(simba.hunt())  # "Simba poluje używając: polowanie stadne"

# Z Feline
print(simba.retract_claws())  # "Simba chowa pazury"
print(simba.purr())  # "Simba mruczy"

# Własne Lion
print(simba.roar())  # "Simba ryczy głośno!"
print(simba.lead_pride())  # "Simba przewodzi stadzie Pride Rock"

# Atrybuty
print(simba.kingdom)  # "Animalia"
print(simba.species)  # "Panthera leo"
print(simba.fur_color)  # "złoty"

Sprawdzanie relacji klas

Python oferuje funkcje do sprawdzania hierarchii:

class Animal:
    pass

class Mammal(Animal):
    pass

class Lion(Mammal):
    pass

simba = Lion()

# isinstance() - sprawdź czy obiekt jest instancją klasy
print(isinstance(simba, Lion))    # True
print(isinstance(simba, Mammal))  # True - Lion dziedziczy z Mammal
print(isinstance(simba, Animal))  # True - Lion dziedziczy z Animal (przez Mammal)
print(isinstance(simba, str))     # False

# issubclass() - sprawdź czy klasa dziedziczy z innej klasy
print(issubclass(Lion, Mammal))   # True
print(issubclass(Lion, Animal))   # True
print(issubclass(Mammal, Lion))   # False
print(issubclass(Lion, Lion))     # True - klasa jest podklasą samej siebie

# type() - zwróć dokładny typ
print(type(simba))  # <class '__main__.Lion'>
print(type(simba) == Lion)    # True
print(type(simba) == Mammal)  # False - simba to Lion, nie Mammal

Wielodziedziczenie (Multiple Inheritance)

Python pozwala dziedziczyć z wielu klas naraz - klasa może mieć wielu rodziców!

class Swimmer:
    def swim(self):
        return f"{self.name} pływa"

class Flyer:
    def fly(self):
        return f"{self.name} lata"

class Walker:
    def walk(self):
        return f"{self.name} chodzi"

# Duck dziedziczy z trzech klas!
class Duck(Swimmer, Flyer, Walker):
    def __init__(self, name):
        self.name = name

    def quack(self):
        return f"{self.name}: Kwa kwa!"

donald = Duck("Donald")

# Ma dostęp do metod ze wszystkich klas bazowych
print(donald.swim())   # "Donald pływa"
print(donald.fly())    # "Donald lata"
print(donald.walk())   # "Donald chodzi"
print(donald.quack())  # "Donald: Kwa kwa!"

MRO - Method Resolution Order

Gdy klasa dziedziczy z wielu rodziców, Python używa MRO (Method Resolution Order), aby określić kolejność szukania metod:

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):  # Dziedziczy z B i C
    pass

d = D()
print(d.method())  # "B" - Python szuka: D → B → C → A

# Sprawdź MRO
print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
#  <class '__main__.A'>, <class 'object'>)

# Lub czytelniej:
print(D.mro())

Zasada: Python przeszukuje klasy od lewej do prawej, od najbardziej specyficznej do najbardziej ogólnej.

Przykład z safari - hierarchia gatunków z obserwacjami

Teraz cała hierarchia safari: wspólna klasa Species, pod nią ssaki i ptaki, dalej drapieżniki i roślinożercy, a na samym dole kotowate i psowate. Każdy poziom dokłada swoje atrybuty i rozszerza describe() przez super().

class Species:
    """
    Klasa bazowa dla wszystkich gatunków w katalogu Safari
    """

    kingdom = "Animalia"
    total_species_count = 0

    def __init__(self, scientific_name, common_name, habitat):
        self.scientific_name = scientific_name
        self.common_name = common_name
        self.habitat = habitat
        self.observations = []

        Species.total_species_count += 1

    def add_observation(self, date, location, count, notes=""):
        """Dodaj obserwację w terenie"""
        self.observations.append({
            "date": date,
            "location": location,
            "count": count,
            "notes": notes
        })

    def get_total_observed(self):
        """Łączna liczba zaobserwowanych osobników"""
        return sum(obs["count"] for obs in self.observations)

    def describe(self):
        """Podstawowy opis gatunku"""
        return f"{self.common_name} ({self.scientific_name})"

    def __str__(self):
        return self.describe()

class Mammal(Species):
    """
    Klasa reprezentująca ssaki - rozszerza Species
    """

    class_name = "Mammalia"

    def __init__(self, scientific_name, common_name, habitat, fur_color, gestation_days):
        # Wywołaj konstruktor Species
        super().__init__(scientific_name, common_name, habitat)
        # Dodaj atrybuty specyficzne dla ssaków
        self.fur_color = fur_color
        self.gestation_days = gestation_days

    def nurse_young(self):
        """Ssaki karmią młode mlekiem"""
        return f"{self.common_name} karmi młode mlekiem (ciąża trwa {self.gestation_days} dni)"

    def describe(self):
        """Rozszerz opis o informacje o ssakach"""
        base = super().describe()  # Wywołaj Species.describe()
        return f"{base} | Ssak | Futro: {self.fur_color}"

class Bird(Species):
    """
    Klasa reprezentująca ptaki
    """

    class_name = "Aves"

    def __init__(self, scientific_name, common_name, habitat, wingspan_m, can_fly=True):
        super().__init__(scientific_name, common_name, habitat)
        self.wingspan_m = wingspan_m
        self.can_fly = can_fly

    def lay_eggs(self):
        return f"{self.common_name} składa jaja"

    def describe(self):
        base = super().describe()
        flight_status = "latający" if self.can_fly else "nielotny"
        return f"{base} | Ptak {flight_status} | Rozpiętość: {self.wingspan_m}m"

class Carnivore(Mammal):
    """
    Drapieżniki - dziedziczą z Mammal
    """

    order = "Carnivora"

    def __init__(self, scientific_name, common_name, habitat, fur_color,
                 gestation_days, hunting_style, pack_hunter=False):
        super().__init__(scientific_name, common_name, habitat, fur_color, gestation_days)
        self.hunting_style = hunting_style
        self.pack_hunter = pack_hunter

    def hunt(self):
        style = "w stadzie" if self.pack_hunter else "samotnie"
        return f"{self.common_name} poluje {style} używając: {self.hunting_style}"

    def calculate_danger_level(self):
        """Oblicz poziom niebezpieczeństwa (1-10)"""
        base_danger = 5
        if self.pack_hunter:
            base_danger += 3
        if "zasadzka" in self.hunting_style:
            base_danger += 2
        return min(10, base_danger)

    def describe(self):
        base = super().describe()
        danger = self.calculate_danger_level()
        return f"{base} | Drapieżnik | Niebezp.: {danger}/10"

class Herbivore(Mammal):
    """
    Roślinożercy - dziedziczą z Mammal
    """

    def __init__(self, scientific_name, common_name, habitat, fur_color,
                 gestation_days, diet_type):
        super().__init__(scientific_name, common_name, habitat, fur_color, gestation_days)
        self.diet_type = diet_type  # "liście", "trawa", "owoce"

    def graze(self):
        return f"{self.common_name} je {self.diet_type}"

    def describe(self):
        base = super().describe()
        return f"{base} | Roślinożerca | Dieta: {self.diet_type}"

class Feline(Carnivore):
    """
    Kotowate - dziedziczą z Carnivore
    """

    family = "Felidae"

    def __init__(self, scientific_name, common_name, habitat, fur_color,
                 gestation_days, has_mane=False, pride_size=1):
        super().__init__(
            scientific_name, common_name, habitat, fur_color,
            gestation_days, "zasadzka i pościg", pack_hunter=(pride_size > 1)
        )
        self.has_mane = has_mane
        self.pride_size = pride_size

    def retract_claws(self):
        return f"{self.common_name} chowa ostre pazury"

    def stalk_prey(self):
        return f"{self.common_name} skrada się cicho do zdobyczy"

    def describe(self):
        base = super().describe()
        social = f"stadne ({self.pride_size})" if self.pride_size > 1 else "samotne"
        return f"{base} | Kotowate | {social}"

class Canine(Carnivore):
    """
    Psowate - dziedziczą z Carnivore
    """

    family = "Canidae"

    def __init__(self, scientific_name, common_name, habitat, fur_color,
                 gestation_days, pack_size=1):
        super().__init__(
            scientific_name, common_name, habitat, fur_color,
            gestation_days, "pościg na dystansie", pack_hunter=(pack_size > 1)
        )
        self.pack_size = pack_size

    def howl(self):
        return f"{self.common_name} wyje do stada"

    def track_scent(self):
        return f"{self.common_name} tropi zdobycz po zapachu"

    def describe(self):
        base = super().describe()
        social = f"wataha ({self.pack_size})" if self.pack_size > 1 else "samotne"
        return f"{base} | Psowate | {social}"

# === DEMONSTRACJA - Tworzenie hierarchii Safari ===

print("=== KATALOG GATUNKÓW SAFARI - HIERARCHIA ===\n")

# Kotowate
lion = Feline(
    scientific_name="Panthera leo",
    common_name="Lew",
    habitat="sawanna",
    fur_color="złoty",
    gestation_days=110,
    has_mane=True,
    pride_size=15
)

leopard = Feline(
    scientific_name="Panthera pardus",
    common_name="Lampart",
    habitat="sawanna i lasy",
    fur_color="żółty w czarne plamy",
    gestation_days=90,
    has_mane=False,
    pride_size=1  # Samotnik
)

# Psowate
wild_dog = Canine(
    scientific_name="Lycaon pictus",
    common_name="Likaon",
    habitat="sawanna",
    fur_color="pstrokaty",
    gestation_days=70,
    pack_size=20
)

# Roślinożercy
elephant = Herbivore(
    scientific_name="Loxodonta africana",
    common_name="Słoń afrykański",
    habitat="sawanna",
    fur_color="szary",
    gestation_days=645,  # Najdłuższa ciąża!
    diet_type="liście, kora, trawa"
)

giraffe = Herbivore(
    scientific_name="Giraffa camelopardalis",
    common_name="Żyrafa",
    habitat="sawanna",
    fur_color="żółty w brązowe plamy",
    gestation_days=440,
    diet_type="liście akacji"
)

# Ptaki
eagle = Bird(
    scientific_name="Aquila rapax",
    common_name="Orzeł sawannowy",
    habitat="sawanna",
    wingspan_m=2.1,
    can_fly=True
)

# Dodaj obserwacje
lion.add_observation("2024-01-15", "Serengeti", 12, "Stado polujące na gnu")
lion.add_observation("2024-01-20", "Masai Mara", 8, "Rodzina z młodymi")
leopard.add_observation("2024-01-16", "Obszar skalny", 1, "Samotny samiec")
wild_dog.add_observation("2024-01-18", "Savuti", 18, "Wataha polująca")
elephant.add_observation("2024-01-17", "Amboseli", 45, "Duże stado przy wodopoju")
giraffe.add_observation("2024-01-19", "Tarangire", 23, "Żyrafy żerujące na akacjach")
eagle.add_observation("2024-01-21", "Niebo nad sawanną", 3, "Para z młodym")

# Wyświetl opisy - każdy używa swojej wersji describe()
print("LEW:")
print(f"  {lion.describe()}")
print(f"  {lion.hunt()}")
print(f"  {lion.stalk_prey()}")
print(f"  {lion.retract_claws()}")
print(f"  {lion.nurse_young()}")
print(f"  Obserwacje: {lion.get_total_observed()} osobników")

print(f"\nLAMPART:")
print(f"  {leopard.describe()}")
print(f"  {leopard.hunt()}")
print(f"  Poziom niebezpieczeństwa: {leopard.calculate_danger_level()}/10")

print(f"\nLIKAON:")
print(f"  {wild_dog.describe()}")
print(f"  {wild_dog.hunt()}")
print(f"  {wild_dog.howl()}")
print(f"  {wild_dog.track_scent()}")

print(f"\nSŁOŃ:")
print(f"  {elephant.describe()}")
print(f"  {elephant.graze()}")
print(f"  Obserwacje: {elephant.get_total_observed()} osobników")

print(f"\nŻYRAFA:")
print(f"  {giraffe.describe()}")
print(f"  {giraffe.graze()}")

print(f"\nORZEŁ:")
print(f"  {eagle.describe()}")
print(f"  {eagle.lay_eggs()}")

# Sprawdź hierarchię
print(f"\n=== HIERARCHIA KLAS ===")
print(f"Lew dziedziczy z Feline? {isinstance(lion, Feline)}")
print(f"Lew dziedziczy z Carnivore? {isinstance(lion, Carnivore)}")
print(f"Lew dziedziczy z Mammal? {isinstance(lion, Mammal)}")
print(f"Lew dziedziczy z Species? {isinstance(lion, Species)}")
print(f"Lew dziedziczy z Bird? {isinstance(lion, Bird)}")

print(f"\nMRO Feline: {[cls.__name__ for cls in Feline.mro()]}")
# ['Feline', 'Carnivore', 'Mammal', 'Species', 'object']

print(f"\n=== STATYSTYKI ===")
print(f"Łączna liczba gatunków w katalogu: {Species.total_species_count}")

# Polimorfizm - każdy gatunek ma swoją implementację describe()
print(f"\nWszystkie gatunki:")
all_animals = [lion, leopard, wild_dog, elephant, giraffe, eagle]
for animal in all_animals:
    print(f"  - {animal.describe()}")

Praktyczne zasady dziedziczenia

1. Kiedy używać dziedziczenia?

Użyj dziedziczenia gdy:

  • Relacja "jest" (is-a): Lew jest Ssakiem
  • Chcesz reużyć kod z klasy bazowej
  • Tworzysz hierarchię typów

NIE używaj dziedziczenia gdy:

  • Relacja "ma" (has-a): Samochód ma Silnik (użyj kompozycji!)
  • Klasy nie mają wspólnej natury
  • Chcesz tylko pożyczyć kilka metod
# Dobre - relacja "jest"
class Animal:
    pass

class Dog(Animal):  # Pies JEST zwierzęciem
    pass

# Złe - relacja "ma"
class Engine:
    def start(self):
        return "Silnik uruchomiony"

class Car(Engine):  # NIE! Samochód NIE JEST silnikiem!
    pass

# Dobre - kompozycja
class Car:
    def __init__(self):
        self.engine = Engine()  # Samochód MA silnik

    def start(self):
        return self.engine.start()

2. Zasada podstawienia Liskov (LSP)

Obiekt klasy pochodnej powinien móc zastąpić obiekt klasy bazowej bez zmiany poprawności programu.

def make_sound(animal):
    """Funkcja przyjmuje dowolne Animal"""
    print(animal.speak())

class Animal:
    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Hau!"

class Cat(Animal):
    def speak(self):
        return "Miau!"

# LSP - Dog i Cat mogą zastąpić Animal
make_sound(Dog())  # "Hau!" - działa
make_sound(Cat())  # "Miau!" - działa

3. Unikaj głębokiej hierarchii

Każdy poziom dziedziczenia to kolejna klasa, którą trzeba przeczytać, żeby zrozumieć obiekt. Porównaj sześć pustych poziomów z trzema, które coś znaczą:

# Złe - zbyt głęboka hierarchia
class A:
    pass
class B(A):
    pass
class C(B):
    pass
class D(C):
    pass
class E(D):
    pass
class F(E):  # 6 poziomów!
    pass

# Dobre - płaska, zrozumiała hierarchia
class Animal:
    pass

class Mammal(Animal):
    pass

class Lion(Mammal):
    pass

Trzy poziomy, Animal → Mammal → Lion, czyta się od razu. Gdy hierarchia rośnie ponad trzy lub cztery poziomy, sprawdź, czy części zachowań nie lepiej przenieść do kompozycji.

Podsumowanie

W tej lekcji nauczyłeś/aś się:

  • Czym jest dziedziczenie i dlaczego jest potężne
  • Jak tworzyć klasy pochodne z class Child(Parent)
  • Używania super() do wywołania metod rodzica
  • Nadpisywania i rozszerzania metod
  • Budowania hierarchii klas (drzewo taksonomiczne)
  • Sprawdzania relacji z isinstance() i issubclass()
  • Wielodziedziczenia i MRO
  • Praktycznych zasad: kiedy używać dziedziczenia, a kiedy nie

Checkpoint

Przed przejściem dalej:

  • Rozumiesz różnicę między klasą bazową a pochodną
  • Potrafisz użyć super() w konstruktorze
  • Wiesz jak nadpisać metodę rodzica
  • Rozumiesz hierarchię i dziedziczenie wielu poziomów
  • Znasz różnicę między relacją "jest" (dziedziczenie) a "ma" (kompozycja)

Analogia Safari: Hierarchia klas to drzewo ewolucyjne - każdy potomek dziedziczy cechy przodków, ale rozwija własne unikalne adaptacje!

W następnej lekcji Darwin nauczy Cię enkapsulacji - jak chronić wrażliwe dane gatunków przed nieautoryzowanym dostępem!

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jak zdefiniować klasę Cat dziedziczącą po Animal?

  2. 2. Do czego służy super().__init__()?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy w prawidłowej kolejności:

  • Edytor kodu

    Stwórz klasę Tiger dziedziczącą po Animal(name, species): w __init__ wywołaj super().__init__(name, species) i dodaj atrybut stripes. Utwórz jednego tygrysa

  • Edytor kodu

    Klasa Animal ma metodę speak(). Nadpisz ją w klasie Tiger(Animal) tak, aby wyświetlała 'Rrrrr!'. Utwórz tygrysa i wywołaj speak()

  • Układanie w poziomie

    Ułóż nagłówek klasy Tiger, która dziedziczy po klasie Animal:

  • Klikanie w kolejności

    Kliknij elementy wywołania konstruktora klasy nadrzędnej z argumentem name:

  1. PytanieDziedziczenie
  2. PytanieFunkcja super()
  3. PytanieNadpisywanie metod
  4. Ułóż w kolejnościTworzenie instancji
  5. Zadanie z kodemKlasa potomna
  6. Zadanie z kodemNadpisywanie metod
  7. Ułóż w kolejnościDziedziczenie
  8. Kliknij w kolejnościWywołanie super()

Przydatne artykuły