Eerste Java-programma’s

Een eerste Java-programma geeft de computer een korte lijst met instructies. De omringende klasse en main-methode vertellen Java waar die instructies horen en waar de uitvoering begint.

Plaats instructies binnen main

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

De buitenste accolades omsluiten de klassebody. De binnenste accolades omsluiten de methodebody. Wanneer dit programma start, voert Java de eerste instructie binnen main uit. Meer instructies die daaronder staan, worden van boven naar beneden uitgevoerd. Wanneer main klaar is, eindigt dit kleine programma.

Neem public static void main(String[] args) zorgvuldig over. Hier zorgt public ervoor dat het startprogramma de methode kan aanroepen, maakt static uitvoering mogelijk zonder eerst een object te maken en geeft void aan dat de methode geen resultaat teruggeeft. String[] args ontvangt woorden die op de opdrachtregel na de programmanaam zijn getypt. Je kunt een bericht weergeven zonder die woorden te gebruiken.

Laat leestekens en namen overeenkomen

Een instructie zoals System.out.println("Hi"); eindigt met een puntkomma. Bij een openingsaccolade { hoort een sluitaccolade }. De hierboven getoonde klasse- en methodekop openen blokken; vervang die openingsaccolades niet door puntkomma’s. Als je de instructie vier spaties verder laat inspringen dan de methodekop, wordt de nesting zichtbaar.

Sla public class Hello op in Hello.java. De naam van de publieke klasse en het deel vóór .java moeten exact overeenkomen, inclusief hoofdletters. Als de declaratie public class Other luidt, moet het bestand Other.java heten. Een compilermelding dat de klasse in een ander bestand moet worden gedeclareerd, wijst op dit verschil.

Java is hoofdlettergevoelig. De naam System moet met een hoofdletter S beginnen; system.out.println("Hi"); compileert niet. Een methode met de naam Main is een andere methode dan main. Een klasse met alleen Main kan compileren, maar het startprogramma kan de bedoelde startmethode niet vinden wanneer je het programma uitvoert.

Maak de code leesbaar

Gebruik één instructie per regel en laat elk niveau tussen accolades vier spaties inspringen. De meeste spaties en regeleinden tussen code-elementen hebben geen invloed op het compileren. Spaties binnen tekst tussen aanhalingstekens hebben wel invloed op de uitvoer. Klassenamen staan volgens de conventie in PascalCase, zoals TravelTime.

Commentaar legt code uit aan mensen. Java negeert alles na // op die regel. Blokcommentaar begint met /* en eindigt met */ en kan meerdere regels beslaan. Nuttig commentaar legt een reden uit, zoals // Convert hours to seconds naast een omzetting waarvan het doel misschien onduidelijk is.

Herken de kortere vorm

Java 25 en later ondersteunen ook een compact bronbestand:

void main() {
    IO.println("Hello, world!");
}

Deze vorm laat de expliciete klassedeclaratie weg. IO.println geeft een regel weer en IO.readln("Your name: ") toont een invoervraag en geeft de getypte regel terug. De klassieke vorm met een klasse werkt ook met oudere Java-versies; beide vormen hebben een main-methode waar de uitvoering begint.

Broncode schrijven en een programma uitvoeren zijn afzonderlijke stappen. Java controleert en vertaalt je code eerst en voert die daarna uit. Als je weet welke stap is mislukt, kun je bepalen waar je moet zoeken.

Compileer de broncode en start daarna de klasse

Broncode is de tekst in een .java-bestand. De compiler, javac, vertaalt geldige broncode naar bytecode in een .class-bestand. De Java Virtual Machine (JVM) voert die bytecode uit. Met een geschikte JVM kan dezelfde bytecode op verschillende besturingssystemen worden uitgevoerd.

Open een terminal in de map met Hello.java en voer in:

javac Hello.java
java Hello

De eerste opdracht maakt Hello.class als het compileren slaagt. De tweede start het programma. Het argument is de klassenaam, zonder .class: met java Hello.class vraag je het startprogramma naar de verkeerde klassenaam te zoeken en dat mislukt.

De JDK, oftewel Java Development Kit, levert beide opdrachten. Een IDE, zoals IntelliJ IDEA, Eclipse, NetBeans of Visual Studio Code met Java-ondersteuning, compileert en start het programma wanneer je op de uitvoerknop drukt. De omgeving kan fouten markeren terwijl je typt, maar het zijn nog steeds fouten in dezelfde Java-taal.

Sinds Java 11 biedt de bronbestandsmodus een kortere route voor één klein programma:

java Hello.java

Hiermee wordt de broncode in het geheugen gecompileerd en uitgevoerd zonder een .class-bestand achter te laten. Houd de twee vormen uit elkaar: java Hello start een gecompileerde klasse, terwijl java Hello.java broncode start.

Lees compilatiefouten

Een compilatiefout verhindert dat de code met succes wordt gecompileerd. Een ontbrekende puntkomma kan bijvoorbeeld dit opleveren:

Hello.java:3: error: ';' expected
        System.out.println("Hello")
                                   ^

De melding geeft het bestand, de regel en de plek aan waar de compiler het probleem opmerkte. De werkelijke fout kan eerder staan: een niet-afgesloten aanhalingsteken op één regel kan latere regels verstoren. Lees de gemarkeerde regel en de regel ervoor. Herstel de eerste gemelde fout en compileer opnieuw voordat je meerdere andere regels wijzigt. Eén reparatie kan veel latere meldingen laten verdwijnen.

Onderscheid uitvoeringsfouten van verkeerde antwoorden

