Informatiedragers van de Java code
Primitieve datatypen (primitive datatypes)
Java kent acht primitieve datatypen die géén objecten zijn: boolean, char, byte, short, int, long, float en double. Deze datatypen zijn puur bestemd om allerlei waarden te kunnen opslaan en rekenkundig ermee te kunnen werken met behulp van Operatoren.
Ofschoon deze datatypen geen objecten zijn, is er van elke datatype wel een zogenaamde wrapper object (omhulzen, omwikkelen): Boolean, Character, Byte, Short, Integer, Long, Float en Double. Met zo'n wrapper-object kun je o.a. de primitieve datatypen converteren naar strings (met de toString() methode) of omgekeerd (met o.a. de parse methoden). Ook kun je hiermee primitieve datatypen converteren naar wrapper objecten of omgekeerd. Zie ook Data conversies.
Terug naar boven
Initialiseren (to initialize)
Met initialiseren wijs je een waarde aan een vers gedeclareerde datatype variabele toe:
// Declareer een integer variabele. Deze is nu nog leeg. int i; // Hier wordt deze variabele pas geinitialiseerd. i = 10; // Dit kan ook tegelijk: declareren én initialiseren. int j = 10;
Je kunt niet direct met een datatype variabele werken zonder deze eerst te initialiseren. Mocht je dat wel doen, dan krijg je in alle gevallen een foutmelding tijdens het compileren naar bytecode:
Unresolved compilation problem: The local variable i may not have been initialized
Maar een ongeinitialiseerde datatype variabele krijgt in specifieke gevallen wel automatisch een standaard waarde toegewezen. Zoals in het geval van een statische variabele en de variabelen van de instanties (dus niet de referentie-variabele zelf, maar de variabelen die in het geinstantieerde object zitten). Welke standaard waarde dit is, staat hieronder wel bij elke datatype vermeld. Let wel, een lege (ongeinitialiseerde) datatype variabele is niet gelijk aan null. Lege (ongeinstantieerde) referentie-variabelen zijn dat wel.
Terug naar boven
Boolean (boolean type)
De boolean datatype kan alleen worden gebruikt om de logische waarden true (waar) of false (onwaar) te bewaren. De boolean is géén nummeriek datatype, terwijl de overige primitieve datatypen dat wel zijn. De boolean wordt met name gebruikt om de flow (stroming, draaiboek) van de Java applicatie te aansturen (als, dan, of, als, dan, of, etc). Ze kunnen ook worden gebruikt voor variabelen die slechts 2 mogelijke waarden kunnen aangeven. Bijvoorbeeld:
// Declareer de boolean variabele die aangeeft of de verlichting aan is. boolean verlichtingAan; // De verlichting staat aan. verlichtingAan = true; // De verlichting staat uit. verlichtingAan = false; // Dit kun je dus ook gebruiken om de flow te aansturen. if (verlichtingAan) { System.out.println("De verlichting staat aan."); } else { System.out.println("De verlichting staat uit."); }
De standaard waarde van een boolean is false.
Terug naar boven
Integers (integer types)
De integers omvatten de byte, short, int en long datatypen. Deze datatypen kunnen alleen gehele nummerieke waarden vasthouden. Het enige verschil tussen deze vier datatypen is de hoeveelheid geheugenruimte dat deze in beslag kan nemen en daaraan gerelateerd de maximum en minimum waarden die je kunt opgeven. Hieronder staat een overzichtje:
| datatype | breedte (bits) | minimum waarde | maximum waarde |
|---|---|---|---|
| byte | 8 | -27 (-128) | 27-1 (127) |
| short | 16 | -215 (-32768) | 215-1 (32767) |
| int | 32 | -231 (-2147483648) | 231-1 (2147483647) |
| long | 64 | -263 (-9223372036854775808L) | 263-1 (9223372036854775807L) |
Om gelijk de eerste vraag te beantwoorden nadat je deze tabel uitgebreid hebt bestudeerd: van de positieve maximum waarden gaat er 1 van de waarde af, omdat de nul (0) ook meetelt als een positieve nummerieke waarde. En de tweede vraag zal vast over de postfix 'L' gaan die achter de long waarde staat: hiermee kun je expliciet aangeven dat het om een long gaat, anders wordt de waarde automatisch geconverteerd naar een int, de "standaard" integer datatype. Bij long waarden van kleiner dan -2147483648 of groter dan 2147483647 zou je anders de volgende foutmelding krijgen:
Unresolved compilation problem: <nummer> is out of range
In principe kun je een nummerieke waarde in alle soorten integers stoppen. Maar als je 100% van mening bent dat deze waarde gedurende de loop van de code nooit groter dan 127 of kleiner dan -128 wordt, dan kun je deze waarde ook gewoon in een byte zetten. Hoe kleiner de datatype, hoe minder geheugenruimte je in beslag neemt. Al is dat vrij fractioneel. De "standaard" integer datatype is de int.
Let wel, de integers rekenen weer bij het begin af door wanneer de maximum waarde wordt overschreden:
// Declareer en initialiseer de verschillende integers. byte b = 100; short s = 30000; int i = 2000000000; long l = 9000000000000000000L; // Nu laten we hun met zichzelf optellen en de uitkomst geven. System.out.println(b += b); System.out.println(s += s); System.out.println(i += i); System.out.println(l += l);
Met als uitkomst:
-56
-5536
-294967296
-446744073709551616
Voor de byte wordt dit even uitgelegd: 100 + 100 = 200. Echter bij de byte wordt er na 127 teruggegaan naar -128 en daarvanuit doorgeteld. Dus wanneer we bij 128 willen zijn, komen we in -128 terecht. Er rest dus nog 200 - 128 = 72, dan tellen we vanaf -128 door met 72: -128 + 72 = -56.
Let wel: b + 100 levert daarentegen wél 200 op, want de "standaard" integer datatype is de int. Wanneer je een integer waarde niet specifiek declareert, dan wordt er dus altijd van een int uitgegaan. Omdat 100 een int is, wordt de b automatisch geconverteerd naar een int. Om dit te voorkomen moet je casten: (byte) (b + 100). Het casten wordt later in deze tutorial uitgelegd: Objecten - Objecten converteren.
De standaard waarde van de integers is 0 (nul).
Terug naar boven
Floating points (floating-point types)
De floating points omvatten de float en double datatypen. Deze datatypen kunnen gebroken nummerieke waarden vasthouden. Het enige verschil tussen deze twee datatypen is de hoeveelheid geheugenruimte dat deze in beslag kan nemen en daaraan gerelateerd de maximum en minimum waarde die je kunt opgeven. Hieronder staat een overzichtje:
| datatype | breedte (bits) | minimum waarde | maximum waarde |
|---|---|---|---|
| float | 32 | ±1.40129846432481707 x 10-45 | ±3.40282346638528860 x 1038 |
| double | 64 | ±4.94065645841246544 x 10-324 | ±1.79769313486231570 x 10308 |
Deze minimum en maximum waarden zijn dus gelijk voor de positieve en de negatieve waarden. De nul kan zowel positief als negatief zijn.
Bij de float en double moet je alle gehele nummerieke waarden specifiek aangeven met een postfix 'F' respectievelijk 'D' of specifiek casten naar float danwel double, anders worden deze waarden aangenomen als een int. Dit is niet nodig bij gebroken nummerieke waarden, deze worden standaard een float. Het casten wordt overigens later in deze tutorial uitgelegd: Objecten - Objecten converteren.
double d1 = 1 / 3; // Gehele nummerieke waarden zijn standaard 'int'. double d2 = 1D / 3D; // Specifieke postfix met 'D'. double d3 = 1.0 / 3.0; // Gebroken nummerieke waarden zijn standaard 'float'. double d4 = (double) 1 / 3; // Specifieke cast naar 'double'. // Laat de waarden zien. System.out.println(d1); System.out.println(d2); System.out.println(d3); System.out.println(d4);
Met als uitkomst:
0.0
0.3333333333333333
0.3333333333333333
0.3333333333333333
De standaard waarde van de floating points is +0.0F voor de float en +0.0D voor de double.
Terug naar boven
Karakter (character type)
De char datatype is 16 bits breed en kan 65536 (216) verschillende Unicode karakters vasthouden. Let wel, niet allemaal tegelijk, maar slechts 1 tegelijk! Niet alleen onze Alfabet komt erin voor, maar ook heel veel Aziatische schriften (Chinees, Koreaans, Japans, etc). Het laatste neemt zo'n 70% van de huidige Unicode karakterset in beslag.
Je kunt de char vullen met een letter of een Unicode code voorafgegaan door een backslash "\". De hoofdletter "A" heeft een Unicode code van "u0041". De char datatype vereist dat je de waarde met enkelvoudige aanhalingstekens ' (single quotes) omvat:
// Declareer en initialiseer de karakters. char a = 'A'; char b = '\u0041'; // Vergelijk de twee karakters. if (a == b) { System.out.println("Ze zijn hetzelfde."); } else { System.out.println("Ze zijn niet hetzelfde."); }
En jawel hoor, de uitkomst is:
Ze zijn hetzelfde.
De standaard waarde van een char is '\u0000' (de Unicode code voor "leeg").
Terug naar boven
En de String?
Nee, de string is geen datatype. Het is een object. Op zich is dat eigenlijk ook logisch, want je kunt helemaal niet rekenen met strings. De String is een speciale object dat alle mogelijke waarden kan opslaan en dan wel puur voor de opslag. De String is een bijzondere object dat niet direct geinstantieerd hoeft te worden met de new sleutelwoord. De String wordt gekenmerkt door een waarde dat is omsloten door dubbele aanhalingstekens " (double quotes). De Java Virtual Machine maakt impliciet een nieuwe String object aan voor alles wat tussen dubbele aanhalingstekens staat. Je kan een String dus op de volgende manieren gebruiken:
// Declareer, instantieer en initialiseer volgens de gebruikelijke manier. String str1 = new String(); str1 = "test1"; // Declareer, instantieer en initialiseer tegelijk. String str2 = new String("test2"); // Declareer en initialiseer zoals bij de datatypen. String str3 = "test3";
Het behoeft geen uitleg dat de laatste manier de meestgebruikte manier is. De eerste twee manieren zijn af te raden, omdat je hier in wezen twéé String objecten aanmaakt (één met de new String() en één met de waarde tussen de dubbele aanhalingstekens), wat alleen maar extra geheugenruimte kost.
Aangezien de String een object is, is de standaard waarde natuurlijk null.
Terug naar boven
In het volgende hoofdstuk wordt uitgelegd op welke manieren je allemaal kunt werken met de hierboven genoemde datatypen en diverse objecten: Operatoren.
Copyright - Niets van deze pagina mag worden overgenomen zonder uitdrukkelijke toestemming.
(C) April 2006, BalusC
No comments:
Post a Comment