# Hoe Java-primitieven te gebruiken Er zijn 8 primitieve datatypes in Java, die allemaal een vaste grootte en een gedefinieerd waardebereik hebben. Ze worden gebruikt om variabelen te maken en deze individuele getallen, tekens of logische waarden toe te wijzen. De 8 Java-primitieven zijn boolean, byte, char, double, float, int, long en short. ## Wat zijn Java-primitieven? Net als andere programmeertalen heeft Java verschillende [gegevenstypen](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-gegevenstypen/). In Java vallen deze uiteen in twee categorieën. De eerste categorie bestaat uit referentietypen, die verwijzen naar een object dat vrij kan worden gedefinieerd, zoals strings, arrays, klassen en interfaces. Daarnaast zijn er de Java-primitieven. Deze hebben een **vaste grootte** die op alle platforms hetzelfde is. Ze hebben ook hun eigen **wrapperklasse**, zijn **onveranderlijk** en hebben een **vast waardebereik**. Java-primitieven worden gebruikt om variabelen te creëren voor individuele getallen, tekens of logische waarden. In Java zijn er 8 verschillende primitieve gegevenstypen die voornamelijk verschillen in termen van **welke waarden ze opslaan**. Wat ze allemaal gemeen hebben, is dat ze slechts één enkele waarde kunnen bevatten. Aangezien sommige ervan in vergelijkbare situaties worden gebruikt, kunnen we de Java-primitieven verder onderverdelen in vier categorieën: - Logisch gegevenstype (booleaans) - Integraal gegevenstype (byte, short, int en long) - Drijvende-kommagegevenstype (float en double) - Tekstgegevenstype (char) Omdat ze rechtstreeks in de stack worden opgeslagen, is hun grootte van bijzonder belang. We zullen hier later in deze handleiding verder op ingaan. Java-primitieven zijn ook belangrijk omdat Java een **statisch getypeerde taal** is. Wanneer u een programma maakt, moet u dus al definiëren welk gegevenstype een variabele heeft, anders krijgt u foutmeldingen. Hier volgt een overzicht van de Java-primitieven:
Gegevenstype Grootte Waardebereik Standaardwaarde Wrapperklasse
boolean 1 bit waar of onwaar false java.lang.Boolean
byte 8 bits -128 tot 127 0 java.lang.Byte
kort 16 bits -32768 tot 32767 0 java.lang.Short
int 32 bits -2147483648 tot 2147483647 0 java.lang.Integer
lang 64 bits -9223372036854775808 tot 9223372036854775807 0 java.lang.Long
float 32 bits tot 7 decimalen 0,0 java.lang.Float
dubbel 64 bits tot 16 decimalen 0,0 java.lang.Double
char 16 bits \*\*’\\u0000’ (d.w.z. 0) tot ‘\\uffff’ (komt overeen met 65535) ‘\\u0000’ java.lang.Character
## Hoe gebruik je de Java-primitieve boolean? Een [Java Boolean](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/javas-booleaanse-primitieve-gegevenstype/) wordt ook wel een waarheidswaarde genoemd. Het is de eenvoudigste Java-primitief, omdat het slechts twee mogelijke waarden heeft: **‘true’ of ‘false’.** Het wordt gebruikt wanneer een logische operand nodig is en is het enige logische gegevenstype. In uitdrukkingen staan de twee mogelijke waarden meestal voor een voorwaarde die wel (true) of niet (false) is vervuld. Als u geen waarde toekent aan een Boolean, krijgt deze de standaardwaarde false. De Boolean kan worden gecombineerd met Booleaanse operatoren in Java, zoals [AND en OR](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-operatoren-and-en-or/). Het toekennen van een waarde aan een Boolean ziet er als volgt uit: ```java public class Main { public static void main(String[] args) { boolean x = true; System.out.println(x); } } ``` Als u het Java-commando `System.out.prinln` gebruikt om een uitvoer te initialiseren, ziet de uitvoer er als volgt uit: ```java true ``` ## byte byte is het kleinste gegevenstype onder de gehele gegevenstypen. Het heeft een zeer beperkt bereik van waarden, namelijk van **-128 tot 127**. Maar het gebruikt slechts 8 bits geheugen. Het dankt zijn naam aan het feit dat 8 bits één byte vormen. Als u slechts met een zeer beperkt bereik van waarden werkt, kunt u een byte als volgt declareren: ```java public class Main { public static void main(String[] args) { byte x = 101; System.out.println(x); } } ``` De uitvoer ziet er als volgt uit: ```java 101 ``` ## kort short is **twee keer zo groot als byte**, wat betekent dat het ook een van de minder vaak gebruikte Java-primitieven is. Maar als byte te klein is en int te groot, dan is short misschien wel het integer-datatype dat u zoekt. Zo declareert u het: ```java public class Main { public static void main(String[] args) { short x = -27412; System.out.println(x); } } ``` De uitvoer ziet er als volgt uit: ```java -27412 ``` ## int int is het **meest gebruikte** gegevenstype voor gehele getallen. Het heeft een zeer groot waardebereik en bespaart toch ruimte. int is een twee-complementwaarde en wordt ook vaak voor andere doeleinden gebruikt. Hier volgt hoe u het kunt gebruiken: ```java public class Main { public static void main(String[] args) { int x = 14; int y = 3; int z = x + y; System.out.println(x + " + " + y + " = " + z); } } ``` De uitvoer ziet er als volgt uit: ```java 14 + 3 = 17 ``` ## lang long is de uitbreiding van int en kan **nog langere getallen** bevatten. int is in de meeste gevallen voldoende, maar als u long wilt declareren, kunt u dat als volgt doen: ```java public class Main { public static void main(String[] args) { long x = 47; System.out.println(x); } } ``` Dit is de uitvoer: ```java 47 ``` ## drijver Er zijn twee Java-primitieven voor het weergeven van subsets van rationale getallen. float is de kleinste van de twee **drijvende-kommagegevenstypen** en gebruikt 32 bits. Het kan maximaal 7 decimalen weergeven. Het is echter niet erg nauwkeurig en wordt daarom niet vaak gebruikt. Als u besluit om het te gebruiken, kunt u het als volgt declareren: ```java public class Main { public static void main(String[] args) { float x = 7.22f; System.out.println(x); } } ``` Let op: u moet een kleine letter ‘f’ of hoofdletter ‘F’ achter het getal invoegen om de computer te laten weten dat het een float is en geen double. De f wordt niet weergegeven in de uitvoer: ```java 7.22 ``` ## dubbel Het tweede drijvende-kommagegevenstype is double. Dit is aanzienlijk nauwkeuriger dan float, maar levert nog steeds geen volledig exacte resultaten op. Als u op zoek bent naar een alternatief, kunt u gebruikmaken van de **klasse BigDecimal**. Als double aan uw doeleinden voldoet, kunt u dit als volgt declareren: ```java public class Main { public static void main(String[] args) { double x = 7.2252; System.out.println(x); } } ``` Let op: er is hier geen extra letter. De uitvoer ziet er als volgt uit: ```java 7.2252 ``` ## char char wordt gebruikt om Unicode-tekens weer te geven. Het loopt van ‘\\u0000’ tot ‘\\uffff’, dus van 0 tot 65535. Het gegevenstype character kan bijna alle **Europese en Aziatische tekens** weergeven. Het gebruikt 16 bits geheugen. De waarden van deze Java-primitief worden tussen enkele aanhalingstekens geplaatst. Zo ziet het eruit in code: ```java public class Main { public static void main(String[] args) { char x = '&'; System.out.println(x); } } ``` De uitvoer ziet er als volgt uit: ```java & ``` This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-primitieven/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-primitieven/) for AI/LLM consumption.