# Kuidas kasutada Java-s OR-operaatorit ja AND-operaatorit

Java-operaatoreid AND ja OR kasutatakse Java-keeles tingimuste täpsuse kontrollimiseks. Need kaks operaatorit toimivad väga sarnaselt, kuid erinevad üksikasjade poolest. Käesolevas artiklis selgitame kõike, mida peate Java-keeles AND ja OR kohta teadma.

## Mis on Java AND- ja OR-operaatorid?

Java operaatorid on olulised tööriistad programmeerimiskeele kasutamisel. Erinevateks eesmärkideks on olemas erinevad operaatorid. Java operaatorid AND ja OR on loogilised operaatorid, mida kasutatakse **seisundi täpsuse** kontrollimiseks. Need tagastavad\*\*Boolean väärtused\* „true” või „false”. Need on olulised mõista kõigile, kes õpivad programmeerimist.

Java keeles hindab AND-operaator kahte tingimust ja tagastab `true` ainult siis, kui **mõlemad väited või tingimused on tõesed**. Muidu tagastab ta `false`. Operaatorit väljendatakse numbriga `&&`. Java keeles hindab OR-operaator samuti kahte tingimust. Ta tagastab `true`, kui **üks või mõlemad väited või tingimused on tõesed**. Ta tagastab `false` ainult siis, kui mõlemad väited on valed. Seda väljendatakse numbriga `||`.

Kahe operatsiooni süntaks on järgmine:

```java
statement1 operator statement2
```

Allpool vaatame mõningaid praktilisi näiteid, mis näitavad, kuidas Java AND- ja OR-operaatoreid kasutatakse.

## Kuidas kasutada AND-operaatorit Java-s

Java AND-operaatorit kasutatakse selleks, et hinnata, kas kaks väidet on mõlemad tõesed. Selle süntaks on järgmine:

```java
statement1 && statement2
```

Kui mõlemad tingimused on tõesed, väljastab see `true`. Kui üks või mõlemad tingimused on valed, väljastab see `false`.

Esimeses näites anname süsteemile kaks lihtsat avaldust ja kasutame Java käsku `System.out.println`, et tagastada booli väärtus:

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

Süsteem hindab esmalt, kas väärtus 3 on suurem kui 1. See on. Seejärel hindab süsteem väite „3&lt;7” tõesust. See on samuti tõene. Kuna mõlemad väited on tõesed, väljastab süsteem tulemuseks „true”.

Nüüd vaatame, mis juhtub, kui üks väide on tõene, aga teine mitte. Teeme eespool toodud näites väikese muudatuse:

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

Jällegi hindab süsteem esmalt, kas väärtus 3 on suurem kui 1, ja leiab, et see on tõene. Seekord ei ole aga teine väide tõene. Kuna mõlemad tingimused ei ole tõene, annab süsteem tulemuseks `false`.

Kolmandas näites on hindamine veelgi lühem. Kuna esimene tingimus ei ole täidetud, ei vaata süsteem isegi teist tingimust. Selle asemel väljastab ta lihtsalt `false`:

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

## Kuidas kasutada OR-operaatorit Java-s

Java OR-operaator hindab samuti kahte tingimust. Selle süntaks on järgmine:

```java
statement1 || statement2
```

Erinevalt AND-operaatorist tagastab OR-operaator `true`, kui vähemalt üks kahest väitest on tõene. Samuti tagastab see `true`, kui mõlemad väited on tõesed. Väärtus `false` tagastatakse ainult juhul, kui **kumbki väide ei ole tõene**. Allpool illustreerime selle toimimist mõne lihtsa näite abil.

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

Süsteem annab selle näite puhul tulemuseks `true`. Kuna esimene väide on tõene, on OR-operaatori tingimus täidetud. Siiani näeb see välja üsna sarnane AND-operaatoriga.

Nüüd vaatame näidet, kus OR hakkab AND-ist erinema:

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

Esimene väide on õige, kuna 3 on suurem kui 1. Teine väide aga ei ole õige, kuna 3 ei ole suurem kui 7. Kuna üks kahest väitest on õige, annab süsteem tulemuseks `true`.

Saame väljundi `false` ainult siis, kui kumbki tingimus ei ole täidetud, nagu allpool näidatud juhul:

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

Selles näites vaatab süsteem esimest väidet ja otsustab, et see on vale. Seejärel pöördub süsteem teise väite poole. Kui teine väide oleks õige, oleks väljundiks `true`. Kuna teine väide on aga tegelikult vale, on väljundiks `false`.


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-operaatorid-and-ja-or/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-operaatorid-and-ja-or/) for AI/LLM consumption.