Ellie, variabelen en datatypen

Een vrouw met knalroze haar kwam de cabine binnen. "Ik vraag me af of alle mensenvrouwen zulk haar hebben", dacht Amigo bij zichzelf.

"Hoi! Mijn naam is Elisabeth Costanza. Maar je mag me Ellie noemen. Ik ben de navigator van de Galactische Galei."

"Hallo Ellie", wist Amigo uit te brengen.

"Ik ga je het meest interessante onderdeel van de hele Java-taal uitleggen: variabelen."

"Ehh, ik hang aan je lippen. Wat zijn die variabelen precies voor dingen?"

"Variabelen zijn speciale dingen waarin je data (dat wil zeggen gegevens) kunt opslaan. Allerlei soorten data. In Java worden alle data opgeslagen in variabelen. Je kunt een variabele het best vergelijken met een doos."

"Een doos? Wat voor soort doos?"

"Gewoon een doos. Stel dat je het getal 13 op een papiertje schrijft en dat papier in een doos doet. Nou kun je zeggen dat de waarde 13 is opgeslagen in de doos, of dat de doos de waarde 13 bevat.

In Java heeft elke variabele drie belangrijke eigenschappen: een type, een naam en een waarde."

"Kun je dat uitleggen?"

"Ja hoor. We gebruiken namen om de variabelen uit elkaar te kunnen houden. Het is zoiets als het etiket van een doos.

Het type van een variabele bepaalt wat voor soort data of waarden erin kunnen worden opgeslagen. We doen bijvoorbeeld bonbons in een bonbondoos en schoenen in een schoenendoos, maar geen schoenen in een bonbondoos.

En de waarde van een variabele is het specifieke stukje data dat in de variabele is opgeslagen."

"Kun je dat van die typen nog wat verder uitleggen?", vroeg Amigo.

"Ja hoor. Elk ding in Java is van een bepaald datatype. Je kunt bijvoorbeeld typen hebben voor hele getallen, gebroken getallen, teksten... maar ook voor katten, huizen enzovoort.

Ook een variabele is altijd van een bepaald type. En in een variabele kun je alleen dingen opslaan die van hetzelfde type zijn als de variabele.

Dus eigenlijk net zo als in het gewone leven. Verschillende soorten dozen worden gebruikt voor verschillende dingen:

Het maken van een variabele noemen we 'declareren'. Om een variabele te declareren, vermeld je het type en de naam van de variabele: TypeName variableName.

Ik geef je een paar voorbeelden.

int a;

String s;

double c;

Een veel gebruikt datatype zijn de integers. Dat zijn getallen zonder cijfers achter de komma, gehele getallen dus. Variabelen van dit type declareer je met het woord int. Een ander populair datatype is bedoeld voor tekst. Variabelen van dit type worden gedeclareerd met het woord String)."

"En wat is een double?"

"Doubles zijn reële getallen. Die kunnen wel cijfers achter de komma hebben."

"Je zei dat een variabele drie eigenschappen heeft: type, naam en waarde. Maar ik zie er maar twee. Wat ik dus eigenlijk wil vragen: hoe krijgt een variabele een waarde?"

"Daarvoor gaan we terug naar de vergelijking met de dozen. Stel dat je het getal 42 op een stuk papier schrijft en het papier vervolgens in een doos stopt. Nu heeft de doos de waarde 42."

"Dat snap ik."

"In Java gebruiken we een speciale bewerking ('toewijzing') om een waarde aan een variabele te geven. Een toewijzing kopieert een waarde van een variabele naar een andere variabele. Dus de waarde wordt niet verplaatst, maar gekopieerd! Net als een bestand op een harde schijf. Zo ziet dat eruit:

i = 3;

a = 1;
b = a+1;

x = 3;
x = x + 1;

Om een toewijzing op te schrijven, gebruiken we in Java het isgelijkteken (=). Maar je spreekt dit teken uit als 'wordt' en niet als 'is'!

Dus voor alle duidelijkheid: het isgelijkteken is in Java niet bedoeld om twee dingen met elkaar te vergelijken. We kopiëren de waarde rechts van het isgelijkteken naar de variabele links van het isgelijkteken. Als we in Java willen weten of twee dingen aan elkaar gelijk zijn, gebruiken we twee isgelijktekens achter elkaar (==)."

