# Hvordan bruke OR-operatoren og AND-operatoren i Java

Java-operatorene AND og OR brukes til å kontrollere nøyaktigheten av betingelser i Java. De to operatorene fungerer på svært lik måte, men skiller seg fra hverandre når det gjelder detaljene. I denne artikkelen forklarer vi alt du trenger å vite om AND og OR i Java.

## Hva er Java-operatorene AND og OR?

Java-operatorer er viktige verktøy for å arbeide med programmeringsspråket. Det finnes forskjellige typer operatorer for forskjellige formål. Java-operatorene AND og OR er logiske operatorer som brukes til å sjekke **nøyaktigheten av en tilstand**. De returnerer de\*\*boolske verdiene\* «true» eller «false». Det er viktig å forstå disse for alle som lærer programmering.

AND-operatoren i Java evaluerer to betingelser og returnerer `true` bare når **begge utsagnene eller betingelsene er sanne**. Ellers returnerer den `false`. Operatoren uttrykkes med `&&`. OR-operatoren i Java evaluerer også to betingelser. Den returnerer `true` når **ett eller begge utsagnene eller betingelsene er sanne**. Den returnerer bare `false` hvis begge utsagnene er falske. Den uttrykkes ved hjelp av `||`.

Syntaksen for de to operasjonene ser slik ut:

```java
statement1 operator statement2
```

Nedenfor ser vi på noen praktiske eksempler som viser hvordan Java-operatorene AND og OR brukes.

## Hvordan bruke AND-operatoren i Java

Javas AND-operator brukes til å evaluere om to utsagn begge er sanne. Syntaksen ser slik ut:

```java
statement1 && statement2
```

Den gir ut `true` hvis begge betingelsene er sanne. Hvis en eller begge betingelsene er falske, gir den ut `false`.

I vårt første eksempel gir vi systemet to enkle utsagn og bruker Java-kommandoen `System.out.println` til å returnere en boolsk verdi:

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

Systemet vil først vurdere om verdien 3 er større enn 1. Det er den. Deretter vurderer det sannheten i utsagnet «3&lt;7». Dette er også sant. Siden begge utsagnene er sanne, gir det ut «sant».

La oss nå se hva som skjer når den ene utsagnet er sant, men den andre ikke er det. Vi skal gjøre en liten endring i eksemplet ovenfor:

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

Igjen vil systemet først vurdere om verdien 3 er større enn 1 og finne at det er sant. Denne gangen er imidlertid den andre setningen ikke sann. Siden begge betingelsene ikke er sanne, vil systemet returnere `false`.

I vårt tredje eksempel vil evalueringen bli enda kortere. Siden den første betingelsen ikke er oppfylt, ser systemet ikke engang på den andre betingelsen. I stedet gir det bare ut `false`:

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

## Hvordan bruke OR-operatoren i Java

Javas OR-operator evaluerer også to betingelser. Syntaksen ser slik ut:

```java
statement1 || statement2
```

I motsetning til AND-operatoren returnerer OR-operatoren `true` hvis minst én av de to setningene er sann. Den returnerer også `true` hvis begge setningene er sanne. Den returnerer bare `false` hvis **ingen av setningene er sanne**. Nedenfor illustrerer vi hvordan dette fungerer med noen enkle eksempler.

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

Systemet vil returnere `true` for dette eksemplet. Siden den første setningen er sann, er betingelsen for OR-operatoren oppfylt. Så langt ser dette ganske likt ut som AND-operatoren.

Nå skal vi se på et eksempel der OR begynner å skille seg 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 påstanden er sann, siden 3 er større enn 1. Den andre påstanden er imidlertid ikke sann, siden 3 ikke er større enn 7. Siden en av de to påstandene er sann, vil systemet returnere `true`.

Vi får bare et resultat på `false` når ingen av betingelsene er oppfylt, som i eksemplet nedenfor:

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

I dette eksemplet ser systemet på den første setningen og fastslår at den er falsk. Deretter går det videre til den andre setningen. Hvis den andre setningen var sann, ville resultatet blitt `true`. Men siden den andre setningen faktisk er falsk, blir resultatet `false`.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-operatorene-and-og-or/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-operatorene-and-og-or/) for AI/LLM consumption.