Hoe Java-pri­mi­tie­ven te gebruiken

Er zijn 8 pri­mi­tie­ve datatypes in Java, die allemaal een vaste grootte en een ge­de­fi­ni­eerd waar­de­be­reik hebben. Ze worden gebruikt om va­ri­a­be­len te maken en deze in­di­vi­du­e­le getallen, tekens of logische waarden toe te wijzen. De 8 Java-pri­mi­tie­ven zijn boolean, byte, char, double, float, int, long en short.

Wat zijn Java-pri­mi­tie­ven?

Net als andere pro­gram­meer­ta­len heeft Java ver­schil­len­de ge­ge­vens­ty­pen. In Java vallen deze uiteen in twee ca­te­go­rie­ën. De eerste categorie bestaat uit re­fe­ren­ti­e­ty­pen, die verwijzen naar een object dat vrij kan worden ge­de­fi­ni­eerd, zoals strings, arrays, klassen en in­ter­fa­ces. Daarnaast zijn er de Java-pri­mi­tie­ven. Deze hebben een vaste grootte die op alle platforms hetzelfde is. Ze hebben ook hun eigen wrap­per­klas­se, zijn on­ver­an­der­lijk en hebben een vast waar­de­be­reik. Java-pri­mi­tie­ven worden gebruikt om va­ri­a­be­len te creëren voor in­di­vi­du­e­le getallen, tekens of logische waarden.

In Java zijn er 8 ver­schil­len­de pri­mi­tie­ve ge­ge­vens­ty­pen die voor­na­me­lijk ver­schil­len 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 ver­ge­lijk­ba­re situaties worden gebruikt, kunnen we de Java-pri­mi­tie­ven verder on­der­ver­de­len in vier ca­te­go­rie­ën:

• Logisch ge­ge­vens­ty­pe (booleaans)
• Integraal ge­ge­vens­ty­pe (byte, short, int en long)
• Drijvende-kom­ma­ge­ge­vens­ty­pe (float en double)
• Tekst­ge­ge­vens­ty­pe (char)

Omdat ze recht­streeks in de stack worden op­ge­sla­gen, is hun grootte van bijzonder belang. We zullen hier later in deze hand­lei­ding verder op ingaan. Java-pri­mi­tie­ven zijn ook be­lang­rijk omdat Java een statisch ge­ty­peer­de taal is. Wanneer u een programma maakt, moet u dus al de­fi­ni­ë­ren welk ge­ge­vens­ty­pe een variabele heeft, anders krijgt u fout­mel­din­gen. Hier volgt een overzicht van de Java-pri­mi­tie­ven:

Hoe gebruik je de Java-pri­mi­tie­ve boolean?

Een Java Boolean wordt ook wel een waar­heids­waar­de genoemd. Het is de een­vou­dig­ste 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 ge­ge­vens­ty­pe. In uit­druk­kin­gen staan de twee mogelijke waarden meestal voor een voor­waar­de die wel (true) of niet (false) is vervuld. Als u geen waarde toekent aan een Boolean, krijgt deze de stan­daard­waar­de false. De Boolean kan worden ge­com­bi­neerd met Boole­aan­se ope­ra­to­ren in Java, zoals AND en OR. Het toekennen van een waarde aan een Boolean ziet er als volgt uit:

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 ini­ti­a­li­se­ren, ziet de uitvoer er als volgt uit:

true

byte

byte is het kleinste ge­ge­vens­ty­pe onder de gehele ge­ge­vens­ty­pen. 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 de­cla­re­ren:

public class Main {
	public static void main(String[] args) {
		byte x = 101;
		System.out.println(x);
	}
}

De uitvoer ziet er als volgt uit:

101

kort

short is twee keer zo groot als byte, wat betekent dat het ook een van de minder vaak gebruikte Java-pri­mi­tie­ven is. Maar als byte te klein is en int te groot, dan is short misschien wel het integer-datatype dat u zoekt. Zo de­cla­reert u het:

public class Main {
	public static void main(String[] args) {
		short x = -27412;
		System.out.println(x);
	}
}

De uitvoer ziet er als volgt uit:

-27412

int

int is het meest gebruikte ge­ge­vens­ty­pe voor gehele getallen. Het heeft een zeer groot waar­de­be­reik en bespaart toch ruimte. int is een twee-com­ple­ment­waar­de en wordt ook vaak voor andere doel­ein­den gebruikt. Hier volgt hoe u het kunt gebruiken:

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:

14 + 3 = 17

lang

long is de uit­brei­ding van int en kan nog langere getallen bevatten. int is in de meeste gevallen voldoende, maar als u long wilt de­cla­re­ren, kunt u dat als volgt doen:

public class Main {
	public static void main(String[] args) {
		long x = 47;
		System.out.println(x);
	}
}

Dit is de uitvoer:

47

drijver

Er zijn twee Java-pri­mi­tie­ven voor het weergeven van subsets van rationale getallen. float is de kleinste van de twee drijvende-kom­ma­ge­ge­vens­ty­pen en gebruikt 32 bits. Het kan maximaal 7 decimalen weergeven. Het is echter niet erg nauw­keu­rig en wordt daarom niet vaak gebruikt. Als u besluit om het te gebruiken, kunt u het als volgt de­cla­re­ren:

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 hoofd­let­ter ‘F’ achter het getal invoegen om de computer te laten weten dat het een float is en geen double. De f wordt niet weer­ge­ge­ven in de uitvoer:

7.22

dubbel

Het tweede drijvende-kom­ma­ge­ge­vens­ty­pe is double. Dit is aan­zien­lijk nauw­keu­ri­ger dan float, maar levert nog steeds geen volledig exacte re­sul­ta­ten op. Als u op zoek bent naar een al­ter­na­tief, kunt u ge­bruik­ma­ken van de klasse Big­De­ci­mal. Als double aan uw doel­ein­den voldoet, kunt u dit als volgt de­cla­re­ren:

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:

7.2252

char

char wordt gebruikt om Unicode-tekens weer te geven. Het loopt van ‘\u0000’ tot ‘\uffff’, dus van 0 tot 65535. Het ge­ge­vens­ty­pe character kan bijna alle Europese en Azi­a­ti­sche tekens weergeven. Het gebruikt 16 bits geheugen. De waarden van deze Java-primitief worden tussen enkele aan­ha­lings­te­kens geplaatst. Zo ziet het eruit in code:

public class Main {
	public static void main(String[] args) {
		char x = '&';
		System.out.println(x);
	}
}

De uitvoer ziet er als volgt uit:

&