"Ik weet hoe je een kat in een variabele krijgt. Het is net een soort programma", zei Amigo.

"Zo vang je een kat:

1. Pak een lege doos.

2. Wacht."

"Nee, Amigo. Je kunt maar één kat in een doos doen. Eh, ik bedoel dat je maar één waarde aan een variabele kunt toewijzen."

"Ik snap het. Kun je nog eens laten zien hoe je variabelen maakt?"

"OK, nog een keer dan. Om een variabele te maken (te declareren), gebruik je deze vorm: TypeName variableName."

String s;

int x;

int a, b, c;
int d;

"Oh, nou snap ik het!"

"Houd er rekening mee dat je nooit twee variabelen met precies dezelfde namen kunt maken binnen dezelfde methode."

"En in verschillende methoden?"

"Ja, dat kan wel. Dat is alsof je twee dozen met hetzelfde etiket in verschillende huizen hebt."

"Kan ik een variabele elke naam geven die ik wil?"

"Bijna wel. Maar namen van variabelen mogen geen spaties, plus- en mintekens en andere speciale tekens bevatten. Je kunt beter alleen letters en cijfers gebruiken in namen van variabelen.

Ook belangrijk om te weten: Java is hoofdlettergevoelig. Dus int a is niet hetzelfde als Int a.

Je kunt in Java trouwens meteen een waarde aan een variabele toewijzen wanneer je de variabele declareert. Daarmee bespaar je tijd en ruimte."

int a = 5;
int b = 6;

int a;
a = 5;
int b;
b = 6;

int c = 7;
int d = c+1;

int c;
c = 7;
int d;
d = c+1;

String s = "I'm Amigo";

String s;
s = "I'm Amigo";

"Zo is het wel een stuk korter en duidelijker, ja."

"Mooi toch.

Er zijn twee datatypen die elke beginnende Java-leerling moet kennen: int (gehele getallen) en String (tekst).

In variabelen van het type int kun je gehele getallen (integers) opslaan. Bovendien kun je bewerkingen op integers uitvoeren, zoals optellen, aftrekken, vermenigvuldigen, delen enzovoort."

int x = 1;
int y = x*2;
int z = 5*y*y + 2*y + 3;

int a = 5;
int b = 1;
int c = (a-b) * (a+b);

int a = 64;
int b = a/8;
int c = b/4;
int d = c*3;

"Ik begrijp het. Is programmeren altijd zo gemakkelijk?"

"Eigenlijk wel, ja."

"Tof! Wat gaan we nu doen?"

"In variabelen van het type String kun je stukken tekst opslaan. Die noemen we 'strings' (ook wel 'tekenreeksen').

Om een string in Java op te schrijven, plaats je de tekst tussen dubbele aanhalingstekens. Dit zijn een paar voorbeelden:"

String s = "Amigo";

String s = "123";

String s = "123 + 456";

"Ik begrijp het. Heel erg moeilijk lijkt het niet."

"Ik heb nog een leuk weetje voor je.

Je kunt twee strings aan elkaar plakken met een plusteken (+). Bekijk deze voorbeelden maar:"

String s = "Amigo" + " is the best";

String s = "";

int x = 333;
String s = "Amigo" + x;

"OK, dus je kunt getallen aan strings toevoegen?"

"Ja, maar let op: wanneer je strings en getallen aan elkaar toevoegt, is het resultaat altijd een string."

"Dat had ik al begrepen uit je voorbeeld."

"Als je zo slim bent, zeg dan maar eens hoe je een variabele op het scherm weergeeft."

"Hmmm. Een variabele? Op het scherm? Er schiet me zo gauw niets te binnen."

"Eigenlijk is het heel simpel. Om iets op het scherm weer te geven, gebruiken we de instructie System.out.println(). Datgene wat we op het scherm willen zetten, geven we als argument door aan de instructie. Dat argument mag ook een variabele zijn."

System.out.println("Amigo");

System.out.println("Ami"+"go");

String s = "Amigo";
System.out.println(s);

String s = "Am";
System.out.println(s+"igo");

"Aha! Dat vind ik allemaal erg logisch."

"Mooi. Dan zijn hier nog drie oefeningen voor je!"