Java variables (Variabelen)

Een (Java) variable (variabele) is een naam die wordt gegeven aan een deel van het geheugen, waarin ook een waarde staat.  Op deze manier hoef je niet steeds weer een waarde aan te maken, maar kan je het met een naam ophalen uit het geheugen. De waarde kan tijdens het uitvoeren van een programma ook veranderen.

Wat zijn Java variables?

Een Java variable heeft drie belangrijke onderdelen, namelijk:

• Datatype = Het soort type data dat kan worden opgeslagen in de Java variable.
• Naam = De naam die aan de variable is gegeven.
• Waarde = De waarde die in de variable staat opgeslagen.

Je kan het bijvoorbeeld zien als een soort doos die speciaal gelabeld is voor een “Gele auto”. Het is de bedoeling dat daar alleen een gele auto in wordt bewaard. Stel dat je een gele auto bewaard in de doos. Waar je de doos ook mee naartoe neemt, de gele auto blijft erin zitten. Tijdens het verhuizen kan je bijvoorbeeld ook de gele auto uit de doos halen, omdat het verouderd of misschien wel kapot is, en een nieuwe gele auto erin stoppen. De waarde (Gele auto) in de doos kan veranderen.

• Datatype = Er mag alleen een gele auto in de doos. In de Java code is String het datatype van de Java variable.
• Naam = De naam op de doos is “Gele auto”. In de Java code is DoosGeleAuto de naam van de Java variable.
• Waarde = Er zit een gele auto in de doos. In de Java code is “Oude gele speelgoed auto” de waarde van de Java variable.

Er zijn drie soorten Java variables, namelijk:

• Local variables
• Instance variables
• Static variables

In het volgende hoofdstuk vind je daar voorbeelden van in Java code.

Java variables voorbeelden in code

Local variables

Een local Java variable is gedeclareerd (Aangemaakt) in een method, constructor of een block. De code in een block is alles wat tussen de braces staat ({}). De local variable is alleen toegankelijk binnenin het block waarin de variable is gedeclareerd. Als het desbetreffende block eindigt, dan wordt de variable vernietigd. Hieronder een voorbeeld:

public class MijnClass {
    
    public void Naam() {
        String naam = "Henk";
        System.out.println("Naam uit dit voorbeeld is " + naam);
    }
    
    public static void main(String args[]) {
        MijnClass mc = new MijnClass();
        mc.Naam();
    }
}

Als je de variable naam buiten de Naam() method zou willen gebruiken of uitlezen, krijg je een error. Probeer het eens op JDoodle.

Instance variables

Een instance Java variable is gedeclareerd buiten een method, constructor of een block. De instance variables worden in een class gedeclareerd en aangemaakt wanneer er een object van een class wordt gemaakt. Wanneer het object wordt vernietigd, wordt ook de instance variable vernietigd. Instance variables zijn alleen toegankelijk via een object. Tevens maak je gebruik van access modifiers. Dit is de toegankelijkheid die je meegeeft aan de variable voor andere classes en/of packages. Hieronder een voorbeeld van instance variables:

class Hond {
    // Dit zijn instance variables, omdat ze in de class staan 
    // en niet in een method, constructor of block
    public String naam;
    public int leeftijd;
}

public class MijnClass {
    
    public static void main(String args[]) {     
        Hond h = new Hond();
        h.naam = "Max";
        h.leeftijd = 10;
        System.out.println(h.naam);
        System.out.println(h.leeftijd);
    }
}

Zoals je hierboven ziet hebben alle instance variables in dit voorbeeld een public access modifier. Hierdoor zijn ze toegankelijk in alle andere classes. In MijnClass wordt er een object aangemaakt van de class Hond. Via dit object kan je de instance variables aanroepen en een waarde meegeven. In System.out.println(); worden de waardes uitgelezen. Als je meerdere objecten zou aanmaken, heeft elk object zijn eigen kopie van een instance variable. Probeer het eens op JDoodle.

Static variables

Een static Java variable behoort tot een class. De static variables worden hetzelfde gedeclareerd als instance variables. Het enige verschil is dat het “static” keyword er nog voor staat. Er is maar één kopie van een static variable per class. Als het programma start, worden de static variables aangemaakt. Als het programma eindigt, worden de static variables weer vernietigd. De static variables worden aangesproken door een class. Hieronder een voorbeeld:

class Hond {
    // Static variables
    // naam krijgt een waarde
    // leeftijd heeft nog geen waarde
    public static String naam = "Max";
    public static int leeftijd;
}

public class MijnClass {
    
    public static void main(String args[]) {
        
        // Static variables aanspreken met class naam
        // Waarde toekennen aan leeftijd
        Hond.leeftijd = 10;
        System.out.println(Hond.naam);
        System.out.println(Hond.leeftijd);
    }
}

Hierboven zie je duidelijk de verschillen met instance variables. De static variables worden aangesproken met de naam van de class, Hond in dit geval. Probeer zelf eens ermee te oefenen op JDoodle.

Overige regels en weetjes

Overige regels en weetjes voor Java variables die nog niet zijn besproken:

• Je kan meerdere variables op één regel declareren in Java (Scheiden door komma’s): int nummer1 = 10, nummer2 = 20, nummer3 = 30;
• De naam van een Java variable moet beginnen met een letter.
• De naam van een Java variable is hooflettergevoelig.
• De naam van een Java variable kan ook beginnen met een $ of _.
• Reserved keywords kunnen niet worden gebruikt als naam van een Java variable.
• Alle Java variables moeten een unieke naam hebben.

Meer leren?

Wil je meer leren over de basisonderdelen van Java en programmeren in het algemeen? Dan is het aan te raden om het e-book “Snelcursus Leren Programmeren” te lezen. Ook kan het interessant zijn om het artikel “Java leren” te lezen.