Wat zijn de ver­schil­len­de ge­ge­vens­ty­pen in Java?

Java biedt acht pri­mi­tie­ve datatypes en talrijke complexe datatypes. Deze bepalen welke waarden binnen een variabele kunnen worden op­ge­sla­gen en weer­ge­ge­ven. Bepaalde datatypes worden toe­ge­we­zen aan alle va­ri­a­be­len in Java.

Welke ge­ge­vens­ty­pen zijn er in Java?

In elke pro­gram­meer­taal zijn er ver­schil­len­de ge­ge­vens­ty­pen die spe­ci­fie­ke objecten en ge­de­fi­ni­eer­de be­wer­kin­gen bevatten. Hoewel de ge­ge­vens­ty­pen die door ver­schil­len­de talen worden aan­ge­bo­den vaak op elkaar lijken, zijn er soms aan­zien­lij­ke ver­schil­len. Als je bij­voor­beeld Python en Java en hun ge­ge­vens­ty­pen ver­ge­lijkt, zie je over­een­kom­sten tussen de twee, maar ook talrijke ver­schil­len die de talen geschikt maken voor ver­schil­len­de soorten taken.

Java maakt gebruik van twee ver­schil­len­de soorten datatypes: pri­mi­tie­ve en complexe. Complexe datatypes worden ook wel re­fe­ren­ti­e­ty­pes genoemd. Pri­mi­tie­ve en complexe datatypes ver­schil­len qua grootte en bepalen welke waarden in een variabele kunnen worden op­ge­sla­gen. Terwijl pri­mi­tie­ve datatypes alleen een­vou­di­ge waarden kunnen opslaan, worden re­fe­ren­ti­e­ty­pes gebruikt om com­plexe­re struc­tu­ren te creëren en grote hoe­veel­he­den gegevens te or­ga­ni­se­ren en te ma­ni­pu­le­ren.

Als je wilt leren pro­gram­me­ren, is het be­lang­rijk om niet alleen de ver­schil­len­de ge­ge­vens­ty­pen te kennen, maar ook te weten hoe je het meeste uit elk van deze typen kunt halen. Om te begrijpen hoe je ge­ge­vens­ty­pen het beste kunt gebruiken, moet je niet alleen weten wat hun func­ti­o­na­li­teit is, maar ook hoeveel geheugen ze gebruiken (of besparen).

Wat zijn pri­mi­tie­ve datatypes in Java?

Er zijn in totaal acht ver­schil­len­de pri­mi­tie­ve datatypes in Java, die vast­om­lijn­de waar­de­be­rei­ken bevatten. Ze kunnen worden on­der­ver­deeld in vier ca­te­go­rie­ën: logische datatypes, integrale datatypes, drijvende-kom­ma­da­ta­ty­pes en te­ken­da­ta­ty­pes. Ze hebben geen extra speciale mo­ge­lijk­he­den en worden ook wel ele­men­tai­re datatypes genoemd. Elk datatype heeft een vast aantal bits. Hieronder gaan we dieper in op de pri­mi­tie­ve datatypes. Java maakt gebruik van de volgende pri­mi­tie­ve types:

• boole­aan­se waarde
• byte
• kort
• int of integer
• lang
• drijvende komma
• dubbel
• teken

boolean

Hetboole­aan­se ge­ge­vens­ty­pevan Java is geen numeriek type. Het biedt slechts twee mogelijke waarden: true en false. Het kan worden gebruikt om te bepalen of een voor­waar­de van toe­pas­sing is (true) of niet (false). Het is een logisch ge­ge­vens­ty­pe en de stan­daard­waar­de is false. Het bestaat uit 1 bit en heeft de volgende syntaxis:

boolean booleanVar;

byte

byte is een integraal ge­ge­vens­ty­pe dat wordt weer­ge­ge­ven als een twee-com­ple­ment­waar­de met een grootte van 8 bits of 1 byte. Het wordt doorgaans gebruikt om geheugen te besparen in grotere arrays. Het waar­de­be­reik loopt van -128 tot 127 en de stan­daard­waar­de is 0. Dit is de syntaxis:

byte byteVar;

short

short is ook een van de integrale ge­ge­vens­ty­pen in Java en wordt voor­na­me­lijk gebruikt om geheugen te besparen in grotere arrays. De waarde van het twee-com­ple­ment zelf is 16 bits of 2 bytes groot en het waar­de­be­reik loopt van -32768 tot en met 32767. Standaard is de waarde 0. Zo wordt short gebruikt:

short shortVar

int of geheel getal

int of integer is ook een twee-com­ple­ment­waar­de en een integraal ge­ge­vens­ty­pe met een grootte van 4 bytes of 32 bits. Het waar­de­be­reik omvat gehele getallen tussen -2147483648 en 2147483647 en de stan­daard­waar­de is 0. De syntaxis is als volgt:

int intVar

long

Het grootste integrale ge­ge­vens­ty­pe is long. Dit geldt ten eerste voor het waar­de­be­reik, dat tussen -9223372036854775808 en 9223372036854775807 ligt, en ten tweede voor de grootte zelf, die 8 bytes of 64 bits is. De twee-com­ple­ment­waar­de wordt daarom gebruikt als de andere integrale ge­ge­vens­ty­pen niet voldoende zijn. Het vereist echter ook veruit de meeste ge­heu­gen­ruim­te. De stan­daard­waar­de is 0. Dit is de syntaxis:

lomg longVar

float

float is een drijvende-kom­ma­ge­ge­vens­ty­pe en wordt gebruikt om reële getallen op te slaan. Het heeft een grootte van 32 bits en voldoet aan de IEEE 754-standaard, die de stan­daard­weer­ga­ve van binaire en decimale drijvende-kom­ma­ge­tal­len in computers de­fi­ni­eert. De stan­daard­waar­de van float is 0,0 en er kunnen maximaal zeven decimalen worden weer­ge­ge­ven in het waar­de­be­reik. In ver­ge­lij­king met double is float echter niet zo nauw­keu­rig en mag daarom niet worden gebruikt voor waarden waarbij nauw­keu­rig­heid een door­slag­ge­ven­de rol speelt. Als dit echter niet het geval is, kunt u float gebruiken om ruimte te besparen. De syntaxis voor float is als volgt:

float floatVar;

double

double is ongeveer twee keer zo nauw­keu­rig als float en vervult een soort­ge­lijk doel. Het is 64 bits groot en kan tot 16 decimalen weergeven. De stan­daard­waar­de is ook 0,0. Als u nauw­keu­ri­ge­re waarden nodig hebt, moet u altijd double gebruiken, hoewel dit ge­ge­vens­ty­pe ook niet zo nauw­keu­rig is. Als u met absoluut exacte waarden wilt werken, moet u in plaats daarvan de klasse Big­De­ci­mal gebruiken. De syntaxis van double is als volgt:

double doubleVar;

char

char is een te­ken­ge­ge­vens­ty­pe. Het slaat tekens op basis van de Unicode-tekenset op, waardoor het op tal van ver­schil­len­de platforms kan worden gebruikt. Elk teken vereist 2 bytes geheugen. Het waar­de­be­reik komt overeen met ASCII (American Standard Code for In­for­ma­ti­on In­ter­chan­ge) en ligt tussen ‘\u0000’ (d.w.z. 0) en ‘\uffff’ (komt overeen met 65535). De stan­daard­waar­de van char is ‘\u0000’ en de syntaxis ziet er als volgt uit:

char charVar

Wat zijn complexe datatypes in Java?

Het tweede type ge­ge­vens­ty­pen in Java zijn de re­fe­ren­ti­e­ty­pen, ook wel complexe ge­ge­vens­ty­pen genoemd. Ze worden re­fe­ren­ti­e­ty­pen genoemd omdat ze naar objecten verwijzen. In te­gen­stel­ling tot pri­mi­tie­ve ge­ge­vens­ty­pen zijn ze normaal gesproken niet vooraf ge­de­fi­ni­eerd, maar worden ze bepaald door de pro­gram­meur (een uit­zon­de­ring hierop is string). Ze kunnen methoden gebruiken en kunnen ook de waarde 0 hebben (in de zin van leeg). Terwijl pri­mi­tie­ve ge­ge­vens­ty­pen beginnen met een kleine letter, beginnen re­fe­ren­ti­e­ty­pen met een hoofd­let­ter. Hier bekijken we de be­lang­rijk­ste re­fe­ren­ti­e­ty­pen.

Touwtjes

