Java-operators

In deze tutorial leer je over de verschillende typen operators in Java, hun syntax en hoe je ze gebruikt met behulp van voorbeelden.

Operators zijn symbolen die operaties uitvoeren op variabelen en waarden. Bijvoorbeeld, + is een operator voor optelling, terwijl * een operator is voor vermenigvuldiging.

Operators in Java kunnen ingedeeld worden in 6 typen:

1. Arithmetic Operators
2. Assignment Operators
3. Relational Operators
4. Logical Operators
5. Unary Operators
6. Bitwise Operators

---

1. Java Arithmetic Operators

Arithmetic operators worden gebruikt om rekenkundige operaties uit te voeren op variabelen en data. Bijvoorbeeld,

a + b;

Hier wordt de +-operator gebruikt om twee variabelen a en b op te tellen. Er zijn verschillende andere arithmetic operators in Java.

Operator	Operatie
+	Optelling
-	Aftrekking
*	Vermenigvuldiging
/	Deling
%	Modulo-operatie (rest na deling)

Voorbeeld 1: Arithmetic Operators

class Main {
    public static void main(String[] args) {
        // declareer variabelen
        int a = 12, b = 5;
        // optelling operator
        System.out.println("a + b = " + (a + b));
        // aftrekking operator
        System.out.println("a - b = " + (a - b));
        // vermenigvuldiging operator
        System.out.println("a * b = " + (a * b));
        // deling operator
        System.out.println("a / b = " + (a / b));
        // modulo operator
        System.out.println("a % b = " + (a % b));
    }
}

Output

a + b = 17
a - b = 7
a * b = 60
a / b = 2
a % b = 2

In het bovenstaande voorbeeld hebben we +, - en * operators gebruikt voor optelling, aftrekking en vermenigvuldiging.

/ Delingsoperator

Let op de operatie a / b in ons programma. De /-operator is de delingsoperator.

Als we de delingsoperator met twee integers gebruiken, dan is de resulterende quotiënt ook een integer. En als een van de operanden een floating-point getal is, zal het resultaat ook in floating-point zijn.

In Java, (9 / 2) is 4
(9.0 / 2) is 4.5
(9 / 2.0) is 4.5
(9.0 / 2.0) is 4.5

% Modulo-operator

De modulo-operator % berekent de rest. Wanneer a = 7 gedeeld wordt door b = 4, is de rest 3.

Let op: De %-operator wordt voornamelijk gebruikt met integers.

---

2. Java Assignment Operators

Assignment operators worden in Java gebruikt om waarden toe te kennen aan variabelen. Bijvoorbeeld,

int age;
age = 5;

Hier is = de assignment-operator. Het kent de waarde aan zijn rechterkant toe aan de variabele aan zijn linkerkant. Dat is, 5 wordt toegewezen aan de variabele age.

Laten we nog meer assignment operators in Java bekijken.

Operator	Voorbeeld	Equivalent aan
=	a = b;	a = b;
+=	a += b;	a = a + b;
-=	a -= b;	a = a - b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

Voorbeeld 2: Assignment Operators

class Main {
    public static void main(String[] args) {
        // variabelen aanmaken
        int a = 4;
        int var;
        // waarde toekennen met =
        var = a;
        System.out.println("var met =: " + var);
        // waarde toekennen met +=
        var += a;
        System.out.println("var met +=: " + var);
        // waarde toekennen met *=
        var *= a;
        System.out.println("var met *=: " + var);
    }
}

Output

var met =: 4
var met +=: 8
var met *=: 32

---

3. Java Relational Operators

Relational operators worden gebruikt om de relatie tussen twee operanden te controleren. Bijvoorbeeld,

// controleren of a kleiner is dan b
a < b;

Hier is < de relationele operator. Het controleert of a kleiner is dan b of niet.

Het retourneert ofwel true ofwel false.

Operator	Beschrijving	Voorbeeld
==	Is Gelijk Aan	3 == 5 retourneert false
!=	Niet Gelijk Aan	3 != 5 retourneert true
>	Groter Dan	3 > 5 retourneert false
<	Kleiner Dan	3 < 5 retourneert true
>=	Groter Dan of Gelijk Aan	3 >= 5 retourneert false
<=	Kleiner Dan of Gelijk Aan	3 <= 5 retourneert true

Voorbeeld 3: Relational Operators

class Main {
    public static void main(String[] args) {
        // variabelen aanmaken
        int a = 7, b = 11;
        // waarde van a en b
        System.out.println("a is " + a + " en b is " + b);
        // == operator
        System.out.println(a == b); // false
        // != operator
        System.out.println(a != b); // true
        // > operator
        System.out.println(a > b); // false
        // < operator
        System.out.println(a < b); // true
        // >= operator
        System.out.println(a >= b); // false
        // <= operator
        System.out.println(a <= b); // true
    }
}

Let op: Relational operators worden gebruikt in besluitvorming en lussen.

---

4. Java Logical Operators

Logical operators worden gebruikt om te controleren of een expressie true of false is. Ze worden gebruikt in besluitvorming.

Operator	Voorbeeld	Betekenis
&& (Logical AND)	expression1 && expression2	true alleen als zowel expression1 als expression2 true zijn
|| (Logical OR)	expression1 || expression2	true als ofwel expression1 ofwel expression2 true is
! (Logical NOT)	!expression	true als expression false is en vice versa

Voorbeeld 4: Logical Operators

