1. Lijst met primitieve typen
Java heeft 8 fundamentele primitieve typen. Ze worden primitief genoemd omdat de waarden van deze typen geen objecten zijn en rechtstreeks in variabelen worden opgeslagen.
Hier is een tabel met wat korte informatie over deze typen:
Type | Grootte in bytes |
Waardebereik | Standaardwaarde | Beschrijving |
---|---|---|---|---|
byte |
1 | -128 .. 127 | 0 |
Het kleinste gehele type is een enkele byte |
short |
2 | -32.768 .. 32.767 | 0 |
Kort geheel getal, twee bytes |
int |
4 | -2*10 9 .. 2*10 9 | 0 |
Geheel getal, 4 bytes |
long |
8 | -9*10 18 .. 9*10 18 | 0L |
Lang geheel getal, 8 bytes |
float |
4 | -10 38 .. 10 38 | 0.0f |
Drijvend-kommagetal, 4 bytes |
double |
8 | -10 308 .. 10 308 | 0.0d |
Drijvende kommagetal met dubbele precisie, 8 bytes |
boolean |
1 | true ,false |
false |
Booleaans type (alleen true en false ) |
char |
2 | 0 .. 65.535 | '\u0000' |
Tekens, 2 bytes, allemaal groter dan 0 |
Trouwens, hier is een belangrijke nuance. Als u een instantievariabele (veld) of een statische klassevariabele declareert en er niet onmiddellijk een waarde aan toekent, wordt deze geïnitialiseerd met een standaardwaarde . De tabel bevat een lijst van deze waarden.
Lokale variabelen in een methode hebben geen standaardwaarde. Als u geen waarde toewijst aan dergelijke variabelen, worden ze als niet-geïnitialiseerd beschouwd en kunnen ze niet worden gebruikt.
Maar laten we terugkeren naar primitieve typen en ze eens nader bekijken.
2. Integer-typen
Java heeft 4 typen gehele getallen: byte
, short
, int
en long
. Ze verschillen in hun grootte en het bereik van waarden die ze kunnen opslaan.
int
type
De meest gebruikte is het int
type. De naam komt van het woord integer ( geheel getal). Alle letterlijke gehele getallen (hele getallen) in code zijn ints
(als ze niet eindigen op een L
, F
, of D
).
Variabelen van dit type kunnen waarden aannemen van -2,147,483,648
tot +2,147,483,647
.
Dat is veel en voldoende voor bijna elke gelegenheid. Bijna elke functie die een getal retourneert, retourneert een int
.
Voorbeelden:
Code | Uitleg |
---|---|
|
De length() methode retourneert de lengte van een string |
|
Het length veld bevat de lengte van de array. |
short
type
Het short
type dankt zijn naam aan short int
. Het wordt ook vaak een kort geheel getal genoemd . In tegenstelling tot het int
type is de lengte slechts twee bytes en is het bereik van mogelijke waarden van -32,768
tot +32,767
.
Dat betekent dat je het getal een miljoen er niet in kunt opslaan. Of zelfs 50.000. Dit is het meest zelden gebruikte integer-type in Java. De belangrijkste motivatie om het te gebruiken is om geheugen te besparen.
Stel dat je een situatie hebt waarin je van tevoren weet dat je gaat werken met waarden die nooit hoger zijn dan 30.000, en er zullen miljoenen van deze waarden zijn.
Stel dat u bijvoorbeeld een toepassing schrijft die afbeeldingen met ultrahoge definitie verwerkt die 10
-bits per kleur gebruiken. En je hebt een miljoen pixels in je foto. Dit is een scenario waarbij de beslissing om te gebruiken int
of short
ertoe doet.
long
type
Dit type dankt zijn naam aan long int
en wordt ook wel een lang geheel getal genoemd . In tegenstelling tot het int
type heeft het een fabelachtig enorm scala aan waarden: van tot .-9*1018
+9*1018
Waarom is het niet het standaard integer type?
Omdat Java halverwege de jaren 90 verscheen, toen de meeste computers 32-bits waren. Dat betekent dat alle processors zijn geoptimaliseerd voor het werken met getallen bestaande uit 32 bits. Processors konden werken met 64-bits gehele getallen, maar de bewerkingen ermee waren langzamer.
Als gevolg hiervan besloten programmeurs redelijkerwijs om int
het standaard integer-type te maken en het long
type alleen te gebruiken wanneer het echt nodig is.
byte
type
Dit is het kleinste gehele type in Java, maar verre van het minst gebruikt. De naam, byte
, is ook het woord voor het kleinste adresseerbare geheugenblok in Java.
Er zijn niet zoveel geldige waarden voor het byte
type: from -128
to +127
. Maar dat is niet zijn kracht. Het byte
type wordt meestal gebruikt wanneer u grote blobgegevens in het geheugen moet opslaan. Een reeks van byte
s is hiervoor ideaal.
Stel dat u ergens een bestand moet kopiëren.
U hoeft de inhoud van het bestand niet te verwerken: u wilt gewoon een geheugengebied (buffer) maken, de inhoud van het bestand erin kopiëren en die gegevens vervolgens van de buffer naar een ander bestand schrijven. byte
Hiervoor heb je een array nodig.
Houd er rekening mee dat een matrixvariabele alleen een verwijzing naar een geheugengebied opslaat. Wanneer de variabele wordt doorgegeven aan een methode, wordt alleen het geheugenadres doorgegeven. Het geheugenblok zelf wordt niet gekopieerd.
byte[] buffer = new byte[1024*1024];
FileInputStream sourceFile = new FileInputStream("c:\\data.txt");
FileOutputStream destFile = new FileOutputStream("c:\\output.txt");
while (true)
{
int size = sourceFile.read(buffer); // Read data from a file into a buffer
destFile.write(buffer, 0, size); // Write data from the buffer to a file
// Stop copying if the buffer is not full
if (size < buffer.length) break;
}
sourceFile.close();
destFile.close();
3. Echte typen
De primitieve typen omvatten twee typen voor reële getallen. Hoewel het niet helemaal juist is om die term te gebruiken. Wanneer computers met reële getallen omgaan, noemen we ze getallen met drijvende komma . De naam komt van een standaard voor het weergeven van getallen, waarbij de gehele en gebroken delen van een getal worden gescheiden door een punt (een punt, geen komma).
Elk land heeft zijn eigen normen voor het schrijven van cijfers (verrassing!).
Veel mensen zijn gewend om punten te gebruiken om duizendtallen te scheiden en komma's als decimaal scheidingsteken: ze zouden bijvoorbeeld schrijven one million ones and 153 thousandths
als 1.000.000,153
. Maar in de Verenigde Staten, waar de makers van Java woonden, werd een andere standaard aangenomen:1000000.153
Java heeft twee primitieve typen met drijvende komma: double
en float
.
Zoals we eerder zeiden, hebben deze typen een zeer specifieke interne rangschikking: in feite is binnen elke variabele van deze typen niet één getal, maar twee:
Het getal met drijvende komma kan bijvoorbeeld 987654.321
worden weergegeven als . Dan wordt het in het geheugen weergegeven als twee getallen (de mantisse , dwz het significante deel van het getal) en ( exponent , dwz een macht van tien)0.987654321*106
987654321
6
float
type
De naam van het float
type komt van een getal met drijvende komma . De grootte van dit type is vrij klein - slechts 4 bytes (32 bits) - maar het kan waarden opslaan van tot . Er zijn 24 bits toegewezen voor het weergeven van de mantisse en 8 bits voor de exponent. Dit type kan slechts 8 significante cijfers opslaan.-3.4*1038
3.4*1038
Deze benadering maakt het mogelijk om veel grotere getallen op te slaan dan een int
, terwijl dezelfde 4 bytes worden gebruikt. Maar om dat te doen, offeren we nauwkeurigheid op. Omdat een deel van het geheugen de mantisse opslaat, slaan deze variabelen slechts 6-7 decimalen op, terwijl de rest wordt weggegooid.
Voorbeeld:
Code | Waarde |
---|---|
|
123.45679 |
|
12346.0 |
|
-1.2345679 |
Zoals u kunt zien, is het belangrijkste nadeel van dit type het zeer kleine aantal significante cijfers en het verlies van precisie vanaf het achtste cijfer. Daarom float
is het type niet erg populair onder Java-programmeurs.
double
type
Het double
type is het standaard drijvende-kommatype. De naam komt van dubbele precisie floating-point number . Alle echte literals zijn double
standaard s.
Dit type neemt 8 bytes geheugen in beslag (64 bits) en kan waarden opslaan van tot . Een belangrijk ding om te weten is dat 53 bits zijn toegewezen voor de mantisse, terwijl de resterende 11 voor de exponent zijn.-1.7*10308
1.7*10308
Hierdoor kunnen 15-17 significante cijfers worden opgeslagen.
Voorbeeld:
Code | Waarde |
---|---|
|
1234567890.1234567 |
|
1234567890.1234512 |
|
1234567890.1357913 |
Deze precisie, zeker in vergelijking met het float
type, is doorslaggevend: 99% van alle bewerkingen met reële getallen wordt uitgevoerd met behulp van het double
type.
11
bits worden toegewezen voor de exponent, wat betekent dat je machten van tien kunt opslaan van -323
tot +308
(dat is een macht van twee van -1024
tot +1023
). Het double
type kan gemakkelijk een getal opslaan met honderden nullen achter de komma:
Code | Waarde |
---|---|
|
600.0 |
4. Oneindigheid
Drijvende-kommagetallen hebben nog een ander interessant kenmerk: ze kunnen een speciale waarde opslaan die oneindigheid aangeeft . En je kunt positieve oneindigheid en negatieve oneindigheid vertegenwoordigen .
Voorbeelden:
Code | Opmerking |
---|---|
|
|
|
|
|
|
Als oneindig wordt vermenigvuldigd met een getal, krijg je oneindig. Als je een getal optelt bij oneindig, krijg je oneindig. Dat is superhandig.
Geen nummer ( NaN
)
Elke bewerking waarbij oneindigheid betrokken is, levert oneindig op. Nou ja, de meeste maar niet alle.
Drijvende-kommagetallen kunnen nog een speciale waarde opslaan: NaN
. Het is een afkorting van Not a Number ( geen nummer ) .
Als je in de wiskunde oneindig door oneindig deelt, is het resultaat ongedefinieerd.
Maar als je in Java oneindig door oneindig deelt, is het resultaat NaN
.
Voorbeelden:
Code | Opmerking |
---|---|
|
|
|
|
|
|
Elke operatie met NaN
opbrengsten NaN
.
5. char
typen
Van de primitieve typen van Java verdient er één speciale aandacht: het char
type. De naam komt van het woord karakter en het type zelf wordt gebruikt om karakters op te slaan.
Tekens zijn waar snaren van gemaakt zijn, toch? Strings zijn een reeks tekens.
Maar nog interessanter is het feit dat het char
type ook een numeriek type is ! Het is een soort met twee doelen, om zo te zeggen.
De realiteit is dat het char
type eigenlijk geen karakters heeft. In plaats daarvan slaat het tekencodes op van de Unicode-codering. Elk teken komt overeen met een nummer: de numerieke code van het teken.
Elke char
variabele neemt twee bytes in het geheugen in beslag (hetzelfde als het short
type). Maar in tegenstelling tot het short
type, char
is het type integer niet ondertekend en kan het waarden opslaan van 0
tot 65,535
.
Het char
type is een hybride type. De waarden kunnen zowel als getallen worden geïnterpreteerd (ze kunnen bijvoorbeeld worden opgeteld en vermenigvuldigd) als als tekens. Dit werd gedaan omdat, hoewel karakters visuele representaties zijn, ze voor een computer vooral cijfers zijn. En het is veel handiger om ermee te werken als cijfers.
Unicode
Unicode is een speciale tabel (codering) die alle tekens ter wereld bevat. En elk personage heeft zijn eigen nummer. Het ziet er ongeveer zo uit:
Er zijn verschillende manieren om een waarde toe te kennen aan een char
variabele.
Code | Beschrijving |
---|---|
|
De a variabele zal de Latijnse letter bevatten A . |
|
De a variabele zal de Latijnse letter bevatten A . De code is 65 . |
|
De a variabele zal de Latijnse letter bevatten A . De code is 65 , wat gelijk is 41 aan het hexadecimale systeem. |
|
De a variabele zal de Latijnse letter bevatten A . De code is 65 , wat gelijk is 41 aan het hexadecimale systeem. De twee extra nullen veranderen niets. |
|
De a variabele zal de Latijnse letter bevatten A . Een andere manier om een karakter te definiëren aan de hand van zijn code. |
Meestal geven mensen het teken eenvoudig tussen aanhalingstekens aan (zoals in de eerste rij van de tabel). Dat gezegd hebbende, de laatste methode is ook populair. Het voordeel is dat het in strings kan worden gebruikt.
En zoals we al zeiden, het char
type is ook een geheel getal, dus je kunt zoiets als dit schrijven:
Code | Console-uitvoer |
---|---|
|
De Latijnse letter B wordt op het scherm weergegeven. Omdat: A – 65 B – 66 C –67 |
Werken met char
s
Elk char
is allereerst een nummer (tekencode) en vervolgens een teken. Als u een tekencode kent, kunt u het teken altijd in uw programma krijgen. Voorbeeld:
Code | Console-uitvoer |
---|---|
|
|
Standaard codes
Dit zijn de meest bekende karaktercodes:
Karakters | Codes |
---|---|
0 , 1 , 2 , ...9 |
48 , 49 , 50 , ...57 |
a , b , c , ...z |
97 , 98 , 99 , ...122 |
A , B , C , ...Z |
65 , 66 , 67 , ...90 |
6. boolean
typen
En het laatste primitieve type is boolean
.
Zoals u al weet, kan het slechts twee waarden aannemen: true
en false
.
En daarmee weet je al alles wat er te weten valt over dit type.