Objektorienterad programmering (OOP)

💡 Vad är OOP?

OOP är som att bygga med LEGO! 🧱

Tänk dig att du ska bygga en hel stad. Istället för att ha en jättestor klump av kod, delar du upp allt i små, smarta objekt:

🚗 Bil-objekt - kan accelerera, bromsa, tuta
🏠 Hus-objekt - har adress, ägare, färg
👤 Person-objekt - har namn, ålder, kan gå, prata

Varje objekt vet vad det ska göra och har sina egna superkrafter (metoder) och egenskaper (properties)!

🎯 TL;DR

OOP = bygga program som LEGO. Skapa objekt (klasser) med egenskaper och beteenden. Enkelt att återanvända, ändra och förstå. Fyra grundpelare: Inkapsling, Arv, Polymorfism, Abstraktion.

📋 Efter att ha läst detta kommer du att kunna

Förstå vad OOP är och varför det är så användbart 🧠
Skapa klasser och objekt i C-Sharp 🏗️
Använda de fyra grundpelarna i OOP ⚡
Se skillnaden mellan objekt och klasser 👀
Bygga enkla men kraftfulla program med OOP 🚀

🔧 De fyra grundpelarna i OOP

🏰 1. Inkapsling (Encapsulation)

“Håll privata saker privata”

Tänk på ditt bankkonto - du kan se saldot och sätta in pengar, men banken låter dig INTE direkt ändra saldot genom att skriva in ett nytt nummer!

public class BankKonto
{
    private decimal saldo; // 🔒 Privat - ingen kan ändra direkt!

    public decimal GetSaldo() // 👀 Kan bara KOLLA saldot
    {
        return saldo;
    }

    public void SättaIn(decimal summa) // ✅ Säker metod att ändra saldot
    {
        if (summa > 0)
            saldo += summa;
    }
}

🧬 2. Arv (Inheritance)

“Ärv superkrafter från föräldrar”

Precis som du ärvt egenskaper från dina föräldrar, kan klasser ärva från andra klasser:

// 🐾 Basdjur
public class Animal
{
    public string Name { get; set; }
    public void Eat() => Console.WriteLine($"{Name} äter");
}

// 🐕 Hund ärver från Animal
public class Dog : Animal
{
    public void Bark() => Console.WriteLine($"{Name} skäller: Woof!");
}

// 🐱 Katt ärver från Animal
public class Cat : Animal
{
    public void Meow() => Console.WriteLine($"{Name} jamar: Mjau!");
}

🎭 3. Polymorfism (Polymorphism)

“Samma sak, olika sätt”

Alla djur kan göra ljud, men på olika sätt:

public abstract class Animal
{
    public abstract void MakeSound(); // Alla måste implementera detta!
}

public class Dog : Animal
{
    public override void MakeSound() => Console.WriteLine("Woof!");
}

public class Cat : Animal
{
    public override void MakeSound() => Console.WriteLine("Mjau!");
}

// 🎪 Magi - samma metod, olika beteende!
List<Animal> djur = new List<Animal> { new Dog(), new Cat() };
foreach(Animal djuret in djur)
{
    djuret.MakeSound(); // Dog säger Woof, Cat säger Mjau!
}

🎨 4. Abstraktion (Abstraction)

“Visa bara det viktiga”

När du kör bil behöver du inte veta hur motorn fungerar - du trycker bara på gasen!

public abstract class Vehicle
{
    public abstract void StartEngine(); // Vad som ska hända
    public abstract void Drive();       // men inte HOW det händer
}

public class Car : Vehicle
{
    public override void StartEngine() => Console.WriteLine("🚗 Bilmotor startar");
    public override void Drive() => Console.WriteLine("🛣️ Kör på vägen");
}

✨ Fördelar med OOP

🧩 Modularitet

Som LEGO-klossar!

// Varje klass är som en LEGO-kloss
public class Player { } // 🎮 Spelare
public class Enemy { }  // 👾 Fiende
public class Weapon { } // ⚔️ Vapen
// Enkelt att kombinera på olika sätt!

🔄 Återanvändbarhet

Skriv en gång, använd överallt!

// Samma Person-klass kan användas i:
// - Skol-system (Student extends Person)
// - Sjukhus-system (Patient extends Person)
// - HR-system (Employee extends Person)
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

🛠️ Lätt att underhålla

Ändra en sak utan att förstöra allt annat!

// Om du ändrar hur Car fungerar...
public class Car
{
    private void ImprovedEngine() // 🔧 Ny förbättring!
    {
        // ...bara Car påverkas, inte hela programmet!
    }
}

🎯 Abstraktion

Fokusera på VHAT, inte HOW

// Du behöver inte veta HOW SendEmail fungerar
EmailService.SendEmail("test@test.com", "Hej!");
// Du bara använder det! 🚀

⚠️ När OOP kan bli krångligt

🧗 Inlärningskurva

Många nya begrepp att lära sig

Klasser, objekt, arv, polymorfism…
Lösning: Ta en sak i taget! Börja med enkla klasser.

🐌 Prestanda