Als een variabele divisor van een geheel type nul bevat, mislukt 5 / divisor tijdens de uitvoering met ArithmeticException: / by zero. De rekenkundige instructie kan geldige broncode zijn, ook al veroorzaken de waarden tijdens de uitvoering een fout.

Een programma dat een gemiddelde van 8 weergeeft terwijl de juiste waarde ongeveer 8,33 is, heeft een logische fout. Geen compilermelding kan je vertellen dat dit voor jouw taak het verkeerde resultaat is. Test met bekende invoer, inspecteer tussenwaarden en zoek de eerste onjuiste berekening.

Werk in een korte cyclus: bewerken, opslaan, compileren, uitvoeren, testen. Opslaan is belangrijk: compileren leest het opgeslagen bestand, dus niet-opgeslagen wijzigingen kunnen het gecompileerde programma niet veranderen.

Weergegeven uitvoer is de eerste manier om te zien wat een programma doet. Met Java bepaal je welke tekens worden weergegeven en waar de volgende regel begint.

Volg de uitvoerpositie

System.out.print(...) schrijft de waarde en laat de uitvoerpositie op dezelfde regel staan. System.out.println(...) schrijft de waarde en begint daarna een nieuwe regel. Een aanroep van System.out.println() met lege haakjes voegt alleen een regeleinde toe.

System.out.print("Hello");
System.out.print(", ");
System.out.println("world");
System.out.println("Bye");

De eerste twee aanroepen laten de positie achter de spatie na de komma staan. De derde voegt world op die positie toe en gaat dan naar een nieuwe regel. De exacte uitvoer is:

Hello, world
Bye

Java voegt geen spaties tussen aanroepen in. Als je de spatie in ", " verwijdert, wordt de eerste regel “Hello,world”. Een lege println() tussen de laatste twee instructies zou een lege regel tussen de berichten maken.

Bepaal of je tekst of een waarde wilt

Een stringliteral is tekst tussen dubbele aanhalingstekens. Als je "7 * 6" weergeeft, verschijnt de tekst “7 * 6”. Als je 7 * 6 weergeeft, wordt de vermenigvuldiging geëvalueerd en verschijnt “42”. De aanhalingstekens zijn leestekens in de code; ze worden niet als onderdeel van de literal weergegeven.

Als name bijvoorbeeld “Ada” bevat, geeft System.out.println(name); “Ada” weer, terwijl System.out.println("name"); “name” weergeeft. Gebruik de variabele zonder aanhalingstekens als je de opgeslagen waarde wilt.

Enkele aanhalingstekens hebben een andere rol. 'A' is één char-waarde. 'Hello' kan geen bericht met meerdere tekens bevatten en veroorzaakt een compilatiefout. Gebruik "Hello" voor die tekst.

Zet speciale tekens in een string

Een escapesequentie begint met een backslash en stelt een teken binnen de literal voor.

Bijvoorbeeld:

System.out.println("She said \"hi\"");
System.out.println("C:\\Users");

Deze instructies geven She said "hi" en C:\Users weer, op afzonderlijke regels. De extra backslashes vertellen Java hoe het volgende teken moet worden geïnterpreteerd; ze worden niet allemaal naar de uitvoer gekopieerd.

Eén aanroep kan ook meerdere regels weergeven:

System.out.println("Name:\tAda\nAge:\t36");

De tab scheidt het label van de waarde en \n zet de leeftijd op de volgende regel. De aanroep van println voegt ook zelf een afsluitend regeleinde toe. Een tab gaat naar een tabstop, dus de zichtbare breedte hangt af van de uitvoeromgeving.

Een gewone stringliteral tussen aanhalingstekens moet op dezelfde bronregel beginnen en eindigen. Als je midden in de literal op Enter drukt, blijft die onafgesloten. Om een lang bericht over bronregels te verdelen, schrijf je twee volledige literals die je met + verbindt, of gebruik je afzonderlijke aanroepen voor uitvoer.

Een variabele geeft een waarde een naam, zodat latere instructies die kunnen gebruiken. Het type vertelt Java welke soort waarde de variabele kan bevatten; een toewijzing verandert de opgeslagen waarde.

Declareer en initialiseer

int age;
age = 36;

De declaratie introduceert age als een int. De toewijzing slaat 36 op. De gecombineerde vorm int age = 36; heet initialisatie. Een lokale variabele moet een waarde krijgen voordat je die leest. Als je int age; declareert en direct daarna age weergeeft, krijg je een foutmelding dat de variabele mogelijk niet is geïnitialiseerd.

Declareer een naam één keer binnen dezelfde methodebody. Om de waarde later te veranderen, schrijf je age = 37;, zonder int te herhalen. Een tweede int age = 37; in die body probeert dezelfde variabele opnieuw te declareren.

Lees een toewijzing van rechts naar links

De rechterkant van = wordt eerst berekend. Java slaat dat resultaat daarna op in de variabele links:

int count = 5;
count = count + 1;

De tweede instructie leest de huidige waarde 5, telt er 1 bij op en slaat 6 op. Het teken = betekent toewijzing, geen wiskundige bewering dat een getal gelijk is aan zichzelf plus één. De linkerkant moet een plek aangeven waar de waarde kan worden opgeslagen; 36 = age; is ongeldig.

Een toewijzing kopieert de waarde op dat moment:

int a = 5;
int b = a;
a = 10;

Nu bevat a de waarde 10 en b de waarde 5. Er blijft geen verbinding bestaan die b opnieuw berekent als a verandert.

Volg een verwisseling

Stel dat first de waarde 4 bevat en second de waarde 9. De reeks first = second; second = first; verliest de 4 bij de eerste stap en laat beide waarden op 9 staan. Bewaar eerst de oorspronkelijke waarde:

int temp = first;
first = second;
second = temp;

Een traceertabel legt elke variabele na elke instructie vast. Bij int x = 3; x = x * 2; x = x + 1; zijn de waarden eerst 3, dan 6 en dan 7. Werk telkens één rij bij met de laatst opgeslagen waarden.

Kies bruikbare namen en vaste typen

Namen mogen letters, cijfers, onderstrepingstekens en dollartekens bevatten. Ze mogen niet met een cijfer beginnen of een gereserveerd woord zoals class zijn. Hoofdletters zijn belangrijk: total en Total verschillen. Gebruik beschrijvende namen in camelCase, zoals distanceKm of secondsLeft.

Aan een final-variabele kun je maar één keer een waarde toewijzen. final int SECONDS_PER_HOUR = 3600; geeft een vaste omrekeningsfactor een duidelijke naam. Een nieuwe toewijzing compileert niet. Namen van constanten bestaan volgens de conventie uit hoofdletters, met onderstrepingstekens tussen de woorden.

Sinds Java 10 kan var het type van een lokale variabele afleiden uit de initialisatiewaarde. var count = 10; leidt int af; var price = 2.5; leidt double af. Het afgeleide type blijft vast. var count; mislukt omdat er geen initialisatiewaarde is waaruit een type kan worden afgeleid.

Het type van een waarde bepaalt het bereik, de schrijfwijze van de literal en de berekeningen die Java ermee kan uitvoeren. Gebruik int voor gewone aantallen en double voor gewone metingen, en herken ook de andere primitieve typen.

Vergelijk de acht primitieve typen

Eindige float-waarden lopen bij benadering van −3,4 × 10³⁸ tot +3,4 × 10³⁸; eindige double-waarden lopen bij benadering van −1,8 × 10³⁰⁸ tot +1,8 × 10³⁰⁸. Deze grote bereiken betekenen niet dat elk kommagetal erin exact kan worden weergegeven.

Een char stelt vaak één teken voor, zoals 'A'. Sommige Unicode-tekens hebben twee UTF-16-code-eenheden nodig, dus één char kan niet elk mogelijk teken voorstellen. 'A' heeft de numerieke code 65, 'a' heeft 97 en '7' heeft 55. Het teken '7' is iets anders dan het gehele getal 7. Een boolean is geen getal: boolean active = 1; mislukt.

Schrijf literals passend bij hun type

Een literal schrijft een waarde rechtstreeks in de broncode. 42 is een int-literal, 42L een long, 3.5 een double en 3.5f een float. Tekenliterals gebruiken enkele aanhalingstekens; String-literals gebruiken dubbele aanhalingstekens. Namen van primitieve typen schrijf je met kleine letters, terwijl String met een hoofdletter begint.

Schrijf long large = 3000000000L;. Zonder de L is die literal voor een geheel getal te groot. Schrijf float rate = 3.5f;: 3.5 zonder toevoeging heeft het type double, dat Java niet stilzwijgend versmalt naar float. Een constante met een geheel getal dat past, kan een kleiner geheel type initialiseren: byte b = 100; compileert, maar byte b = 200; niet.

Onderstrepingstekens tussen cijfers maken een literal leesbaar: 1_000_000 heeft dezelfde waarde als 1000000. Wetenschappelijke notatie gebruikt e, zoals in 1.5e3, wat 1500,0 betekent. Decimalen in broncode gebruiken altijd een punt.

Let op het bereik van de bewerking

Bij een berekening met gehele getallen kan overloop optreden zonder foutmelding. Als je 1 optelt bij de grootste int, loopt de waarde door naar de kleinste int. Het product 50_000 * 50_000 gebruikt int-rekenkunde en levert -1794967296 op. In 50_000L * 50_000 is één operand een long, waardoor het product de juiste waarde 2500000000 heeft.

Als je alleen de ontvangende variabele verandert in een long, ben je te laat om een int-product te herstellen waarbij al overloop is opgetreden. Kies vóór de vermenigvuldiging een operand met een voldoende groot bereik.

Zwevendekommawaarden hebben een andere beperking. Veel decimale breuken worden opgeslagen als binaire benaderingen: 0.1 + 0.2 geeft 0.30000000000000004 weer. Maak zulke resultaten op voor de weergave. Bij exacte geldberekeningen kun je hele centen opslaan in een long; de klasse BigDecimal is een andere mogelijkheid om exact met decimalen te rekenen.

Een String bevat tekst, met bijvoorbeeld spaties, cijfers en leestekens, of helemaal geen tekens. De operator + kan die tekst combineren met andere waarden om een bericht op te bouwen.

Voeg waarden samen tot tekst

String firstName = "Ada";
String lastName = "Lovelace";
System.out.println(firstName + " " + lastName);

De uitvoer is “Ada Lovelace”. De middelste literal levert de spatie. Zonder die literal zou firstName + lastName de uitvoer “AdaLovelace” opleveren. Concatenatie voegt zelf geen scheidingstekens toe.

Concatenatie betekent waarden samenvoegen tot een nieuwe string. Als een van beide operanden van + een String is, zet Java de andere waarde om naar tekst en voegt die samen. Zo wordt "Age: " + 36 de tekst “Age: 36” en wordt "Price: " + 2.5 de tekst “Price: 2.5”. De cijfers in het resultaat maken nu deel uit van een tekstwaarde.

String begint met een hoofdletter S. Anders dan de acht primitieve typen is het een klasse. Als je string name = "Ada"; met een kleine s schrijft, compileert de code niet. De lege string "" is geldige tekst zonder tekens; het is geen ontbrekende waarde.

