11 Programowanie Obiektowe III

Dziedziczenie 


1
2
class Pochodna(Bazowa):
      pass

Klasa bazowa nazywana jest parent, superclass, base class.
Klasa pochodnia nazywana jest subclass, derived.


Przykład, na bazie klasy Czlowiek, tworzone są dwie klasy pochodne Dorosly i Dziecko:

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class Czlowiek:
    def __init__(self,imie,nazwisko):
        self.imie=imie
        self.nazwisko= nazwisko

class Dorosly(Czlowiek):
    pass

class Dziecko(Czlowiek):
    pass


osoba1=Dorosly("Zenon","Domyslny")
osoba2=Dziecko("Zenonek","Niedomyślny")

print(osoba1.imie)
print(osoba2.nazwisko)
wynik:

Zenon
Niedomyślny

klasy Dorosly i Dziecko  dziedziczą z superklasy w całości metodę __init__ i nie mają swoich metod.



Nadpisywanie metod klasy bazowej


W klasie pochodnej Dorosly, możemy nadpisać metodę __init__.
Jak widać nowa metoda ma dodany atrybut 'pseudonim'.
Żeby się nie powtarzać przypisanie zmiennych imię i nazwisko możemy skopiować z superklasy za pomocą polecenia:

super().__init__(imie,nazwisko)

 Przykład:
1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Czlowiek:
    def __init__(self,imie,nazwisko):
        self.imie=imie
        self.nazwisko= nazwisko

class Dorosly(Czlowiek):
    def __init__(self,imie,nazwisko,pseudonim):
        super().__init__(imie,nazwisko)
        self.pseudonim=pseudonim



osoba1=Dorosly("Zenon","Domyslny","Banita")

print(osoba1.pseudonim)

nadpisywać i wywoływać przez super można metody, ale nie specjalne.


Mamy możliwość dziedziczenia z typów wbudowanych, jak lista słownik itp.

Na bazie list stwórzmy własną klasę i dodajmy jej metodę znajdującą  średnią:

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class MojaLista(list):
    
    def srednia(self):
        wynik=sum(self)
        wynik=wynik/len(self)
        return wynik


x=MojaLista( )
x.append(1)
x.append(2)
x.append(3)

print(x.srednia())

wynik:
2



Argument funkcji *args

Służy do przekazywania dowolnej liczby nie nazwanych parametrów do funkcji.

1
2
3
4
5
6
7
def too ( arg1 , arg2 ,*argv ):
    print ( "normalne argumenty:" , arg1 )
    for arg in argv :
        print ( "parametr *argv :" , arg )
    print ( "normalne argumenty:" , arg2 )

too("Dzień", "Jak", 1,2,3,4,"Codzień" )

Wynik:
normalne argumenty: Dzień
parametr *argv : 1
parametr *argv : 2
parametr *argv : 3
parametr *argv : 4
parametr *argv : Codzień
normalne argumenty: Jak



Dziedziczenie wielobazowe

 Jest możliwe dziedziczenie jednoczesne z dwóch klas:

1
class Jakas(Domek,Mieszkanie) :




Agregacja

 Nowa klasa powstaje przez użycie obiektów klas już istniejących.

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
class Reka:
    def __init__(self,ktora):
        self.ktora=ktora
        
class Noga:
    def __init__(self,ktora):
        self.ktora=ktora

class CialoSamo:
    def __init__ (self):
        self.lewa_reka=Reka("LEWA" )
        self.prawa_reka=Reka("PRAWA" )
        self.lewa_noga=Noga("LEWA" )
        self.prawa_noga=Noga("PRAWA" )

cialo = CialoSamo ( )

print(cialo.lewa_reka.ktora)
wynik:

LEWA

Obiekt ciało składa się z argumentów które w rzeczywistości są obiektami klas Reka i Noga.
.