Programmeren in Java/Variabelen

Soms wil je gegevens van bijvoorbeeld input kunnen opslaan om later te gebruiken, dit doen we dan in een variabele. We kunnen primitieve variabelen opslaan en objecten. Over objecten vertellen we later meer, we beperken ons nu even op de primitieve. Dit zijn vaak eenvoudige gegevens, zoals getallen en tekens.

Primitieve variabelen

Hele getallen opslaan

Getallen kun je opslaan met de volgende twee manieren:

int a = 1;
int b = a;

Met int geven we aan dat de variabele een geheel getal is, dit moet er dan ook altijd voor, zelfs als we er nog geen waarde aan geven. Let erop dat je dit schrijft met een kleine i! Met de a geven we de variabele een naam. Na het =-teken zetten we er de waarde neer die de variabele moet krijgen, daarvoor kunnen we de waarde ter plekke maken, zoals op de eerste regel hierboven, en kunnen we een waarde uit een bestaande variabele gebruiken. Mocht a later veranderen in bij voorbeeld een 2, blijft b de waarden 1 behouden.

int a;

Als we nog geen waarde aan de variabele willen geven zetten we achter de variabelenaam (hier dus de a) alleen de puntkomma om de regel af te sluiten:

Gebroken getallen opslaan

Als we bijvoorbeeld een half willen opslaan doen we eigenlijk niet heel andere dingen:

Op de plaats waar we eerst int hadden staan, zetten we nu double neer. Als we een gebroken getal willen opslaan zetten we na het =-teken een komma getal zoals we dat ook doen met geldbedragen, maar dan niet met een komma maar met een punt:

double c = 0.5;

Als je dit zou doen met een int, kun je je programma niet compileren en dus ook niet uitvoeren. Andersom kan overigens wel.

Inhoud van primitieve variabelen tonen

De inhoud van de primitieve variabelen kun je op de volgende manier tonen:

System.out.println(a);
System.out.println(b);
System.out.println(c);

Het resultaat hiervan zal op de console dit tonen als je de hiervoor gebruikte regels om primitieve variabelen op te slaan gebruikt hebt:

1
1
0.5

Met System.out.println zorgt de computer ervoor dat dingen op de console getoond worden en hetgeen je wilt tonen zet je daarachter tussen ronde haakjes.

Voorbeeld met primitieven

Een voorbeeld van een volledige klasse met primitieve variabelen en nieuwe variabelen:

public class Main {
	public static void main(String[] args) {
		int a = 2;
		double b = 5.1;
		double c = a;
		System.out.println("Resultaat: " a + b + c);
	}
}

Op het scherm van de console zul je dan het volgende zien:

Resultaat: 2 5.1 2.0

Objecten in variabelen

In variabelen kun je ook objecten opslaan. De belangrijkste verschillen van objecten met primitieve variabelen is dat objecten meerdere variabelen kunnen hebben en verschillende methodes, die je kunt aanroepen. Welke variabelen en methodes er zijn in een object hangt af van welke klasse het object is. Meestal worden methodes gebruikt om variabelen van het object aan te passen. Daarnaast gaat het aanmaken van objecten ook op een heel andere manier dan bij primitieve variabelen. Een object aanmaken doe je altijd met het woordje new, gevolgd door de naam van het variabele, ronde haakjes en dan een puntkomma om de regel af te sluiten. Het opslaan ervan lijkt heel erg op de manier waarop we primitieve variabelen opslaan. Bijvoorbeeld zo voor een object van de klasse Point:

Point p = new Point();

Links van het =-teken is de variabele waarin we het object gaan opslaan. Point staat hier omdat het type van de variabele hetzelfde moet zijn als de klasse waarvan het object, wat hier Point is. Rechts van het =-teken staat het woord new, dit heb je altijd nodig om een nieuw object te maken. Na het woord new komt de naam van de klasse en ronde haakjes, hier staat niets tussen de haakjes, bij sommige klasses kan het wel, bij sommige klasses moet er iets tussen staan. En natuurlijk de puntkomma om de regel af te sluiten.

Een object naar de console schrijven zou je kunnen doen, je krijgt dan de naam van de klasse waarvan die gemaakt is en opsomming van de variabelen te zien en de waardes daarvan. Als je deze regel toevoegt onder de regel die we hierboven al hadden krijg je deze samenvatting te zien op de console:

System.out.println(p);

Hiervan is dan dit het resultaat:

java.awt.Point[x=0,y=0]

Meestal heb je echter niet een dergelijke opsomming van de waardes van de variabelen van een object nodig, ook is de vorm waarop deze tekst is opgebouwd nauwelijks voorspelbaar. Vaak heb je maar specifieke dingen nodig, deze kun je dan opvragen door bepaalde methodes van het object aan te roepen. Dat aanroepen van methodes doe je door de variabele waar het object in zit op geslagen te typen, gevolgd door een punt en dan ronde haakjes met eventueel daar iets tussen:

p.getY()

De waarde die de methode teruggeeft kun je dan bijvoorbeeld opslaan in een variabele:

int e = p.getY();

Of tonen in de console:

System.out.println(p.getY());

Een methode kan overigens ook een object teruggeven als resultaat.

Teksten opslaan en gebruiken

String is een type object wat veel gebruikt wordt, je kunt er teksten mee opslaan in variabelen. Het aanmaken van een object kan in principe maar op 1 manier:

String a = new String();

In a zit nu wel een string, maar zonder inhoud.

Hoewel objecten van het type String daarop wel een uitzondering zijn, die kun je namelijk ook aanmaken door na het =-teken de tekst die het object moet gaan bevatten tussen dubbele aanhalingstekens te zetten:

String a = "tekst";
String b = "";

In a zit nu een String met als inhoud "tekst", in b zit ook een String maar dan zonder inhoud.

Dit opslaan kun je ook weer op 2 manieren doen. Een nieuwe aanmaken of een bestaande gebruiken:

String a = new String("inhoud");
String b = a;

In a zit nu een String met als inhoud "inhoud", in b zit ook een String, dezelfde als in a, dus waar ook de inhoud het woord "inhoud" is.

De inhoud van de variabelen kun je er ook weer uit halen en eventueel ook weer achter elkaar zetten:

String a = "wikibook";
String c = "We hebben hulp nodig!";
System.out.println("Resultaat: " + a + " zegt " + c);

Voorbeelden met objecten in variabelen

String is wel een heel vaak gezien object, maar objecten zijn er in allerlei vormen en maten te vinden en met veel verschillende namen.

public class Main {
	public static void main(String[] args) {
		String a = "Appel ";
		String b = "van ";
		String c = "1 ";
		System.out.println("Resultaat: " + a + b + c + "euro");
	}
}

Op het scherm van de console zul je dan het volgende zien:

Resultaat: Appel van 1 euro