Volg plustekens van links naar rechts

Bekijk:

System.out.println("Sum: " + 2 + 3);

De eerste + voegt de String en 2 samen tot “Sum: 2”. De tweede voegt die String en 3 samen tot “Sum: 23”. Zodra het tussenresultaat tekst is, blijft de volgende + tekst samenvoegen.

Vergelijk drie vormen:

Gebruik haakjes wanneer een bericht het resultaat van een optelling of aftrekking moet bevatten. "Diff: " + (5 - 2) geeft bijvoorbeeld “Diff: 3”. Zonder haakjes probeert "Diff: " + 5 - 2 2 van een String af te trekken en compileert de code niet.

Vermenigvuldigen en delen hebben een hogere prioriteit dan +. De expressie "Area: " + 4 * 5 berekent eerst het product en geeft “Area: 20”.

Bouw een bericht in stappen op

String message = "Hi";
message += "!";

De bijgewerkte variabele bevat “Hi!”. Bij een String voegt += tekst achteraan toe door het samengevoegde resultaat weer aan de variabele toe te wijzen. Je kunt met meerdere instructies een kort bericht samenstellen en het aan het einde één keer weergeven.

Let op bij tekens. Twee char-operanden leiden niet tot Stringconcatenatie. 'A' + 'B' telt hun numerieke codes, 65 en 66, op en levert de int 131 op. Als je met de lege String begint, verandert de keten: "" + 'A' + 'B' maakt eerst “A” en daarna “AB”. Aanhalingstekens bepalen de typen van de operanden en dus ook de betekenis van +.

Een expressie combineert waarden om een resultaat op te leveren. Java evalueert die volgens de operatorprioriteit; daarna kan een instructie dat resultaat opslaan of weergeven.

Schrijf de bewerkingen expliciet

De rekenkundige operatoren zijn +, -, *, / en %: optellen, aftrekken, vermenigvuldigen, delen en rest. Met int width = 4; en int height = 5; wordt width * height geëvalueerd tot 20.

Elke vermenigvuldiging heeft * nodig. De algebraïsche vorm 2(3 + 4) is ongeldige Java-code; schrijf 2 * (3 + 4). Java heeft geen rekenkundige machtsoperator. 2 ^ 3 betekent een bitsgewijze bewerking en levert 1 op, geen 8. Om een waarde te kwadrateren schrijf je x * x; gebruik Math.pow om een andere macht te berekenen.

Pas de prioriteit toe voordat je van links naar rechts leest

Op hetzelfde niveau worden deze rekenkundige operatoren van links naar rechts gegroepeerd. 2 + 3 * 4 is 14; (2 + 3) * 4 is 20. In 10 - 4 - 3 geeft de eerste aftrekking 6 en de tweede 3. In 24 / 4 * 2 geeft de deling 6 en de vermenigvuldiging 12. Om 4 * 2 als noemer te behandelen, zijn haakjes nodig.

Bereken een gemiddelde correct

Stel int a = 7, b = 8, c = 10;. De expressie a + b + c / 3 deelt alleen c. Door geheeltallige deling is 10 / 3 gelijk aan 3 en de optellingen geven daarna 18.

(a + b + c) / 3 groepeert het hele totaal, 25, maar beide operanden van / zijn gehele getallen. Het resultaat is 8. Met (a + b + c) / 3.0 blijft het breukdeel behouden en krijg je 8.333333333333334.

De typen van de operanden bepalen de berekening. Twee int-operanden leveren een int-resultaat op. Door een double-operand wordt de andere numerieke operand omgezet naar double, zoals in 5 * 2.0, met als resultaat 10.0. De ontvangende variabele verandert niet hoe de eerdere berekening is uitgevoerd.

Werk een opgeslagen waarde bij

int total = 10;
total += 5;
total *= 2;
total--;

De opgeslagen waarden worden achtereenvolgens 10, 15, 30 en 29. Voor deze int-operanden voert total += 5; dezelfde bijwerking uit als total = total + 5;. De operatoren -=, /= en %= combineren op dezelfde manier een bewerking met een toewijzing. count++; verhoogt een variabele met 1 en count--; verlaagt die met 1. Als je ze als afzonderlijke instructies gebruikt, is hun effect gemakkelijk te volgen.

Een expressie zoals a + b verandert geen van beide operanden. Om het resultaat te gebruiken, wijs je het toe of geef je het door aan een aanroep voor uitvoer: int sum = a + b; of System.out.println(a + b);. De losse regel a + b; compileert niet, omdat Java die rekenkundige expressie niet als zelfstandige instructie toestaat. Toewijzingen, increments, decrements en methodeaanroepen kunnen zelfstandig voorkomen en kunnen effecten hebben.

Geheeltallige deling geeft antwoord op de vraag hoeveel complete groepen passen. De rest vertelt je wat overblijft. Samen splitsen deze bewerkingen een hoeveelheid op in bruikbare delen.

Voorspel quotiënt en rest

Als beide operanden gehele getallen zijn, laat / het breukdeel weg en gaat de uitkomst richting nul. 7 / 2 is 3, 2 / 3 is 0 en -7 / 2 is −3. Dit is afkappen, geen afronding op het dichtstbijzijnde gehele getal.

De restoperator % geeft terug wat na de deling overblijft. 17 / 5 geeft 3 en 17 % 5 geeft 2. Drie groepen van 5 zijn samen 15, zodat 2 overblijft. Voor gehele operanden en een deler ongelijk aan nul reconstrueert (a / b) * b + a % b de waarde a met Java-rekenkunde voor gehele getallen.