String is een klasse die kan worden gebruikt om een reeks tekens weer te geven, waardoor dit complexe ge­ge­vens­ty­pe zich on­der­scheidt van het pri­mi­tie­ve ge­ge­vens­ty­pe char en andere ge­ge­vens­ty­pen. Een te­ken­reeks bestaat als een object in de klasse java.lang. Met de ver­schil­len­de methoden van de klasse String kunt u af­zon­der­lij­ke tekens in de te­ken­reeks bekijken, te­ken­reek­sen met elkaar ver­ge­lij­ken, te­ken­reek­sen zoeken en te­ken­reek­sen kopiëren. Te­ken­reek­sen worden aangeduid met aan­ha­lings­te­kens. De syntaxis van dit re­fe­ren­ti­e­ty­pe ziet er als volgt uit:

<string_type> <string_variable> = "<string_sequence>";

Hier is een voorbeeld van hoe strings werken:

// How to create a string without a new operator
String a = "This is your new string";
/ / How to create a string with a new operator
String a1 = new string ("This is your new string");

Arrays

Arrays worden gebruikt om meerdere waarden binnen een variabele op te slaan in plaats van voor elke af­zon­der­lij­ke waarde een aparte variabele aan te maken. Ze worden aan­ge­maakt met behulp van vierkante haken. De op­ge­sla­gen waarden worden tussen accolades geplaatst en door komma’s ge­schei­den. Hier is de syntaxis voor arrays:

dataType[] arrayName = {value1, value2, value3,…};

Als u een array met strings wilt maken, kunt u dat als volgt doen:

String[] colors = {"blue", "red", "yellow", "purple"};

Hier volgt hoe je een array met gehele getallen kunt maken:

int[] figures = {5, 10, 15, 20};

Lessen

In Java zijn klassen datatypes die dienen als sjabloon voor het maken van objecten. Ze bevatten ver­schil­len­de com­po­nen­ten, waaronder de naam van de klasse, modifiers en een body tussen accolades. Hier is een voorbeeld van hoe een klasse er in Java uitziet:

public class Main {
	int a = 10;
}

In­ter­fa­ces

In Java is een interface een abstracte klasse. Het fungeert als een interface waarmee een klasse toegang heeft tot ver­schil­len­de functies. Om dit te kunnen doen, moet het deze echter eerst im­ple­men­te­ren. In­ter­fa­ces bevatten alleen con­stan­ten en abstracte methoden. Hun syntaxis ziet er als volgt uit:

interface {
	abstract methods
}

We zullen hier een eenvoudig voorbeeld geven om te laten zien hoe in­ter­fa­ces werken:

interface Pizza {
	public void ingredientsList();
	public void preparation();
}
class Mushroom implements Pizza {
	public void ingredientsList() {
		System.out.println("mushrooms, tomato sauce, oregano, mozzarella");
}
public void preparation() {
	System.out.println("The pizza will be ready in 15 minutes.");
}
}
class Main {
	public static void main(String[] args) {
		Mushroom myMushroom = new Mushroom();
		myMushroom.ingredientsList();
		myMushroom.preparation();
	}
}

De over­een­kom­sti­ge uitvoer van het Java-commando System.out.println ziet er als volgt uit:

mushrooms, tomato sauce, oregano, mozzarella
The pizza will be ready in 15 minutes.

Objecten

In Java zijn objecten ook een complex ge­ge­vens­ty­pe. Objecten zijn in­stan­ties van klassen die ver­vol­gens met elkaar kunnen com­mu­ni­ce­ren via methoden. In het volgende voorbeeld gaan we ver­schil­len­de objecten maken in een Main-klasse:

public class Main {
	int a = 10;
public static void main(String[] args) {
	Main myObj1 = new Main();
	Main myObj2 = new Main();
	System.out.println(myObj1.a);
	System.out.println(myObj2.a);
	}
}

De uitvoer ziet er als volgt uit:

10
10

Enums

Enums zijn een speciale klasse waarmee u on­ver­an­der­lij­ke con­stan­ten in uw code kunt opnemen. Aan deze va­ri­a­be­len worden vaste waarden toegekend die niet kunnen worden gewijzigd. Dit ge­ge­vens­ty­pe is vooral handig als u va­ri­a­be­len nodig hebt die slechts een paar mogelijke toe­stan­den kunnen hebben. De syntaxis van een enum ziet er als volgt uit:

enum NameOfTheClass {
	VALUE1,
	VALUE2,
	VALUE3
}