# Hoe gebruik je de OR-operator en de AND-operator in Java?

De Java-operatoren AND en OR worden gebruikt om de juistheid van voorwaarden in Java te controleren. De twee operatoren werken op vrijwel dezelfde manier, maar verschillen in de details. In dit artikel leggen we alles uit wat u moet weten over AND en OR in Java.

## Wat zijn de AND- en OR-operatoren van Java?

Java-operatoren zijn belangrijke hulpmiddelen voor het werken met de programmeertaal. Er zijn verschillende soorten operatoren voor verschillende doeleinden. AND en OR in Java zijn logische operatoren die worden gebruikt om de **juistheid van een toestand** te controleren. Ze retourneren de\*\*Booleaanse waarden\* ‘true’ of ‘false’. Ze zijn belangrijk om te begrijpen voor iedereen die programmeert.

De AND-operator in Java evalueert twee voorwaarden en retourneert alleen `true` als **beide statements of voorwaarden waar zijn**. Anders retourneert hij `false`. De operator wordt uitgedrukt met `&&`. De OR-operator in Java evalueert ook twee voorwaarden. Hij retourneert `true` als **een of beide statements of voorwaarden waar zijn**. Hij retourneert alleen `false` als beide statements onwaar zijn. Hij wordt uitgedrukt met `||`.

De syntaxis van de twee bewerkingen ziet er als volgt uit:

```java
statement1 operator statement2
```

Hieronder bekijken we enkele praktische voorbeelden die laten zien hoe de AND- en OR-operatoren van Java worden gebruikt.

## Hoe gebruik je de AND-operator in Java?

De AND-operator van Java wordt gebruikt om te beoordelen of twee uitspraken beide waar zijn. De syntaxis ziet er als volgt uit:

```java
statement1 && statement2
```

Het geeft `true` weer als beide voorwaarden waar zijn. Als een of beide voorwaarden onwaar zijn, geeft het `false` weer.

In ons eerste voorbeeld geven we het systeem twee eenvoudige instructies en gebruiken we het Java-commando `System.out.println` om een Booleaanse waarde terug te geven:

```java
public class Main {
	public static void main(String[] args) {
		int x = 3;
		System.out.println(x > 1 && x < 7);
	}
}
```

Het systeem beoordeelt eerst of de waarde 3 groter is dan 1. Dat is het geval. Vervolgens beoordeelt het de waarheid van de uitspraak ‘3&lt;7’. Ook dit is waar. Aangezien beide uitspraken waar zijn, geeft het ‘waar’ weer.

Laten we nu eens kijken wat er gebeurt als één uitspraak waar is, maar de andere niet. We gaan een kleine wijziging aanbrengen in het bovenstaande voorbeeld:

```java
public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 1 && x > 7);
	}
}
```

Ook hier zal het systeem eerst beoordelen of de waarde 3 groter is dan 1 en vaststellen dat dit waar is. Deze keer is de tweede voorwaarde echter niet waar. Aangezien beide voorwaarden niet waar zijn, zal het systeem `false` retourneren.

In ons derde voorbeeld zal de evaluatie nog korter zijn. Aangezien niet aan de eerste voorwaarde is voldaan, kijkt het systeem niet eens naar de tweede voorwaarde. In plaats daarvan geeft het gewoon `false` weer:

```java
public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 3 && x < 7);
	}
}
```

## Hoe gebruik je de OR-operator in Java?

De OR-operator van Java evalueert ook twee voorwaarden. De syntaxis ziet er als volgt uit:

```java
statement1 || statement2
```

In tegenstelling tot de AND-operator geeft de OR-operator `true` terug als ten minste één van de twee uitspraken waar is. Hij geeft ook `true` terug als beide uitspraken waar zijn. Hij geeft alleen `false` terug als **geen van beide uitspraken waar is**. Hieronder illustreren we hoe dit werkt aan de hand van enkele eenvoudige voorbeelden.

```java
public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 1 || x < 7);
	}
}
```

Het systeem geeft in dit voorbeeld `true` terug. Aangezien de eerste uitspraak waar is, is aan de voorwaarde van de OR-operator voldaan. Tot nu toe lijkt dit sterk op de AND-operator.

Nu bekijken we een voorbeeld waarin OR begint te verschillen van AND:

```java
public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 1 || x > 7);
	}
}
```

De eerste bewering is waar, aangezien 3 groter is dan 1. De tweede bewering is echter niet waar, aangezien 3 niet groter is dan 7. Aangezien een van de twee beweringen waar is, zal het systeem `true` retourneren.

We krijgen alleen een uitvoer van `false` wanneer geen van beide voorwaarden waar is, zoals in het onderstaande geval:

```java
public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 3 || x > 7);
	}
}
```

In dit voorbeeld bekijkt het systeem de eerste uitspraak en stelt vast dat deze onwaar is. Vervolgens gaat het naar de tweede uitspraak. Als de tweede uitspraak waar zou zijn, zou de uitvoer `true` zijn. Aangezien de tweede uitspraak echter onwaar is, is de uitvoer `false`.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-operatoren-and-en-or/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-operatoren-and-en-or/) for AI/LLM consumption.