1.2 Klasser og objekter

Fra oppskrift til ferdig kake

I forrige kapittel fikk du vite hva objektorientert programmering er. Nå skal du faktisk skrive dine egne klasser. Tenk på en klasse som en oppskrift eller en mal. Er klassen oppskriften på en kake, er objektet den ferdige kaken. Du kan bake mange kaker fra samme oppskrift – hver kake er et unikt objekt, men alle følger samme mal.

La oss feste tre ord. En klasse er en mal som definerer hvilke attributter og metoder objekter av denne typen skal ha. Et objekt er en konkret instans av klassen, med sine egne verdier. Instans er bare et annet ord for objekt – vi sier at vi instansierer en klasse når vi lager et objekt av den.

Her er din første ekte klasse, en som representerer en person:

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

    def hilse(self):
        print(f"Hei, jeg heter {self.navn} og er {self.alder} år gammel.")

person1 = Person("Kari", 25)
person2 = Person("Ola", 30)
person1.hilse()  # Hei, jeg heter Kari og er 25 år gammel.

Vi definerer klassen med class Person:, lager en konstruktør __init__ som kjører automatisk når objektet opprettes, lagrer attributtene med self.navn og self.alder, definerer en metode hilse, og instansierer klassen to ganger.

Konstruktøren og det mystiske self

La oss se nærmere på de to delene som forvirrer flest. Konstruktøren er en spesiell metode som kjører automatisk når du lager et nytt objekt. I Python heter den alltid __init__, med to understreker på hver side. Den brukes til å sette startverdier for attributter og kjøre nødvendig oppsettskode. Du kan også gi attributter standardverdier, slik at det blir valgfritt å sende dem inn:

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

Her betyr saldo=0 at hvis brukeren ikke oppgir noen saldo, settes den automatisk til null.

Så til det mystiske self. Det dukker opp overalt, men er egentlig enkelt: self refererer til objektet selv – det objektet metoden kalles på. Når du skriver person1.hilse(), er self inni hilse-metoden lik person1. Tenk på det slik: når du sier «Jeg går til butikken», refererer «jeg» til deg selv. På samme måte refererer self til objektet som «snakker». Python krever at du eksplisitt sender med objektreferansen som første parameter i hver metode. Andre språk, som Java, bruker this, som virker mer automatisk.

Metoder som leser, endrer og returnerer

Metoder kan gjøre tre ting med objektet. De kan lese attributter, de kan endre dem, og de kan returnere verdier. At objektet holder styr på sin egen tilstand, er en av de store fordelene med OOP. Se hvordan bankkonto-metodene endrer self.saldo og samtidig validerer input:

    def sett_inn(self, belop):
        if belop > 0:
            self.saldo += belop

    def ta_ut(self, belop):
        if belop > self.saldo:
            print("Ikke nok penger på konto")
        elif belop <= 0:
            print("Beløpet må være positivt")
        else:
            self.saldo -= belop

Denne valideringen er fornuftig logikk som hører hjemme i Bankkonto-klassen. Andre metoder regner ut noe og returnerer resultatet, akkurat som vanlige funksjoner. En Rektangel-klasse kan ha areal() som returnerer self.lengde * self.bredde, omkrets() som returnerer 2 * (self.lengde + self.bredde), og er_kvadrat() som returnerer self.lengde == self.bredde.

En nøkkelinnsikt er at hvert objekt er uavhengig. Lager du tre hunder med hver sin navn, rase og alder, påvirker det ikke de andre om du endrer alderen på én. Det samme gjelder en enkel teller: lager du to Teller-objekter, øker hver sin egen verdi separat. Kaller du øk() to ganger på den første og én gang på den andre, blir verdiene 2 og 1 – ikke felles.

Sammensatte data og vanlige feller

Attributter kan være hvilken som helst datatype – inkludert lister, ordbøker og til og med andre objekter. En Handlekurv kan for eksempel ha en tom liste self.varer = [], en metode legg_til som legger til ordbøker med vare og pris, og en total_pris-metode som summerer prisene:

class Handlekurv:
    def __init__(self):
        self.varer = []

    def legg_til(self, vare, pris):
        self.varer.append({"vare": vare, "pris": pris})

    def total_pris(self):
        return sum(vare["pris"] for vare in self.varer)

Dette viser hvordan OOP rydder opp i kompleks data: én liste med ordbøker, samlet i ett objekt med metoder som hører til.

Til slutt: noen feil går igjen for nybegynnere, og du bør kjenne dem igjen. Skriver du def init i stedet for def __init__, blir konstruktøren aldri kjørt. Glemmer du self som første parameter i en metode, klager Python. Skriver du merke = merke i konstruktøren i stedet for self.merke = merke, lagres verdien bare i en lokal variabel som forsvinner. Og inne i en metode må du bruke self.merke, ikke bare merke, for å lese attributtet. Husker du disse fire, slipper du de vanligste klassefeilene.

Oppsummering

Vi gikk fra oppskrift til ferdig kake og skrev dine egne klasser. Du definerer en klasse med class KlasseNavn:, setter opp objektene i konstruktøren __init__(self, ...), lagrer attributter med self.attributt = verdi og skriver metoder som tar self som første parameter. self refererer alltid til objektet metoden kalles på, og standardverdier som saldo=0 gjør parametere valgfrie.

Metoder kan lese, endre og returnere – og objektet holder styr på sin egen tilstand, gjerne med validering innebygd. Hvert objekt du instansierer er uavhengig av de andre, med sine egne attributtverdier. Attributter kan være sammensatte data som lister og ordbøker. Pass deg for de vanlige fellene: feil navn på konstruktøren, manglende self-parameter, og attributter lagret uten self.. I neste kapittel ser vi på innkapsling – hvordan vi beskytter data i klasser og kontrollerer tilgangen til dem.