Klass (programmering)

Från Wikipedia
Hoppa till: navigering, sök

Klass är i objektorienterad programmering ett avsnitt programkod som samlar en mängd relaterade attribut och funktioner, även kallat metoder. Det är ett viktigt kännetecken för en klass att dess inre struktur inte är tillgänglig utanför klassen, utan den kan enbart manipuleras genom ett specificerat gränssnitt. Fenomenet att en klass privata delar ej är tillgängliga utanför kallas inkapsling (eng. encapsulation). En klass kan sägas vara en användardefinierad datatyp, som alltså kompletterar de fördefinierade datatyperna, i C++ till exempel int och char. För att de klasserna skall likna just användardefinierade datatyper använder man i vissa språk överlagring av operatorer för klasser.

Arvshierarkier[redigera | redigera wikitext]

Objektorienterade programmeringsspråk tillåter klasser att ärva egenskaper från andra klasser i ett eller flera led. En klass som en annan klass ärver egenskaper ifrån kallas för superklass (överklass, härledd klass) medan den klass som ärver egenskaperna benämns subklass, eller underklass (eller basklass).

Exempel på klass i C++[redigera | redigera wikitext]

#include <string>
class example
{
    public:
        example(int no, string s); //Konstruktor
        void add(int no); //Metod för att addera värden med variabeln value
        void subtract(int no); //Metod för att subtrahera från variabeln value
        void change_name(string s); //Metod för att ändra innehållet i strängvariabeln name
 
    protected:
        int value; //En heltalsvariabel 
        std::string name; //En strängvariabel
 
};
 
example::example(int no, string s)
{
    value = no; //Initering av de båda variablerna
    name = s;
}
 
void example::add(int no)
{
    value += no; //no adderas till value
}
 
void example::subtract(int no)
{
    value -= no; //no subtraheras från value
}
 
void example::change_name(string s)
{
    name = s; //name ändras till s
}
 
int main()
{
    example test(10, "test"); //Objektet test initieras, value = 10, name = test
    test.add(10); //value ökar med 10
    test.subtract(5); //value minskar med 5, innehåller just nu 15
    test.change_name("example"); //Variabeln name ändras från test till example
    return 0;
}

Koden ovan definierar en klass som består av en variabel av typen int och en variabel av typen string (som inte är en primitiv datatyp, utan en egen klass). Dessutom anges metoder för att manipulera dessa värden, men inte för att hämta information från klassen. Ingen utskrift kan därför heller ske i huvudprogrammet, eftersom datan har gömts för alla utom arvingar till klassen (se vidare nedan).

Exempel på en subklass i C++[redigera | redigera wikitext]

Exempleklassen ovan saknar vissa metoder som kan vara bra att ha och dessutom kanske man vill kunna lagra ytterligare värden förutom ett heltal och en textsträng. Ett alternativ är då att skapa en subklass till klassen exempel (i stället för att skriva om koden till klassen example). Det ser ut så här:

class betterexample : public example
{
    //En klass är default private, alltså måste följande rad inte skrivas.
    //private:
        double anothervalue; //Ett attribut av typen double
 
    public:
        betterexample(int no, string s, double an); //Konstruktor
        int getValue(); //Metod för att komma åt value, som finns i superklassen
        string getName(); //Metod för att hämta name, som också finns i superklassen
        double getAnothervalue(); //Metod för att hämta anothervalue, som bara finns i subklassen
};
 
betterexample::betterexample(int no, string s, double an): example(no, s) //Anrop till superklassens konstruktor
{
    anothervalue = an; //Initiering av den egna variabeln
}
 
int betterexample::getValue() 
{
    return value; //Hämtar value som definierats i superklassen
}
 
string betterexample::getName()
{
    return name; //Hämtar name som definierats i superklassen
}
 
double betterexample::getAnothervalue()
{
    return anothervalue; //Hämtar another value som definierats på plats i subklassen
}

Här ärver klassen betterexample alla attribut och metoder från klassen example. Därtill definieras ett eget attribut, ett flyttal kallat "anothervalue" liksom metoder som kan användas för att hämta alla värden som lagras i klassen. Om man lägger till koden för betterexample till den som redan finns för example skulle man kunna definiera ett huvudprogram som ser ut så här:

int main()
{
 
    betterexample nytt_test(10, "nytt test", 20.5); //Skapar ett objekt av typen betterexample
    nytt_test.add(20); //adderar 20 till heltalet value
    cout << nytt_test.getValue() << endl; //skriver ut värdet av value 
    cout << nytt_test.getAnothervalue() << endl; //Skriver ut värdet av anothervalue
    cout << nytt_test.getName() << endl; //Skriver ut värdet av name
 
    return 0;
}

Utskriften från detta program blir:

30
20.5
nytt test

Abstrakt klass[redigera | redigera wikitext]

I objektorienterad programmering kan abstrakta klasser definieras. Detta är klasser som inte kan instansieras, vilket innebär att det inte går att skapa objekt av klassen. I stället får man definiera en klass som ärver den abstrakta, och på så sätt skapa objekt.

Ett exempel kan vara klassen Däggdjur. I den kan definieras egenskaper och metoder som är gemensamma för alla däggdjur, men ett antal egenskaper som storlek, dräktighetstid etc kan inte definieras utan att veta vilket djur det rör sig om. Typiskt anger Däggdjur att det har en längd, men kan inte svara på hur stor den är.

Genom att definiera Människa och Delfin som klasser som ärver Däggdjur, och tillföra specifika egenskaper och metoder för sådant som skiljer, kan man både få god utvecklingsekonomi och en beskrivande struktur.

Abstrakta klasser är också praktiska för användare. Ett program för en zoologisk trädgård har troligen behov av att hålla kollektioner av objekt som har klassen Däggdjur eller rentav Djur, och nöjer sig med att resp objekt själv vet vilken klass det egentligen implementerar.

Interface kan ses som ett specialfall av abstrakta klasser. Dessa innehåller enbart definitioner av metoder, och ingen implementering alls.