# Sådan bruges OR-operatoren og AND-operatoren i Java

Java-operatorerne AND og OR bruges til at kontrollere nøjagtigheden af betingelser i Java. De to operatorer fungerer meget ens, men adskiller sig i detaljerne. I denne artikel forklarer vi alt, hvad du behøver at vide om AND og OR i Java.

## Hvad er Java’s AND- og OR-operatorer?

Java-operatorer er vigtige værktøjer til at arbejde med programmeringssproget. Der findes forskellige typer operatorer til forskellige formål. Java’s AND og OR er logiske operatorer, der bruges til at kontrollere **nøjagtigheden af en tilstand**. De returnerer de\*\*boolske værdier\* ‘true’ eller ‘false’. Det er vigtigt at forstå dem for alle, der lærer programmering.

AND-operatoren i Java evaluerer to betingelser og returnerer kun `true`, når **begge udsagn eller betingelser er sande**. Ellers returnerer den `false`. Operatoren udtrykkes med `&&`. OR-operatoren i Java evaluerer også to betingelser. Den returnerer `true`, når **et eller begge udsagn eller betingelser er sande**. Den returnerer kun `false`, hvis begge udsagn er falske. Den udtrykkes ved hjælp af `||`.

Syntaksen for de to operationer ser således ud:

```java
statement1 operator statement2
```

Nedenfor ser vi på et par praktiske eksempler, der viser, hvordan Java’s AND- og OR-operatorer bruges.

## Sådan bruges AND-operatoren i Java

Java’s AND-operator bruges til at vurdere, om to udsagn begge er sande. Dens syntaks ser således ud:

```java
statement1 && statement2
```

Den udgiver `true`, hvis begge betingelser er sande. Hvis en eller begge betingelser er falske, udgiver den `false`.

I vores første eksempel giver vi systemet to enkle udsagn og bruger Java-kommandoen `System.out.println` til at returnere en boolsk værdi:

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

Systemet vurderer først, om værdien 3 er større end 1. Det er den. Derefter vurderer det sandheden i udsagnet ‘3&lt;7’. Dette er også sandt. Da begge udsagn er sande, udgiver det ‘sand’.

Lad os nu se, hvad der sker, når den ene udsagn er sand, men den anden ikke er. Vi vil foretage en lille ændring i ovenstående eksempel:

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

Igen vil systemet først evaluere, om værdien 3 er større end 1, og finde ud af, at det er sandt. Denne gang er den anden betingelse imidlertid ikke sand. Da begge betingelser ikke er sande, vil systemet returnere `false`.

I vores tredje eksempel vil evalueringen være endnu kortere. Da den første betingelse ikke er opfyldt, ser systemet ikke engang på den anden betingelse. I stedet udskriver det blot `false`:

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

## Sådan bruges OR-operatoren i Java

Javas OR-operator evaluerer også to betingelser. Dens syntaks ser således ud:

```java
statement1 || statement2
```

I modsætning til AND-operatoren returnerer OR-operatoren `true`, hvis mindst én af de to udsagn er sand. Den returnerer også `true`, hvis begge udsagn er sande. Den returnerer kun `false`, hvis **ingen af udsagnene er sande**. Nedenfor illustrerer vi, hvordan dette fungerer, med et par enkle eksempler.

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

Systemet returnerer `true` for dette eksempel. Da den første sætning er sand, er betingelsen for OR-operatoren opfyldt. Indtil videre ligner dette AND-operatoren.

Nu skal vi se på et eksempel, hvor OR begynder at adskille sig fra AND:

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

Den første udsagn er sand, da 3 er større end 1. Den anden udsagn er dog ikke sand, da 3 ikke er større end 7. Da en af de to udsagn er sand, vil systemet returnere `true`.

Vi får kun et output på `false`, når ingen af betingelserne er opfyldt, som det er tilfældet nedenfor:

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

I dette eksempel ser systemet på den første sætning og fastslår, at den er falsk. Derefter går det videre til den anden sætning. Hvis den anden sætning var sand, ville resultatet være `true`. Men da den anden sætning faktisk er falsk, er resultatet `false`.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-operatorerne-and-og-or/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-operatorerne-and-og-or/) for AI/LLM consumption.