Java kent een heel aantal operatoren die je in staat stellen wiskundige bewerkingen en logische vergelijkingen uit te voeren.
In deze cursus bespreken we de voornaamste operatoren aan de hand van de voorbeeldtoepassingen die we zullen maken, een volledige lijst vind je op de site van Sun
De klasse Math
Voor het uitvoeren van complexe wiskundige bewerkingen is in Java de klasse Math standaard ter beschikking.
Een volledig overzicht van deze klasse vind je op de site van Sun
Een voorbeeld illustreert het gebruik van deze klasse:
import java.applet.Applet;
import java.awt.*;
public class klassemath extends java.applet.Applet {
public void paint(Graphics g) {
int straal = 7;
double omtrek = 2 * Math.PI * straal;
double oppervlakte = Math.PI * Math.pow(straal,2);
g.drawString("Omtrek: " +omtrek ,20,20);
g.drawString("Oppervlakte: " +oppervlakte ,20,35);
}
}
Het pakket Math
Naast de klasse Math bestaat er ook een pakket met de naam Math.
Dit pakket bevat de interessante klasse BigDecimal, met deze klasse kan je kommagetallen afronden met de de methode setScale. Deze methode ontvangt twee argumenten : het aantal decimalen en de afrondingsmode. Deze afrondingsmode is een integerwaarde die als constante in de klasse BigDecimal is gedefiniëerd.
BigDecimal.ROUND_HALF_UP betekent: afronden naar boven bij 5 of meer, anders naar beneden -zoals we in het gewone leven doen- .
import java.applet.Applet;
import java.awt.*;
import java.math.*;
public class klassemath2 extends java.applet.Applet {
public void paint(Graphics g) {
int straal = 7;
double omtrek = 2 * Math.PI * straal;
double oppervlakte = Math.PI * Math.pow(straal,2);
BigDecimal bd = new BigDecimal(oppervlakte);
g.drawString("Omtrek: " +omtrek ,20,20);
g.drawString("Oppervlakte: " +oppervlakte ,20,35);
g.drawString("Oppervlakte: " +bd.setScale(0,BigDecimal.ROUND_HALF_UP) ,20,50);
g.drawString("Oppervlakte: " +bd.setScale(3,BigDecimal.ROUND_HALF_UP) ,20,65);
}
}
Voor de voorwaardelijke uitvoering van instructies kan je gebruik maken van de if...else... constructie.
import java.applet.Applet;
import java.awt.*;
public class condif extends java.applet.Applet {
public void paint(Graphics g) {
double waarde = -10.89;
if(waarde < 0) g.drawString("Waarde is negatief",20,20);
if(waarde < -8){
g.drawString("Waarde is kleiner dan -8",20,35);
g.drawString("Absolute waarde: " +Math.abs(waarde),20,50);
}
if(waarde > 0){
g.drawString("Waarde is positief",20,65);
} else {
g.drawString("Waarde is negatief",20,65);
}
if(waarde > 0){
g.drawString("Waarde is positief",20,80);
} else if (waarde > -5) {
g.drawString("Waarde is groter dan -5",20,80);
} else if (waarde > -10){
g.drawString("Waarde is groter dan -10",20,80);
} else if (waarde > -15){
g.drawString("Waarde is groter dan -15",20,80);
} else if (waarde > -20){
g.drawString("Waarde is groter dan -20",20,80);
}
}
}
Je kan if-structuren ook nesten.
Zijn er veel verschillende mogelijkheden, dan kan je in plaats van lange if...else...-ladders gebruik maken van de switch-instructie.
import java.applet.Applet;
import java.awt.*;
public class switch1 extends java.applet.Applet {
public void paint(Graphics g) {
int dag = 3;
switch(dag){
case 0:
g.drawString("Het is zondag",20,20);
break;
case 1:
g.drawString("Het is maandag",20,20);
break;
case 2:
g.drawString("Het is dinsdag",20,20);
break;
case 3:
g.drawString("Het is woensdag",20,20);
break;
case 4:
g.drawString("Het is donderdag",20,20);
break;
case 5:
g.drawString("Het is vrijdag",20,20);
break;
default:
g.drawString("Het zal wel zaterdag zijn",20,20);
}
}
}
Vaak komt het voor dat opdrachten herhaald moeten worden. In plaats van dezefde opdracht vele keren te tikken kan je gebruik maken van lusstructuren.
Het gebruik van deze lusstructuren is vrij te bepalen door de programmeur, je kan veelal zonder grote problemen dezelfde code herschrijven met een ander lustype.
Deze lusstructuren kunnen ook genest worden.
while-lus
Een while-lus herhaalt opdrachten zolang de voorwaarde na het woord while waar is. De voorwaarde wordt geëvalueerd voordat de opdrachten worden uitgevoerd.
import java.applet.Applet;
import java.awt.*;
public class while1 extends java.applet.Applet {
public void paint(Graphics g) {
int teller = 1;
int ypositie =20;
while(teller<5){
g.drawString("Waarde van de teller: " +teller++,20,ypositie);
ypositie += 15;
}
}
}
do-while
Met een do-while lus wordt de voorwaarde om te lussen pas gecontroleerd nadat de lus werd doorlopen. Dit betekent dat bij een do...while-lus de opdrachten binnen de lus minstens 1 keer worden uitgevoerd.
import java.applet.Applet;
import java.awt.*;
public class dowhile extends java.applet.Applet {
public void paint(Graphics g) {
int teller = 1;
int ypositie =20;
do{
g.drawString("Waarde van de teller: " +teller++,20,ypositie);
ypositie += 15;
} while(teller<5);
}
}
for-lus
Bij een for-lus geef je drie argumenten op:
- initialisatie expressie: opdracht die uitgevoerd wordt voor de eerste lusdoorgang
- voorwaarde om verder te lussen
- iteratie expressie: opdracht die uitgevoerd wordt na elke lusdoorgang
import java.applet.Applet;
import java.awt.*;
public class forlus extends java.applet.Applet {
public void paint(Graphics g) {
int teller;
int ypositie =20;
for(teller=1;teller<5;teller++){
g.drawString("Waarde van de teller: " +teller,20,ypositie);
ypositie += 15;
}
}
}
Break en continue
Om lussen te onderbreken kan je gebruik maken van de instructies break en continue.
Break beëindigt de lus definitief.
Continue zorgt ervoor dat de verdere opdrachten van de huidige lusdoorgang niet meer worden uitgevoerd, maar indien de lusvoorwaarde nog is voldaan wordt de lus wel hernomen.
import java.applet.Applet;
import java.awt.*;
public class breakcontinue extends java.applet.Applet {
public void paint(Graphics g) {
int teller;
int ypositie =20;
for(teller=1;teller<10;teller++){
if(teller==3) break;
g.drawString("Waarde van de teller: " +teller,20,ypositie);
ypositie += 15;
}
ypositie += 20;
for(teller=1;teller<10;teller++){
if(teller==3) continue;
g.drawString("Waarde van de teller: " +teller,20,ypositie);
ypositie += 15;
}
}
}
Je kan via een console-applicatie input vragen aan de gebruiker.
Dit stukje leerstof zal je nodig hebben voor de oefeningen voor dit hoofdstuk.
Hier zie je ook hoe je uitzonderingen kan opvangen met een try{} catch(){} - blok.
De risicoinstructie zet je in en try{}-blok.
Uitzonderingen vang je op in een catch(uitzondering varnaam){}-blok. Je kan er instructies geven wat moet gebeuren wanneer een bepaalde uitzondering optreedt.
Hier vangen we bij het inlezen van een gehele waarde de NumberFormatException op: er zal een fout optreden wanneer de gebruiker een tekstwaarde of kommagetal intikt die je wenst in een variabele van het type int te stoppen. Als je geen foutafhandeling doet 'crasht' je programma!
De methode getMessage brengt de systeem-foutmelding op het scherm (niet verplicht).
import java.io.*;
public class ConsoleIO {
public static void main(String[] args) throws IOException {
String naam; // Declaratie variabele om de naam en rangwaarde te ontvangen.
int rangwaarde;
BufferedReader bufReader; // Declareer BufferReader-variabele
bufReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Wat is je naam, aarling?");
naam = bufReader.readLine(); // Lees 1 lijn van de console
System.out.println("Wat is je rangwaarde?");
try{rangwaarde = Integer.parseInt(bufReader.readLine());}
catch(NumberFormatException nfe){
System.out.println("Fout! Geef een integer waarde in" +nfe.getMessage());
rangwaarde = -1;
}
System.out.println("Breng me bij je leider, " + naam +"(" +rangwaarde +")");
System.exit(0); // Niet noodzakelijk, maar veelgebruikt: einde toepassing
}
}
Om gegevens in te lezen kan je vanaf J2SE 5.0 werken met de klasse Scanner:
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Leest een integer waarde van de console.