Het teken van een rest ongelijk aan nul volgt de linkeroperand: -7 % 3 is −1, terwijl 7 % -3 gelijk is aan 1. Voor niet-negatieve gehele getallen is n % 2 gelijk aan 0 bij even waarden en 1 bij oneven waarden.

Splits seconden op in grotere eenheden

Begin met 3725 seconden:

int totalSeconds = 3725;
int hours = totalSeconds / 3600;
int secondsAfterHours = totalSeconds % 3600;
int minutes = secondsAfterHours / 60;
int seconds = secondsAfterHours % 60;

De eerste deling vindt 1 volledig uur. De rest is 125 seconden. Als je die rest deelt door 60, vind je 2 minuten, met 5 seconden over. Het resultaat is 1 h 2 min 5 s. Als je het totaal opnieuw opbouwt, krijg je 3600 seconden plus 120 seconden plus 5 seconden, oftewel 3725.

Gebruik de rest na het verwijderen van uren om de minuten binnen het huidige uur te vinden. Als je het oorspronkelijke totaal door 60 deelt, krijg je alle 62 volledige minuten, inclusief de minuten die al als een uur zijn meegeteld.

Met dezelfde operatoren haal je decimale cijfers uit een niet-negatief geheel getal. 4827 % 10 geeft het laatste cijfer, 7; 4827 / 10 geeft de resterende voorste cijfers, 482.

Onderscheid volle groepen van voldoende verpakkingen

Voor 50 eieren en dozen waarin 12 eieren passen, geeft 50 / 12 4 volle dozen en geeft 50 % 12 2 eieren over. Om alle eieren te verpakken is een vijfde doos nodig. Voor niet-negatieve aantallen en positieve doosgroottes rondt de expressie met gehele getallen (count + size - 1) / size het aantal verpakkingen naar boven af, mits bij de optelling geen overloop optreedt. Voor dit voorbeeld geeft (50 + 12 - 1) / 12 de waarde 5.

Kies een deling met breukdeel voordat die plaatsvindt

Een double als doel kan een weggelaten breukdeel niet terughalen. Maak een operand vóór de deling een double wanneer je het breukdeel nodig hebt.

Deling of restbepaling met het gehele getal nul werpt tijdens de uitvoering een ArithmeticException op. Zwevendekommagetallen gedragen zich bij deling anders: 5.0 / 0 geeft Infinity, -5.0 / 0 geeft -Infinity en 0.0 / 0 geeft NaN, wat “geen getal” betekent. Een resultaat kan dus onbruikbaar zijn, ook wanneer de uitvoering niet stopt.

Rekenen met kommagetallen is nuttig voor metingen en gemiddelden. De klasse Math voegt kant-en-klare berekeningen toe, terwijl je met afronden kunt kiezen hoe je een resultaat opslaat of presenteert.

Behoud breukdelen en herken benaderingen

150 / 2.5 geeft 60.0, een snelheid in km/h als de afstand 150 km is en de tijd 2,5 uur. Omdat een operand een double is, behoudt de deling zo nodig een breukdeel in het resultaat. Gewone doubles met een gehele waarde worden met een decimaal deel weergegeven, zoals 60.0.

Een double slaat van veel decimale waarden een binaire benadering op. Daardoor geeft 1.1 * 3 de uitvoer 3.3000000000000003 en 10.0 / 3 de uitvoer 3.3333333333333335. Behoud de waarde voor latere berekeningen en rond die af bij de presentatie.

Grote of kleine waarden kunnen in wetenschappelijke notatie worden weergegeven. 1.23456789E7 stelt 12.345.678,9 voor en 1.0E-4 stelt 0,0001 voor. Voor positieve eindige waarden wordt gewone notatie gebruikt vanaf 0,001 tot maar niet met 10.000.000. Wetenschappelijke notatie verandert de weergegeven vorm, niet de onderliggende waarde.

Roep nuttige Math-methoden aan

Math staat in java.lang, dus er is geen import nodig.

Math.sqrt en Math.pow geven double terug. De constante Math.PI is ongeveer 3,141592653589793. Voor een cirkel met straal 2,5 cm geeft Math.PI * 2.5 * 2.5 de waarde 19.634954084936208 cm², ongeveer 19,63 cm². Voor een rechthoekige driehoek met rechthoekszijden van 3 cm en 4 cm telt Math.sqrt(3 * 3 + 4 * 4) eerst de gekwadrateerde rechthoekszijden op tot 25 en geeft daarna 5.0 cm.

Kies een afrondingsrichting

round kiest het dichtstbijzijnde gehele getal, waarbij waarden precies halverwege richting positieve oneindigheid gaan. floor gaat naar beneden, richting negatieve oneindigheid; ceil gaat naar boven, richting positieve oneindigheid. Bij negatieve getallen betekent “naar beneden” een negatievere waarde, dus naar beneden afronden van −2,7 geeft −3,0.

Voor een double-argument geeft Math.round een long terug. Sla dat resultaat op in een long of zet het expliciet om wanneer een int passend is: int rounded = (int) Math.round(2.7); slaat 3 op. floor en ceil geven double-waarden terug.

Om een opgeslagen waarde op twee decimalen af te ronden, gebruik je Math.round(12.3456 * 100) / 100.0, wat 12.35 geeft. Door eerst te vergroten, komt de positie van de honderdsten op de grens van de gehele getallen te liggen. Delen door 100.0 verkleint de waarde weer met een zwevendekomma-deling; delen door het gehele getal 100 zou het breukdeel weglaten en 12 geven. Als alleen de weergegeven tekst moet worden afgerond, kan printf de oorspronkelijke waarde direct opmaken.

