1.1-Introductie-Programmeren

Theorie Variables 3

Competentie: Ik begrijp wat de scope van een variabele is.

Specifieke leerdoelen:

• Je begrijpt het concept van de variabelenscope en snapt dat variabelen bestaan binnen specifieke blokken code.
• Je begrijpt dat code bestaat uit afzonderlijke blokken afgebakend door openende en sluitende accolades {}.
• Je begrijpt het idee van geneste blokken, waarbij het ene blok binnen een ander blok valt en zo hiërarchische structuren vormt.
• Je weet dat variabelen beperkt zijn tot het blok waarin ze zijn gedeclareerd en geïnitialiseerd.
• Je begrijpt dat variabelen die binnen een blok zijn gedeclareerd, alleen toegankelijk zijn binnen dat blok.
• Je begrijpt dat method parameters alleen geldig zijn binnen de betreffende methode.
• Je weet dat teruggegeven waarden uit methoden kunnen worden gebruikt buiten de methode die ze heeft aangeroepen.
• Je begrijpt de beste praktijk van het definiëren van variabelen binnen de kleinste toepasbare scope, wat geheugenverbruik optimaliseert en automatische opschoning mogelijk maakt na afloop van het blok.
• Je begrijpt het concept van globale variabelen, gedefinieerd op het niveau van de klasse en toegankelijk in het hele programma, maar je erkent het belang van spaarzaam gebruik om de impact op de programmatuur en geheugenverbruik te minimaliseren.

Inleiding

Misschien heb je al gemerkt dat het soms best even puzzelen is waar je variabelen aanmaakt en vanaf welke plekken je er dan allemaal bij kunt. Soms is dat ook knap onhandig allemaal! Een variabele heeft maar een beperkt bereik (scope) en eigenlijk is het idee vrij eenvoudig en simpel

Blokken code.

Je code bestaat uit heel veel blokken. Een blok is een stuk code dat begint met een accolade openen { en eindigt met een accolade sluiten }. Het lastige aan dit concept is dat je ook heel veel blokken in blokken hebt. Ga maar na welke blokken je allemaal in onderstaande voorbeeld hebt.

public class Application implements Runnable {

    public static void main(String[] args) {
        SaxionApp.start(new Application(), 1024, 768);
    }

    public void run() {
        int getal = 10;
        int getal2 = sum(5, 2);

        if (getal < getal2) {
            SaxionApp.printLine("Getal 1 is kleiner dan getal 2");
        } else {
            SaxionApp.printLine("Getal 2 is kleiner dan getal 1");
        }
    }

    public int sum(int x, int y) {
        return x + y;
    }
}

Zie je ze allemaal? Hier komen ze:

1. Een blok voor de hele class, vanaf de eerste regel tot de laatste.
2. Een blok waarin de inhoud van de main methode staat.
3. Een blok waarin de inhoud van de run methode staat.
4. Een blok dat alleen wordt uitgevoerd als getal1 kleiner is dan getal2.
5. Een blok dat alleen wordt uitgevoerd als getal1 groter of gelijk aan getal2 is.
6. Een blok waarin de inhoud van de sum methode staat beschreven.

Kortom: Je code bestaat uit veel blokken en blokken kunnen worden genest (dus een blok kan in een ander blok zitten). Bij het uitvoeren van een programma zal een blok “gewoon” van boven naar beneden uitgevoerd worden.

Hoe zit het dan met de scope?

Nou, een variabele bestaat alleen in het blok waarin je hem gemaakt hebt. Zodra het blok eindigt is je variabele ook weg. Natuurlijk bestaat de variabele ook pas in de regels nadat je hem gemaakt hebt. Ingewikkeld? Nee hoor, We leggen het uit aan de hand van het stukje code hierboven.

• De variabele int getal is beschikbaar in de hele run methode. Dus vanaf dat je hem gemaakt hebt helemaal tot het eind. Ook in de blokken in de run methode (dus die van de if) kun je hem gebruiken.
• De variabele int getal2 is ook bijna beschikbaar in de hele run methode. Alleen je kunt hem natuurlijk niet gebruiken in die regel die erboven staat, want daar bestaat ie nog niet ;-).
• Stel wij zouden in het if of else blok een variabele maken, dan is die alleen beschikbaar in dat blok en dus niet in de hele run-methode.
• De argumenten van de methode sum, dus de X en de Y, zijn alleen beschikbaar in die methode, daarbuiten kun je er verder niet bij en bestaan ze ook niet meer. Wat natuurlijk wel beschikbaar is is de uitvoer van de sum methode (dus datgene wat hij returnd).

Een goed gebruik is om variabelen een zo klein mogelijke scope te geven, dus ze te maken binnen het blok waar je ze nodig hebt. Dat is lekker efficient voor het geheugengebruik van je programma, omdat hij steeds na een blok alle variabelen weer opruimt.

En verder?

Verder is één “truukje” nog wel handig. Als je een variabele wilt hebben die je in je hele programma kunt gebruiken (dus in alle methodes), dan kun je hem bovenaan in je programma aanmaken, direct onder de eerste regel. Dit noem je een globale variabele. Dus bijvoorbeeld zo:

public class Application implements Runnable {
    ArrayList<String> names = new ArrayList<String>();
    public static void main(String[] args) {
        SaxionApp.start(new Application(), 1024, 768);
    }
    public void run() {
        //Je kunt nu hier bij de lijst namen
        names.add("Mary");
        names.add("John");
        names.add("Rachel");
        String name = bepaalEerste();
    }
    public String bepaalEerste() {
        //En hier ook!
        if (names.size() > 0) {
            return names.get(0);
        }
        return "";
    }
}

Let erop dat je hier voorzichtig mee bent, omdat je variabelen altijd een zo klein mogelijke scope wilt geven. Ga dus niet klakkeloos alle variabelen als globaal boven in je programma zetten. Doe het alleen als het echt noodzakelijk is.