---
# System prepended metadata

title: 'Programmering 2: Klasser'
tags: [studiematerial]

---

# Programmering 2: Klasser

Den mest centrala biten i objektorienterad programmering (och i kursen) är klasser. Klasser är ett sätt att skapa nya variabeltyper och används för att gruppera data och funktioner i mindre återanvändbara delar.

### Klasser som variabeltyper

Vi har stött på klasser tidigare genom att vi har jobbat med mer komplexa variabeltyper, dvs variabeltyper som innehåller flera variabler. Till exempel klassen `Vector3` som innehåller tre stycken `float`: `x`, `y`, `z`.

Vi kan skapa våra egna variabeltyper genom att skapa en ny `klass`. Det gör vi genom att skapa en ny kodfil i Visual Studio genom att klicka på *Project --> Add class* och ge den ett namn, t.ex. *Cat* om vi vill ha en variabeltyp som representerar en katt.

![image](https://hackmd.io/_uploads/ryaSLMWhll.png)

Jag får då en ny fil som (bland annat) innehåller följande kod:

```csharp
class Cat
{
}
```

Här används ordet *class* följt av ett namn och sedan måsvingar. Den kod vi skriver innanför måsvingarna till hör klassen. Här kan vi lägga till klassvariabler, också kallat *properties* eller egenskaper på svenska. Dessa variabler ska representera egenskaper hos klassen.

```csharp
class Cat {
    string name;
    int age
    string color;
}
```

Vi kan nu skapa variabler av typen `Cat`. Dessa variabler kallas för objekt.

```csharp
static void Main(string[] args)
{
    Cat minKatt = new Cat();
}
```

Vi kan komma åt kattens egenskaper (variblerna innuti Cat-klassen) på följande sätt.

```csharp
static void Main(string[] args)
{
    Cat minKatt = new Cat();
    
    minKatt.name = "Findus";
    minKatt.age = 8;
    minKatt.color = "orange";
}
```

Om vi gör så här kommer vi dock få ett fel! "... is inaccessable to due its protection level". Vi behöver ange att man får komma åt klassens variabler genom att lägga till ordet `public` framöver dem.

```csharp
class Cat {
    public string name;
    public int age
    public string color;
}
```

### Klassmetoder

En klass kan också innehålla *metoder*. Om vi tänker oss att klassens variabler representerar egenskaper hos en klass, representerar metoderna saker som klassen kan *göra*. Till exempel kan en katt kan säga mjau, åldras och presentera sig själv. Det kan vi implementera som tre metoder: `Meow`, `IncreaseAge` och `PrintInfo`.

```csharp
class Cat {
    public string name;
    public int age
    public string color;

    public void Meow(){
        Console.WriteLine("Mjau!");
    }

    public void IncreaseAge(){
        age++;
    }

    public void PrintInfo(){
        Console.WriteLine("Jag heter " + name + ", jag är " + age 
                          + " år gammal och är färgen " + color);
    }
}
```

Notera här att metoderna också anges som `public` så att vi kan komma åt dem från andra ställen i vår kod. Vi kan nu använda vår klass till exempel så här:

```csharp
static void Main(string[] args)
{
    //Skapar ett katt-objekt för Findus
    Cat kattA = new Cat();
    kattA.name = "Findus";
    kattA.age = 8;
    kattA.color = "orange";

    //Skapar ett katt-objekt för Bosse
    Cat kattB = new Cat();
    kattB.name = "Bosse";
    kattB.age = 12;
    kattB.color = "svart";

    //Båda katterna åldras ett år
    kattA.IncreaseAge();
    kattB.IncreaseAge();

    //Vi får info om båda katterna
    kattA.PrintInfo();
    kattB.PrintInfo();
}
```

Då får vi följande utskrift:

```
Jag heter Findus, jag är 9 år gammal och är färgen orange
Jag heter Bosse, jag är 13 år gammal och är färgen svart
```

### Konstruktorer

Det är väldigt ofta som vi vill sätta värden på variablerna i en klass i samband med att vi skapar ett objekt. Det här kan vi smidigt göra genom att lägga till en konstruktor i klassen. En konstruktor är som en metod, men det har ingen returtyp och måste heta exakt samma som klassen.

```csharp
class Cat{
    
    //Konstruktor (ingen returtyp och samma namn som klassen)
    public Cat(){
        //Den här koden körs när objektet skapas
        
    }
    
}
```

När vi nu skriver `new Cat()` kommer koden i konstruktorn att köras.

Vi kan även lägga till argument i konstruktorn, precis som en vanlig metod. För varje argument måste vi då ange ett motsvarande värde mellan parenteserna när vi skapar objektet med `new`.

Följande konstruktor:
```csharp
class Cat{
    
    //Konstruktor med argument name, age och color
    public Cat(string name, int age, string color){

    }    
}
```
matchas med att objekt skapas genom

```csharp
Cat minKatt = new Cat("Findus", 8, "orange");
```

Det är väldigt ofta vi anger argument i konstruktorn som ska användas för att sätta värden på klassens variabler. Argumenten och klassvariablerna kan ha samma namn, vilket gör att man behöver förtydliga vilken som är vilken. Klassvariabler kan vi ange genom att först skriva `this`. En vanlig konstruktor för katt-klassen skulle då se ut så här.

```csharp
class Cat {
    public string name;
    public int age
    public string color;

    public Cat(string name, int age, string color){
        this.name = name;
        this.age = age;
        this.color = color;
    }
}
```


