1.4 Arv og gjenbruk

Arv og gjenbruk

Tenk deg at du har laga ein god Bil-klasse med masse nyttig funksjonalitet. No vil du lage ein Elbil-klasse. Elbilar er bilar, men med nokre ekstra eigenskapar (batteri, lading). Må du skrive all Bil-koden på nytt?

Nei! Dette er der arv kjem inn. Arv lèt deg lage ein ny klasse basert på ein eksisterande klasse – du arvar alle attributtar og metodar, og kan deretter leggje til eller endre det du treng.

Arv er ein av dei fire grunnpilarane i OOP, og handlar om gjenbruk av kode og hierarkiske relasjonar.

Utvide med nye attributtar og metodar

Når du arvar, kan du leggje til nye attributtar og metodar i subklassen:

class Dyr:
    def __init__(self, navn, alder):
        self.navn = navn
        self.alder = alder

    def beskriv(self):
        print(f"{self.navn} er {self.alder} år gammel")

class Hund(Dyr):
    def __init__(self, navn, alder, rase):
        self.navn = navn
        self.alder = alder
        self.rase = rase  # Nytt attributt

    def apporter(self):  # Ny metode
        print(f"{self.navn} apporterer!")

# Bruk
hund = Hund("Fido", 3, "Golden Retriever")
hund.beskriv()    # Fido er 3 år gammel (arvet)
hund.apporter()   # Fido apporterer! (ny)
print(hund.rase)  # Golden Retriever (nytt attributt)

Men her er det eit problem: Vi gjentek kode i __init__. Løysinga er super().

Override – overstyre metodar

Når ein subklasse definerer ein metode med same namn som i superklassen, seier vi at han overstyrer (overrides) metoden. Dette lèt oss spesialisere oppførselen:

class Bankkonto:
    def __init__(self, kontonummer, saldo=0):
        self.kontonummer = kontonummer
        self.saldo = saldo

    def ta_ut(self, belop):
        if belop <= self.saldo:
            self.saldo -= belop
            return True
        print("Ikke nok penger")
        return False

class Sparekonto(Bankkonto):
    def __init__(self, kontonummer, saldo=0, min_saldo=1000):
        super().__init__(kontonummer, saldo)
        self.min_saldo = min_saldo

    def ta_ut(self, belop):
        # Overstyrt versjon med ekstra regel
        if self.saldo - belop < self.min_saldo:
            print(f"Kan ikke ta ut – må ha minst {self.min_saldo} kr")
            return False
        return super().ta_ut(belop)  # Kaller Bankkonto.ta_ut

# Bruk
vanlig = Bankkonto("11111111", 2000)
vanlig.ta_ut(1900)  # OK
print(vanlig.saldo)  # 100

spare = Sparekonto("22222222", 2000, min_saldo=1000)
spare.ta_ut(1100)  # Kan ikke ta ut – må ha minst 1000 kr
spare.ta_ut(900)   # OK
print(spare.saldo)  # 1100

Sparekonto har strengare reglar, men gjenbruker logikken frå Bankkonto via super().

isinstance() – sjekke objekttype

Nokre gonger må du sjekke om eit objekt er av ein bestemt klasse, eller arvar frå ein klasse. Til dette bruker vi isinstance():

class Dyr:
    pass

class Hund(Dyr):
    pass

class Katt(Dyr):
    pass

# Lag objekter
hund = Hund()
katt = Katt()

# isinstance(objekt, Klasse) returnerer True/False
print(isinstance(hund, Hund))   # True
print(isinstance(hund, Dyr))    # True (Hund arver fra Dyr)
print(isinstance(hund, Katt))   # False

print(isinstance(katt, Katt))   # True
print(isinstance(katt, Dyr))    # True
print(isinstance(katt, Hund))   # False

# isinstance kan også sjekke mot tuple av klasser
print(isinstance(hund, (Hund, Katt)))  # True (hund er Hund)

Brukstilfelle:
- Validere input til funksjonar
- Ulik behandling av forskjellige objekttypar
- Unngå feil når du kallar metodar som berre finst i visse subklassar

Hierarki og spesialisering

Arv lèt oss byggje hierarki av klassar, frå generelle til spesifikke:

        Dyr
         |
    +----+----+
    |         |
  Pattedyr  Fugl
    |         |
  +---+     +---+
  |   |     |   |
Hund Katt Ørn Spurv

Dette vert kalla spesialisering (nedover i hierarkiet) eller generalisering (oppover):

class Dyr:
    def __init__(self, navn):
        self.navn = navn

    def spis(self):
        print(f"{self.navn} spiser")

class Pattedyr(Dyr):
    def die(self):
        print(f"{self.navn} dier")

class Hund(Pattedyr):
    def bjeff(self):
        print(f"{self.navn}: Voff!")

# Hund arver fra både Pattedyr og Dyr
hund = Hund("Fido")
hund.spis()   # Fra Dyr
hund.die()    # Fra Pattedyr
hund.bjeff()  # Fra Hund

is-a relasjonen gjeld heile vegen:
- Ein Hund "er eit" Pattedyr
- Eit Pattedyr "er eit" Dyr
- Difor: Ein Hund "er eit" Dyr

Dette vert stadfesta med isinstance:

print(isinstance(hund, Hund))      # True
print(isinstance(hund, Pattedyr))  # True
print(isinstance(hund, Dyr))       # True

Når skal du bruke arv?

Arv er kraftig, men kan òg misbrukast. Her er retningslinjer:

Bruk arv når:
- Det er ein klar "is-a" relasjon (ein Elbil er ein Bil)
- Subklassen er ei spesialisering av superklassen
- Du vil gjenbruke mykje felles kode
- Endringar i superklassen skal påverke subklassane

Ikkje bruk arv når:
- Relasjonen er "has-a" (ein Bil har ein Motor – bruk komposisjon)
- Du berre vil gjenbruke noko kode (vurder funksjonar eller komposisjon)
- Hierarkiet vert for djupt (meir enn 3-4 nivå)

Eksempel på "has-a" (komposisjon):

# FEIL: Bil arver fra Motor
class Motor:
    pass

class Bil(Motor):  # Gir ikke mening – en bil er ikke en motor!
    pass

# RIKTIG: Bil har en Motor
class Motor:
    def __init__(self, hestekrefter):
        self.hestekrefter = hestekrefter

class Bil:
    def __init__(self, merke):
        self.merke = merke
        self.motor = Motor(150)  # Bil HAR en motor

Tommelfingerregel: "Favor composition over inheritance" (Føretrekk komposisjon over arv) når du er i tvil.

Oppsummering

I dette kapittelet har du lært:

- Arv: ein subklasse overtek attributtar og metodar frå ein superklasse.
- super(): kallar metodane til superklassen.
- Override: overstyre ein metode i subklassen.
- isinstance(): sjekkar typen til objektet.
- Har-en vs. er-en: arv vert brukt ved er-en-forhold.

Noekkelbegreper