🚀 Grunnleggende Java-syntaks for OOP

Økt 2: Klassenes anatomi, felter, metoder og this

Læringsmål for dagens økt:

Forstå klassenes struktur og anatomi
Lære om felter (attributter) i klasser
Mestre metoder og deres signaturer
Bruke this-nøkkelordet effektivt
Skrive din første Point-klasse
Lage objekter og bruke dem i main-metoden

Velkommen til en praktisk reise inn i Java og objektorientert programmering! 🎯

🔄 Rask repetisjon fra forrige økt

💭 Tenk-par-del spørsmål:

Hva er objektorientert programmering?

Diskuter med sidemannen i 2 minutter, deretter deler vi med klassen.

Viktige konsepter vi bygger videre på:

Klasse: En mal eller blueprint for å lage objekter
Objekt: En konkret instans av en klasse
OOP: En programmeringsparadigme basert på objekter og klasser

I dag skal vi dykke dypere inn i hvordan vi faktisk skriver disse klassene i Java! 📝

🏗️ Klassenes anatomi

En Java-klasse består av flere viktige deler. La oss se på strukturen:

public class Point {
    // 1. FELTER (attributter/instansvariabler)
    private int x;
    private int y;
    
    // 2. KONSTRUKTØRER
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    // 3. METODER
    public int getX() {
        return x;
    }
}

🔧 Klassehode:

public - synlighet
class - Java-nøkkelord
Point - klassenavn

📦 Klassekropp:

Felter (data)
Konstruktører
Metoder (oppførsel)

📊 Felter - Klassens data

Felter er variabler som tilhører klassen og representerer objektets tilstand:

public class Point {
    // Instansfelter - hver Point har sine egne verdier
    private int x;       // x-koordinat
    private int y;       // y-koordinat
    private String name; // navn på punktet
    
    // Klassefelt - deles av alle objekter
    private static int pointCount = 0;
}

🎯 Viktige prinsipper for felter:

✅ Bra praksis:

private - skjul data
Beskrivende navn
Initialisering

❌ Unngå:

public felter
Uklare navn (a, b, c)
Uinitialiserte felter

💡 Interaktiv oppgave: Identifiser felter

🤔 Hvilke felter trenger en Student-klasse?

Tenk deg at du skal lage en klasse som representerer en student. Diskuter i grupper på 2-3:

Hvilke egenskaper har en student?
Hvilke datatyper bør disse egenskapene ha?
Hvilke bør være private/public?

📝 Oppgave (5 minutter):

Skriv ned minst 5 felter for en Student-klasse med riktige datatyper:

public class Student {
    // Dine felter her...
    private _________ _________;
    private _________ _________;
    // osv...
}

⚡ Metoder - Klassens oppførsel

Metoder definerer hva objekter kan gjøre. De har en spesifikk struktur:

Metodesignatur:

synlighet returtype metodenavn(parametere)

public class Point {
    private int x, y;
    
    // Getter-metode
    public int getX() {
        return x;  // returnerer x-verdien
    }
    
    // Setter-metode
    public void setX(int newX) {
        x = newX;  // setter ny x-verdi
    }
    
    // Beregningsmetode
    public double distanceFromOrigin() {
        return Math.sqrt(x * x + y * y);
    }
}

🔍 Ulike typer metoder

Getter-metoder

Formål: Hente verdier

public int getX() {
    return x;
}

Returnerer alltid en verdi
Ingen parametere (vanligvis)
Navn starter med "get"

Setter-metoder

Formål: Endre verdier

public void setX(int x) {
    this.x = x;
}

Returnerer void
Tar imot en parameter
Navn starter med "set"

Beregningsmetoder

Formål: Utføre beregninger eller logikk

public double distanceTo(Point other) {
    int dx = x - other.x;
    int dy = y - other.y;
    return Math.sqrt(dx * dx + dy * dy);
}

Kan returnere forskjellige typer
Kan ta imot flere parametere
Beskrivende navn basert på funksjon

👆 this-nøkkelordet

this refererer til det gjeldende objektet. Det brukes når vi trenger å være eksplisitte:

public class Point {
    private int x, y;
    
    // this løser navnekonflikt
    public void setX(int x) {
        this.x = x;  // this.x = feltet, x = parameteren
    }
    
    // this gjør koden klarere
    public void moveBy(int dx, int dy) {
        this.x = this.x + dx;
        this.y = this.y + dy;
    }
    
    // this for å kalle andre metoder
    public void reset() {
        this.setX(0);
        this.setY(0);
    }
}

🎯 Når bruke this?

Navnekonflikt: Parameter og felt har samme navn
Klarhet: Gjøre det tydelig at vi refererer til objektets felt
Metodekall: Kalle andre metoder i samme klasse

🚀 main-metoden - programmets startpunkt

main-metoden er der Java-programmet vårt starter. Her lager vi objekter og bruker dem:

public class Point {
    // ... alle felt og metoder ...
    
    // main-metoden - programmets startpunkt
    public static void main(String[] args) {
        // Lage objekter
        Point p1 = new Point(3, 4);
        Point p2 = new Point(0, 0);
        
        // Bruke objektene
        System.out.println("p1 x: " + p1.getX());
        System.out.println("p1 y: " + p1.getY());
        
        // Kalle metoder
        p1.setX(5);
        double distance = p1.distanceFromOrigin();
        System.out.println("Avstand fra origo: " + distance);
    }
}