class Main {
    public static void main(String[] args) {
        // && operator
        System.out.println((5 > 3) && (8 > 5)); // true
        System.out.println((5 > 3) && (8 < 5)); // false
        // || operator
        System.out.println((5 < 3) || (8 > 5)); // true
        System.out.println((5 > 3) || (8 < 5)); // true
        System.out.println((5 < 3) || (8 < 5)); // false
        // ! operator
        System.out.println(!(5 == 3)); // true
        System.out.println(!(5 > 3)); // false
    }
}

Werking van het programma

• (5 > 3) && (8 > 5) retourneert true omdat zowel (5 > 3) als (8 > 5) true zijn.
• (5 > 3) && (8 < 5) retourneert false omdat de expressie (8 < 5) false is.
• (5 < 3) || (8 > 5) retourneert true omdat de expressie (8 > 5) true is.
• (5 > 3) && (8 > 5) retourneert true omdat de expressie (5 > 3) true is.
• (5 > 3) && (8 > 5) retourneert false omdat zowel (5 < 3) als (8 < 5) false zijn.
• !(5 == 3) retourneert true omdat 5 == 3 false is.
• !(5 > 3) retourneert false omdat 5 > 3 true is.

---

5. Java Unary Operators

Unary operators worden gebruikt met slechts één operand. Bijvoorbeeld, ++ is een unary operator die de waarde van een variabele met 1 verhoogt. Dat is, ++5 zal 6 retourneren.

Verschillende typen unary operators zijn:

Operator	Betekenis
+	Unary plus: niet nodig om te gebruiken omdat getallen positief zijn zonder het
-	Unary minus: keert het teken van een expressie om
++	Increment-operator: verhoogt waarde met 1
--	Decrement-operator: verlaagt waarde met 1
!	Logical complement operator: keert de waarde van een boolean om

Increment en Decrement Operators

Java biedt ook increment- en decrement-operators: ++ en -- respectievelijk. ++ verhoogt de waarde van de operand met 1, terwijl -- deze met 1 verlaagt. Bijvoorbeeld,

int num = 5;
// verhoog num met 1
++num;

Hier wordt de waarde van num verhoogd naar 6 vanaf de initiële waarde van 5.

---

Voorbeeld 5: Increment en Decrement Operators

class Main {
    public static void main(String[] args) {
        // declareer variabelen
        int a = 12, b = 12;
        int result1, result2;
        // oorspronkelijke waarde
        System.out.println("Waarde van a: " + a);
        // increment operator
        result1 = ++a;
        System.out.println("Na increment: " + result1);
        System.out.println("Waarde van b: " + b);
        // decrement operator
        result2 = --b;
        System.out.println("Na decrement: " + result2);
    }
}

Output

Waarde van a: 12
Na increment: 13
Waarde van b: 12
Na decrement: 11

In het bovenstaande programma hebben we de ++ en -- operator gebruikt als prefixes (++a, --b). We kunnen deze operators ook als postfix (a++, b++) gebruiken.

Er is een klein verschil wanneer deze operators als prefix worden gebruikt versus wanneer ze als postfix worden gebruikt.

Lees meer over deze operators: increment en decrement operators.

---

6. Java Bitwise Operators

Bitwise operators in Java worden gebruikt om operaties uit te voeren op individuele bits. Bijvoorbeeld,

Bitwise complement Operatie van 35
35 = 00100011 (In Binair)
~ 00100011
________
11011100 = 220 (In decimaal)

Hier is ~ een bitwise operator. Het keert de waarde van elke bit om (0 naar 1 en 1 naar 0).

De diverse bitwise operators in Java zijn:

Operator	Beschrijving
~	Bitwise Complement
<<	Left Shift
>>	Right Shift
>>>	Unsigned Right Shift
&	Bitwise AND
^	Bitwise exclusive OR

Deze operators worden doorgaans niet veel in Java gebruikt. Lees meer: Java Bitwise en Bit Shift Operators.

---

Overige operators

Naast deze operators zijn er nog andere additionele operators in Java.

Java instanceof-operator

De instanceof-operator controleert of een object een instance is van een bepaalde klasse. Bijvoorbeeld,

class Main {
    public static void main(String[] args) {
        String str = "Programiz";
        boolean result;
        // controleert of str een instance is van
        // de String-klasse
        result = str instanceof String;
        System.out.println("Is str een object van String? " + result);
    }
}

Output

Is str een object van String? true

Hier is str een instance van de String-klasse. Daarom retourneert de instanceof-operator true. Lees meer: Java instanceof.

---

Java Ternary Operator

De ternary operator (conditionele operator) is een verkorte vorm van de if-then-else-statement. Bijvoorbeeld,

variable = Expression ? expression1 : expression2

Hier is hoe het werkt.

• Als de Expression true is, wordt expression1 toegewezen aan de variable.
• Als de Expression false is, wordt expression2 toegewezen aan de variable.

Laten we een voorbeeld van een ternary operator zien.

class Java {
    public static void main(String[] args) {
        int februaryDays = 29;
        String result;
        // ternary operator
        result = (februaryDays == 28) ? "Geen schrikkeljaar" : "Schrikkeljaar";
        System.out.println(result);
    }
}

Output

Schrikkeljaar

In het bovenstaande voorbeeld hebben we de ternary operator gebruikt om te controleren of het jaar een schrikkeljaar is of niet. Lees meer: Java ternary operator.

---

Nu je weet wat Java-operators zijn, is het tijd om te leren over de volgorde waarin operators geëvalueerd worden. Lees meer: Java Operator Precedence.