Ibland lite långsammare

Extra “lager” kan göra kod långsammare
Lösning: Oftast märker du inte skillnaden! Bara viktigt i extrema fall.

🕸️ Överkomplexitet

Risk att göra enkla saker komplicerade

// 🚨 ÖVERKILL för enkel räknare
public abstract class AbstractCalculatorFactoryBuilder
{
    // 50 rader kod för att addera 2+2...
}

// ✅ ENKELT är bättre
public class Calculator
{
    public int Add(int a, int b) => a + b; // 🎯 Klart!
}

🎮 Användningsområden för OOP

🏢 Applikationsutveckling

// Bankssystem med objekt
public class Account { }
public class Customer { }
public class Transaction { }
// Tydlig struktur! 💼

🎯 Spelutveckling

public class Player { }
public class Enemy { }
public class PowerUp { }
public class GameLevel { }
// Perfekt för spel! 🕹️

🌐 Webbutveckling

public class User { }
public class BlogPost { }
public class Comment { }
// MVC-mönster använder OOP! 🌎

🔬 Simuleringar

public class Particle { }
public class ForceField { }
public class PhysicsEngine { }
// Modellera verkligheten! ⚗️

🗄️ Databashantering

// Entity Framework använder OOP
public class Product { }
public class Order { }
public class Customer { }
// Databas + Objekt = ❤️

🚀 OOP i praktiken - Bil-exempel

🟢 Grundläggande klass

// 🚗 Bil-klass med inkapsling
public class Car
{
    // 🔒 Privata fält (inkapsling)
    private string brand;
    private string color;
    private int speed;

    // 🏗️ Konstruktor (bygger objektet)
    public Car(string brand, string color)
    {
        this.brand = brand;
        this.color = color;
        this.speed = 0; // Börjar stillastående
    }

    // ⚡ Metoder (vad bilen kan göra)
    public void Accelerate(int value)
    {
        speed += value;
        Console.WriteLine($"🏎️ Accelererar till {speed} km/h");
    }

    public void Brake(int value)
    {
        speed = Math.Max(0, speed - value); // Kan inte ha negativ hastighet
        Console.WriteLine($"🛑 Bromsar till {speed} km/h");
    }

    // 👀 Getter (säkert sätt att se hastighet)
    public int GetSpeed() => speed;

    public void StartEngine()
    {
        Console.WriteLine($"🔥 {brand} startar motorn!");
    }
}

🟡 Använda klassen

public class Program
{
    public static void Main()
    {
        // 🏗️ Skapa ett bil-objekt
        Car minBil = new Car("Volvo", "röd");

        // 🎮 Använd bilens metoder
        minBil.StartEngine();      // 🔥 Volvo startar motorn!
        minBil.Accelerate(50);     // 🏎️ Accelererar till 50 km/h
        minBil.Accelerate(30);     // 🏎️ Accelererar till 80 km/h
        minBil.Brake(20);          // 🛑 Bromsar till 60 km/h

        Console.WriteLine($"Slutlig hastighet: {minBil.GetSpeed()} km/h");
    }
}

🔴 Utvidgat med arv

// 🏎️ Racerbil ärver från Car
public class RaceCar : Car
{
    private bool turboMode;

    public RaceCar(string brand, string color) : base(brand, color)
    {
        turboMode = false;
    }

    public void ActivateTurbo()
    {
        turboMode = true;
        Console.WriteLine("🚀 TURBO AKTIVERAT!");
        Accelerate(100); // Extra snabb acceleration!
    }
}

// 🚌 Buss ärver också från Car
public class Bus : Car
{
    private int passengers;

    public Bus(string brand, string color) : base(brand, color)
    {
        passengers = 0;
    }

    public void PickUpPassengers(int count)
    {
        passengers += count;
        Console.WriteLine($"🚌 {count} passagerare klev på. Totalt: {passengers}");
    }
}

🎓 Begrepp att komma ihåg

Begrepp	Förklaring	Exempel
Klass	Ritning/mall för objekt	`class Car`
Objekt	Instans av en klass	`new Car()`
Inkapsling	Hålla data privat	`private int speed`
Arv	Ärva från annan klass	`class RaceCar : Car`
Polymorfism	Samma metod, olika beteende	`override MakeSound()`
Abstraktion	Förenkla komplexitet	`abstract class Vehicle`

📚 Sammanfattning

OOP = smart sätt att organisera kod:

🧱 Klasser - Ritningar för objekt
🏗️ Objekt - Instanser av klasser
🔒 Inkapsling - Skydda data
🧬 Arv - Återanvänd och utöka kod
🎭 Polymorfism - Flexibel kod
🎨 Abstraktion - Förenkla komplexitet

🎯 Övningar

🟢 Grundläggande: Skapa en Person-klass med namn och ålder
🟡 Utmanande: Skapa Student och Teacher som ärver från Person
🔴 Expert: Bygg ett enkelt djurpark-system med polymorfism

😄 Obligatorisk dad joke

Varför gillar programmerare OOP?

För att de älskar att ha klass! 🎩📚