Java zet een numerieke waarde soms automatisch om. Andere conversies hebben een expliciete cast nodig. Een cast verandert het type van een waarde op een bepaalde plek in een expressie, dus de plaats beïnvloedt het antwoord.

Verbreed automatisch

De belangrijkste route voor numerieke verbreding is byte → short → int → long → float → double. Een char wordt ook verbreed naar int en verder. Zo slaat double d = 5; de waarde 5.0 op en past elke int-waarde exact in een long.

Verbreding naar een zwevendekommatype kan precisie verliezen. Bij int naar float, long naar float en long naar double kan een groot geheel getal worden afgerond. De conversie van int naar double is exact. Zo wordt (float) 16777217 de waarde 1.6777216E7, die 16.777.216 voorstelt.

Gebruik een cast voor een versmallende conversie

Bij een cast schrijf je het doeltype tussen haakjes vóór de waarde:

int n = (int) 3.99;

Het opgeslagen resultaat is 3. Zonder (int) wijst Java de toewijzing van de double-literal aan een int af. De conversie van een eindige double binnen het bereik naar een geheel getal kapt af richting nul: (int) -3.99 geeft eveneens −3. Afkappen verschilt van afronden; (int) Math.round(3.99) geeft 4.

Versmallende conversies hebben meestal een cast nodig. Een nuttige uitzondering staat toe dat een constante expressie met een geheel getal dat past, een byte, short of char initialiseert. Zo is byte b = 100; geldig zonder (byte). Voor een niet-constante int-variabele geldt deze uitzondering voor constante toewijzingen niet alleen omdat de huidige waarde past.

Zet de cast vóór de bewerking waarvoor die nodig is

Neem int sum = 25; en int count = 3;.

Een cast heeft een hogere prioriteit dan vermenigvuldigen en delen. Haakjes bepalen of de cast geldt voor één operand of een voltooide berekening. Een cast na geheeltallige deling kan weggelaten informatie niet herstellen.

Voorspel veranderingen in tekens en kleine gehele getallen

(int) 'A' geeft de tekencode 65. Als je 1 bij 'A' optelt, krijg je de int 66. Om het volledige resultaat weer om te zetten naar een teken, schrijf je (char) ('A' + 1), wat 'B' geeft. Zonder de buitenste haakjes rond de som zou de cast alleen voor 'A' gelden.

Een versmallende conversie tussen gehele typen behoudt alleen de laagste bits. (byte) 200 wordt −56; (int) 3_000_000_000L wordt −1294967296. Een cast staat de conversie toe, maar controleert niet of de oorspronkelijke waarde past.

Samengestelde toewijzing heeft een ingebouwde conversie naar het type links. Met int x = 10; berekent x += 2.7; de waarde 12,7 en versmalt die naar 12. De gewone toewijzing x = x + 2.7; mislukt omdat de rechterkant double is.

Tekst kan cijfers bevatten zonder een getal te zijn. Om met getypte of opgeslagen tekst te rekenen, parseer je die naar een numeriek type. Om een bericht op te bouwen, zet je een numerieke waarde weer om naar tekst.

Parseer tekst voordat je rekent

De expressie "42" + 1 levert “421” op. Omdat de linkeroperand een String is, voert + concatenatie uit. Integer.parseInt("42") + 1 levert 43 op, omdat parsen vóór de optelling een int oplevert.

String first = "12";
String second = "30";
int total = Integer.parseInt(first) + Integer.parseInt(second);

Hier bevat total de waarde 42. Samenvoegen van de oorspronkelijke strings zou “1230” geven. Kies de conversie op basis van het beoogde gebruik van de waarde, niet op basis van de vraag of de tekens toevallig op een getal lijken.

Integer.parseInt(text) geeft een int terug; Long.parseLong(text) geeft een long terug. Integer.valueOf("42") geeft een Integer-object terug, dat Java automatisch omzet naar int wanneer een int nodig is. Voor een directe omzetting van tekst naar int maakt parseInt het bedoelde resultaat duidelijk.

Parseer kommagetallen en waarheidswaarden

Double.parseDouble("3.75") geeft de double 3,75 terug. De tekstnotatie gebruikt op elke computer een decimale punt, ongeacht de regio-instellingen. Double.parseDouble("3,5") mislukt. Ook Java-broncode gebruikt bij literals een punt, al kunnen methoden voor toetsenbordinvoer een taal- en regio-instelling volgen.

Boolean.parseBoolean(text) volgt een andere regel: de methode geeft true terug voor “true” in elke combinatie van hoofdletters en kleine letters, zoals “TRUE”. Alle andere tekst geeft false terug, waaronder “yes”. Een algemeen bevestigend woord wordt niet als waar geïnterpreteerd.

Herken ongeldige numerieke tekst

Ongeldige numerieke tekst veroorzaakt een NumberFormatException terwijl het programma draait. Integer.parseInt("4.5") mislukt omdat decimale tekst geen schrijfwijze van een geheel getal is. Integer.parseInt("") en Integer.parseInt(" 42") mislukken ook. De exceptiemelding geeft aan welke tekst niet kon worden omgezet.

Hoe witruimte wordt behandeld, hangt af van de parser. Double.parseDouble negeert spaties aan het begin en einde, terwijl Integer.parseInt dat niet doet. Kies bij het lezen van gebruikersgegevens testinvoer die deze verschillen zichtbaar maakt.

Een handig invoerpatroon is om één hele regel te lezen en te parsen:

int age = Integer.parseInt(scanner.nextLine());
double height = Double.parseDouble(scanner.nextLine());

