Hoofdstuk 9 — Methoden en Parameteroverdracht (structuur en hergebruik)

Methoden groeperen gedrag en maken code herbruikbaar. Je leert methodesignatures, parameters, returntypes, overloading, parameter-passing (by value), en scope van variabelen. Ook kijken we kort naar statische vs. instantie-methoden.

Voorbeeld 1 — Basis: definitie en aanroep

public class MethodenBasis {
    static int som(int a, int b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(som(2, 3));
    }
}

Voorbeeld 2 — Return typen en void

public class ReturnVoid {
    static double gemiddelde(int a, int b) {
        return (a + b) / 2.0;
    }
    static void groet(String naam) {
        System.out.println("Hallo, " + naam);
    }
    public static void main(String[] args) {
        System.out.println(gemiddelde(3, 5));
        groet("Kim");
    }
}

Voorbeeld 3 — Overloading (zelfde naam, andere parameters)

public class OverloadingDemo {
    static int som(int a, int b) { return a + b; }
    static double som(double a, double b) { return a + b; }
    public static void main(String[] args) {
        System.out.println(som(2, 3));
        System.out.println(som(2.5, 3.1));
    }
}

Voorbeeld 4 — Parameteroverdracht: by value

public class PassByValue {
    static void verhoog(int x) {
        x++; // werkt op kopie
    }
    public static void main(String[] args) {
        int a = 10;
        verhoog(a);
        System.out.println(a); // nog steeds 10
    }
}

Voorbeeld 5 — Referenties doorgeven (objecten)

class Doos { int waarde; }
public class PassByValueRef {
    static void setTien(Doos d) {
        d.waarde = 10; // de referentie is by value, maar wijzigt het object
    }
    public static void main(String[] args) {
        Doos d = new Doos();
        d.waarde = 5;
        setTien(d);
        System.out.println(d.waarde); // 10
    }
}

Voorbeeld 6 — Scope en schaduw (shadowing)

public class ScopeDemo {
    static int x = 1; // klasseveld
    public static void main(String[] args) {
        int x = 2; // lokale variabele overschaduwt veld
        System.out.println(x);      // 2
        System.out.println(ScopeDemo.x); // 1
    }
}

Voorbeeld 7 — Statisch vs instantie-methoden

class Rekenaar {
    int basis; // instantieveld
    Rekenaar(int basis) { this.basis = basis; }
    int telBij(int a) { return basis + a; }      // instantie
    static int som(int a, int b) { return a + b; } // statisch
}
public class StatischInstantie {
    public static void main(String[] args) {
        System.out.println(Rekenaar.som(3, 4)); // statisch
        Rekenaar r = new Rekenaar(10);
        System.out.println(r.telBij(5));        // instantie
    }
}

Voorbeeld 8 — Varargs (variabel aantal parameters)

public class VarargsDemo {
    static int som(int... getallen) {
        int totaal = 0;
        for (int g : getallen) totaal += g;
        return totaal;
    }
    public static void main(String[] args) {
        System.out.println(som(1));
        System.out.println(som(1, 2, 3));
        System.out.println(som());
    }
}

Voorbeeld 9 — Documenteer met JavaDoc

public class JavaDocDemo {
    /**
     * Berekent de maximale waarde in een array.
     * @param data array van ints (niet null, lengte > 0)
     * @return de grootste int in data
     */
    static int max(int[] data) {
        int m = data[0];
        for (int v : data) if (v > m) m = v;
        return m;
    }
}

Tips:

• Kleine, duidelijke methoden zijn beter te testen en hergebruiken.
• Geef betekenisvolle namen aan methoden en parameters.
• Overload niet te veel; voorkom verwarring.

Koppeling met oefeningen:

• Zie java-workbook/src/chapter_9.md voor methoden- en parameteropdrachten.
• Uitwerkingen in java-solutions/src/chapter_9.md.