🎯 Komplett Point-klasse eksempel

La oss se på en fullstendig Point-klasse som viser alle konseptene:

public class Point {
    // FELTER
    private int x;
    private int y;
    
    // KONSTRUKTØR
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    // GETTER-METODER
    public int getX() {
        return this.x;
    }
    
    public int getY() {
        return this.y;
    }
    
    // SETTER-METODER
    public void setX(int x) {
        this.x = x;
    }
    
    public void setY(int y) {
        this.y = y;
    }
    
    // BEREGNINGSMETODER
    public double distanceFromOrigin() {
        return Math.sqrt(this.x * this.x + this.y * this.y);
    }
    
    public double distanceTo(Point other) {
        int dx = this.x - other.x;
        int dy = this.y - other.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    // MAIN-METODE
    public static void main(String[] args) {
        Point p1 = new Point(3, 4);
        Point p2 = new Point(6, 8);
        
        System.out.println("p1: (" + p1.getX() + ", " + p1.getY() + ")");
        System.out.println("Avstand fra origo: " + p1.distanceFromOrigin());
        System.out.println("Avstand mellom punktene: " + p1.distanceTo(p2));
    }
}

💻 Praktisk oppgave - Lag din første klasse!

🎯 Oppgave: Lag en Circle-klasse (15 minutter)

Instruksjoner:

Lag en klasse som heter Circle
Felter: radius (double) og centerX, centerY (int)
Lag getter- og setter-metoder for alle felter
Lag en metode getArea() som returnerer arealet (π × radius²)
Lag en metode getCircumference() som returnerer omkretsen (2 × π × radius)
Skriv en main-metode som tester klassen

public class Circle {
    // Dine felter her...
    
    // Konstruktør
    public Circle(______) {
        // Din kode her...
    }
    
    // Dine metoder her...
    
    public static void main(String[] args) {
        // Test klassen din her...
    }
}

Tips: Bruk Math.PI for π-verdien!

🤝 Gruppediskusjon og problemløsing

💡 Diskusjonsspørsmål (10 minutter):

Gruppe A & B:

Hvilke utfordringer møtte dere når dere skrev Circle-klassen?
Hvorfor er det viktig å gjøre felter private?
Når brukte dere this-nøkkelordet?

Gruppe C & D:

Hvordan testet dere at metodene deres fungerte?
Hvilke andre metoder kunne vært nyttige i Circle-klassen?
Hva er forskjellen på felter og lokale variabler?

🔄 Presentasjon:

Hver gruppe velger en representant som deler:

En utfordring de møtte og hvordan de løste den
Et tips til resten av klassen
Ett spørsmål de fortsatt lurer på

⚠️ Vanlige feil og hvordan unngå dem

❌ Vanlige feil:

// Glemmer this ved navnekonflikt
public void setX(int x) {
    x = x;  // Feil! Setter parameter til seg selv
}

// Public felter
public int x;  // Dårlig praksis!

// Manglende returtype
public getX() {  // Feil! Mangler returtype
    return x;
}

✅ Riktig måte:

// Bruk this ved navnekonflikt
public void setX(int x) {
    this.x = x;  // Riktig!
}

// Private felter med getter/setter
private int x;  // Bra praksis!

// Spesifiser alltid returtype
public int getX() {  // Riktig!
    return x;
}

🎯 Beste praksis tips:

Navngiving: Bruk beskrivende og konsistente navn
Innkapsling: Gjør felter private, bruk getter/setter
Dokumentasjon: Skriv kommentarer for komplekse metoder
Testing: Test alltid klassene dine i main-metoden

🚀 Utfordring for raske studenter

🏆 Avansert oppgave: Rectangle-klasse

Lag en Rectangle-klasse med følgende funksjonalitet:

Felter: width, height, x, y (for øvre venstre hjørne)
Metoder:
- getArea() - returnerer arealet
- getPerimeter() - returnerer omkretsen
- contains(Point p) - sjekker om punktet er inne i rektangelet
- overlaps(Rectangle other) - sjekker om to rektangler overlapper

💭 Bonusspørsmål:

Hvordan kan du sjekke om et punkt er innenfor et rektangel?
Hvilken matematikk trengs for å sjekke om to rektangler overlapper?
Hvordan kan du lage en metode som flytter rektangelet?

Hint: Et punkt (px, py) er inne i rektangel hvis: px ≥ x && px ≤ x+width && py ≥ y && py ≤ y+height

📋 Oppsummering og veien videre

🎯 Hva har vi lært i dag?

📚 Teori:

Klassenes anatomi og struktur
Felter og deres rolle
Metoder og metodesignaturer
this-nøkkelordet

💻 Praksis:

Skrevet Point-klasse
Lagd Circle-klasse
Brukt main-metoden for testing
Anvendt beste praksis

🔮 Neste økt: Innkapsling

private/public - kontrollere tilgang
Getters/Setters - sikker dataaksess
Immutability - objekter som ikke kan endres
Refaktorering - forbedre Point-klassen

📝 Hjemmeoppgave til neste gang:

Fullfør Circle-klassen og Rectangle-klassen (hvis ikke gjort). Prøv å lage en Car-klasse med felter som brand, model, year, speed og metoder som accelerate(), brake(), og toString().

Tusen takk for en aktiv økt! Spørsmål? 🙋‍♂️🙋‍♀️