Elke aanroep verwerkt de hele regel, inclusief het regeleinde. Daardoor blijven tekstuele en numerieke invoer consistent en voorkom je dat je het lezen van tokens en het lezen van hele regels door elkaar gebruikt.

Zet een getal om naar tekst

String.valueOf(42), Integer.toString(42) en "" + 42 leveren allemaal de String “42” op. Double.toString(2.50) levert “2.5” op. De oorspronkelijke decimale schrijfwijze blijft niet aan het opgeslagen getal verbonden, dus deze conversie voegt geen nul aan het einde toe om die schrijfwijze te behouden.

Gebruik String.format wanneer je opgeslagen tekst met een vast aantal decimalen nodig hebt. Gebruik printf wanneer je die opgemaakte tekst direct wilt weergeven. Een numerieke cast en eenvoudige concatenatie zorgen geen van beide voor een weergave met een vast aantal van twee decimalen.

Toetsenbordinvoer komt binnen als tekst. Een Scanner kan een hele regel of één woord lezen, of een woord lezen en omzetten naar een getal. Kies een consistent leesplan voordat je de gebruiker om waarden vraagt.

Maak één Scanner en lees een regel

import java.util.Scanner;

public class Greeting {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("What is your name? ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

De import komt vóór de klasse. De instructie die de Scanner maakt, komt binnen main en verbindt de Scanner met System.in. Eén Scanner is genoeg voor dit programma. nextLine() wacht op de getypte regel en geeft de tekst zonder het regeleinde terug. Als je “Ada” typt, geeft de laatste instructie “Hello, Ada!” weer. Door print voor de invoervraag te gebruiken, blijft de invoer naast de vraag staan.

Kies regels of tokens

Bij “Ada Lovelace” geeft next() “Ada” terug. Een daaropvolgende nextLine() geeft “ Lovelace” terug, inclusief de spatie vooraan. Twee aanroepen van nextInt() kunnen “3 4” van één regel lezen. Een numeriek token dat niet bij de methode past, zoals “4.5” of “abc” voor nextInt(), veroorzaakt een InputMismatchException.

Houd rekening met het ongelezen regeleinde

Stel dat de gebruiker “30” typt, op Enter drukt, daarna “Ada Lovelace” typt en op Enter drukt. Deze code leest de naam niet zoals bedoeld:

int age = scanner.nextInt();
String name = scanner.nextLine();

nextInt() verwerkt 30 maar laat het regeleinde staan. nextLine() verwerkt direct de lege rest van diezelfde regel, dus name is "". Voeg scanner.nextLine(); toe tussen de twee instructies om die rest weg te lezen voordat je de naam op de volgende regel leest.

Een andere oplossing is om elk antwoord met nextLine() te lezen en numerieke regels te parsen: int age = Integer.parseInt(scanner.nextLine());. Zo voorkom je dat je wisselt tussen twee verschillende invoereenheden.

Maak de decimaalnotatie duidelijk

nextDouble() volgt de taal- en regio-instelling van de Scanner, aanvankelijk de standaardopmaakinstelling van de computer. Een instelling met een decimale komma accepteert in dit voorbeeld “3,5” als kommagetal en wijst “3.5” af. Om kommagetallen met een punt consequent te lezen, voeg je import java.util.Locale; toe en maak je:

Scanner scanner = new Scanner(System.in).useLocale(Locale.US);

Een hele regel lezen met Double.parseDouble(scanner.nextLine()) gebruikt ook een punt. Als je de taal- en regio-instelling van de Scanner verandert, veranderen Java-literals in broncode en de instelling voor latere aanroepen van printf niet.

Lees waarden in de volgorde waarin de invoervragen erom vragen. Als je om een naam en daarna om een leeftijd vraagt, moet de eerste leesactie de naam opslaan. Een leesactie op de verkeerde plek kan gegevens in de verkeerde variabele plaatsen of een conversiefout veroorzaken.

Opgemaakte uitvoer bepaalt hoe waarden binnen een bericht verschijnen. Met printf kun je een vast aantal decimalen tonen, een regeleinde toevoegen en waarden in kolommen uitlijnen zonder hun opgeslagen waarden te veranderen.

Koppel tijdelijke aanduidingen aan waarden

Een opmaakstring bevat gewone tekst plus specificaties die met % beginnen. Elke specificatie die een waarde verwerkt, neemt de volgende waarde die na de opmaakstring wordt opgegeven:

System.out.printf("%s is %d years old%n", "Ada", 36);

Dit geeft “Ada is 36 years old” weer en begint een nieuwe regel. %s toont tekst of een andere waarde als tekst, %d toont een geheel getal zoals een int of long en %f toont een zwevendekommawaarde. %n voegt een regeleinde in zonder een waarde te verwerken. %% geeft één procentteken weer.

printf voegt niet automatisch een regeleinde toe. Neem %n op wanneer de volgende uitvoer op een nieuwe regel moet beginnen. Een gewone escapesequentie \n stelt ook een nieuweregelteken in Java-tekst voor; %n is het platformspecifieke regelscheidingsteken van de opmaakfunctie.

Stel decimalen voor de weergave in

%f zonder precisie geeft zes plaatsen na het decimaalteken weer: het opmaken van 2.5 geeft “2.500000”. De precisie in %.2f vraagt om twee decimalen:

System.out.printf("Total: %.2f%n", 12.3456);

Met Amerikaanse opmaak is de uitvoer “Total: 12.35”. De waarde wordt afgerond in de weergegeven tekst. Een variabele die 12,3456 bevat, bevat na de weergave nog steeds die waarde voor verdere berekeningen.

Bij System.out.printf("%d items at %.2f each, total %.2f%n", 3, 1.5, 3 * 1.5); vullen de waarden de drie tijdelijke aanduidingen in volgorde in. Met Amerikaanse instellingen is de uitvoer “3 items at 1.50 each, total 4.50”.

Lijn velden uit met breedte

Een breedte is een minimale veldgrootte. %5d lijnt een geheel getal rechts uit binnen minstens vijf tekens; %-6s lijnt tekst links uit binnen minstens zes tekens. %6.1f combineert breedte 6 met één decimaal.

System.out.printf("[%5d][%-6s][%6.1f]%n", 42, "Ada", 9.25);

Met Amerikaanse instellingen is de exacte uitvoer [ 42][Ada ][ 9.3]. De vierkante haken maken de opvulling zichtbaar. Een waarde die langer is dan de breedte wordt nog steeds volledig weergegeven; de breedte kapt geen tekens af.

Een specificatie die niet past, veroorzaakt een uitvoeringsfout. printf("%d%n", 2.5) compileert maar werpt IllegalFormatConversionException op, omdat %d een geheel getal verwacht. Te weinig opgegeven waarden, zoals in printf("%d %d%n", 2), veroorzaken MissingFormatArgumentException.

Kies uitvoer of opgeslagen tekst

String.format past dezelfde opmaakregels toe, maar geeft een String terug:

String line = String.format("%.1f km", 12.345);

Met Amerikaanse instellingen bevat line de tekst “12.3 km”; die instructie heeft niets weergegeven.

Beide opmaakmethoden gebruiken de standaardinstelling voor taal en regio, tenzij je er een meegeeft. Voeg import java.util.Locale; toe en gebruik dan System.out.printf(Locale.US, "%.2f%n", 12.3456); om “12.35” te krijgen in plaats van de “12,35” die een instelling met een decimale komma gebruikt. Ook String.format kan Locale.US als eerste argument krijgen. Een double weergeven met println gebruikt een punt, ongeacht de taal- en regio-instelling voor de opmaak.

Een compleet rekenprogramma verbindt drie stappen: lees de invoer, reken ermee en geef de resultaten weer. Als je de waarden en hun eenheden plant voordat je begint te typen, helpt dat bij het kiezen van typen en het testen van het resultaat.

Plan een reistijdprogramma

De invoer bestaat uit afstand in kilometers en gemiddelde snelheid in km/h. Als je de afstand deelt door de snelheid, krijg je de tijd in uren. Beide metingen hebben double nodig, zodat de deling een breukdeel kan behouden. De uitvoer bestaat uit hele uren en minuten, afgerond op de dichtstbijzijnde minuut.

import java.util.Scanner;

public class TravelTime {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Distance (km): ");
        double distance = Double.parseDouble(scanner.nextLine());
        System.out.print("Speed (km/h): ");
        double speed = Double.parseDouble(scanner.nextLine());
        int totalMinutes = (int) Math.round(distance / speed * 60);
        int hours = totalMinutes / 60;
        int minutes = totalMinutes % 60;
        System.out.println("Travel time: " + hours + " h " + minutes + " min");
    }
}

Bij 150 km met 80 km/h geeft de deling 1,875 uur. Vermenigvuldiging met 60 geeft 112,5 minuten. Math.round geeft de long 113 terug en de cast zet die om naar int. Geheeltallige deling en rest geven daarna 1 uur en 53 minuten. De uitvoer is “Travel time: 1 h 53 min”.

Als afstand en snelheid allebei int waren, zou 150 / 80 * 60 de waarde 60 opleveren. Het breukdeel verdwijnt bij de deling, vóór de vermenigvuldiging. Typekeuzes horen thuis in het plan, niet alleen in de laatste instructie voor uitvoer.

Kies weergave en berekening afzonderlijk

Voor een rekening van in totaal 87,60, verdeeld over 4 personen, sla je het totaal op in double en het aantal in int. double share = total / people; geeft 21,9. Met Amerikaanse opmaak geeft System.out.printf("Each person pays %.2f%n", share); de uitvoer “Each person pays 21.90”. De opmaak levert de tweede decimaal zonder de berekening te veranderen.

Voor de scores als gehele getallen 7, 8 en 10 geeft double average = (a + b + c) / 3.0; de waarde 8.333333333333334, die met %.2f als “8.33” wordt weergegeven. De haakjes groeperen het totaal en de deler met een decimaal behoudt het breukdeel.

Test met resultaten die je kent

Bereken verwachte resultaten voordat je het programma uitvoert. Voor reistijd zou 120 km met 60 km/h de uitvoer 2 h 0 min moeten geven. Een afstand van 0 km bij een positieve snelheid zou 0 h 0 min moeten geven. Probeer invoer dicht bij een afrondingsgrens en grotere geldige afstanden om meer dan alleen de eenvoudigste berekening te testen.

Neem nul, negatieve en grote invoer op wanneer je het gedrag van het programma controleert. Bepaal of elke invoer voor de taak zinvol is. Bij een aantal van nul personen levert total / people de waarde Infinity op wanneer total een double ongelijk aan nul is; geheeltallige deling door nul werpt ArithmeticException op. Een geslaagde uitvoering alleen bewijst niet dat het antwoord bruikbaar is.

Als de uitvoer afwijkt van je verwachting, geef dan tussenwaarden weer of volg die in een tabel. Zoek de eerste verkeerde waarde, herstel de verantwoordelijke instructie en voer de bekende tests opnieuw uit. Vergelijk naast getallen ook spaties en labels.

Gebruik namen zoals totalMinutes, benoemde constanten zoals MINUTES_PER_HOUR, eenheden in invoervragen en kort commentaar dat het doel van een berekening uitlegt.