# Kuidas Java Math klass töötab

Java Mathiga saab teha lihtsaid arvutusi. Selles on erinevad meetodid, mis hõlmavad logaritme ja trigonomeetriat, samuti kõiki põhitõdesid. Süntaks on suhteliselt lihtne, mistõttu on seda kerge õppida.

## Mis on Java Math?

Kui soovite Java-s teha lihtsaid numbrilisi arvutusi, võite kasutada selle Math-klassi. Java-klassi ei ole vaja eraldi importida ja sellel on mitmeid meetodeid, mida käsitleme käesoleva artikli hilisemas osas üksikasjalikumalt.

Matemaatika klassi **ei instantsiata ja selle meetoditele pääseb ligi ainult staatiliselt**. Ka klassi kaks konstanti on staatilised: Euleri arv (ligikaudu e = 2,7182818284590), mis on loomuliku logaritmi ja loomuliku eksponentsiaalse funktsiooni alus, ning arv Pi (ligikaudu π = 3,1415926535). ProgrammeerimiskeeleMath-klass asub java.lang-paketis ja selle klassi arvutustulemused on tavaliselt double-andmetüüpi.

## Kuidas teha erinevaid arvutusi Java Mathiga

Java-klassi Math funktsionaalsust ja süntaksit on kõige parem mõista näidete abil. Klass ja selle kasutamine üksikute meetodite kontekstis on lihtsam mõista. Allpool on toodud mitmed erinevad arvutused, mis näitavad, kuidas klass töötab.

### Määrake absoluutsed väärtused

Kui soovite määrata parameetri absoluutväärtuse, võite kasutada `abs()`. Absoluutväärtus on vahemaa numbri ja 0 või märgita numbri vahel. See tähendab, et tulemus on alati positiivne. Selle meetodi jaoks lubatud andmetüübid on double, float, int ja long. Allpool näitame, kuidas `Math.abs` töötab positiivse numbriga. Järgnevate näidete väljundiks kasutame Java-käsku `System.out.println`.

```java
public class Main {
public static void main(String args[]) {
int number = +7;
System.out.println ("The original number is: " + number);
System.out.println ("The absolute number is: " + "Math.abs (" + number + ") = " + Math.abs(number));
}
}
```

Väljund näeb välja järgmine:

```java
The original number is: 7 
The absolute number is: Math.abs ( 7 ) = 7
```

Algväärtus võib olla ka negatiivne. Tulemus on ikkagi positiivne. Vaadakem, mis juhtub, kui muudame eespool toodud näite 7 negatiivseks:

```java
public class Main {
public static void main(String args[]) {
int number = -7;
System.out.println ("The original number is: " + number);
System.out.println ("The absolute number is: " + "Math.abs (" + number + ") = " + Math.abs(number));
}
}
```

Väljund on suures osas sama kui eelmises näites:

```java
The original number is: -7 
The absolute number is: Math.abs( -7 ) = 7
```

Meetod ignoreerib negatiivse täisarvu (-7) märgi ja väljastab tulemusena 7.

### Määrake suurim väärtus

Kasutage `max()` meetodit, et määrata kahe sisendi suurem väärtus. See toimib järgmiselt:

```java
public class Main {
public static void main(String args[]) {
double number = Math.max(3, 9);
System.out.println ("The larger number is: " + number);
}
}
```

Väljund on:

```java
The larger number is: 9.0
```

### Määrake väikseim väärtus

Väiksema väärtuse määramise kood on sarnane eelmise näite koodiga. Selleks kasutage meetodit `min()`:

```java
public class Main {
public static void main(String args[]) {
double number = Math.min(3, 9);
System.out.println ("The smaller number is: " + number);
}
}
```

Siin on väljund:

```java
The smaller number is: 3.0
```

### Arvuta võimsused

Eelmised näited olid üsna lihtsad, kuid Java klass Math suudab teha ka keerulisemaid arvutusi. Näiteks saab arvutada ka astmeid. Astmete arvutamise meetod on nimega **pow()**. Selle meetodi puhul peame enne arvutuse tegemist määrama aluse ja eksponendi.

```java
public class Main {
public static void main(String args[]) {
double base = 4;
double exponent = 2;
double power = Math.pow(base, exponent);
System.out.println ("The result is: " + power);
}
}
```

Väljund näeb välja järgmine:

```java
The result is: 16.0
```

### Arvuta ruutjuured

Seda klassi saab kasutada ka ruutjuure arvutamiseks `sqrt()` meetodil. Järgmises näites arvutame ruutjuure arvust 64:

```java
public class Main {
public static void main(String args[]) {
double number = 64;
double root = Math.sqrt(number);
System.out.println ("The result is: " + root);
}
}
```

See on väljund:

```java
The result is: 8.0
```

### Juhuslike numbrite genereerimine

`random()` meetodiga genereerib Java juhusliku arvu vahemikus 0,0 ja 1,0 või teie enda määratud vahemikus.

```java
public class Main {
public static void main(String args[]) {
double randomNumber;
System.out.println(Math.random());
}
}
```

Võimalik tulemus oleks:

```java
0.7488711506123137
```

Kuid saate ka võimalikke tulemusi piirata, näiteks lubades ainult täisarve vahemikus 0 kuni 100. Selleks kasutage järgmist koodi:

```java
public class Main {
public static void main(String args[]) {
int randomNumber = (int) (Math.random() * 101);
System.out.println(randomNumber);
}
}
```

See annab sulle sellise juhusliku tulemuse:

```java
27
```

## Millised on kõige olulisemad meetodid?

Java Math-klassiga saab kasutada mitmeid meetodeid. Siin on loetletud kõige olulisemad neist:

<table>
  <thead>
    <tr>
      <th><strong>Meetod</strong></th>
      <th><strong>Funktsioon</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`abs()`</td>
      <td>Tagastab argumendi absoluutväärtuse</td>
    </tr>
    <tr>
      <td>`max()`</td>
      <td>Tagastab kahe väärtuse suurema</td>
    </tr>
    <tr>
      <td>`min()`</td>
      <td>Tagastab kahe väärtuse väiksema.</td>
    </tr>
    <tr>
      <td>`pow()`</td>
      <td>Tagastab võimsuse väärtuse.</td>
    </tr>
    <tr>
      <td>`sqrt()`</td>
      <td>Arvutab ruutjuure</td>
    </tr>
    <tr>
      <td>`random()`</td>
      <td>Tagastab juhusliku kahekordse väärtuse</td>
    </tr>
    <tr>
      <td>`cbrt()`</td>
      <td>Arvutab kuupjuure</td>
    </tr>
    <tr>
      <td>`log()`</td>
      <td>Tagastab kahekordse väärtuse loomuliku logaritmi</td>
    </tr>
    <tr>
      <td>`sin()`</td>
      <td>Arvutab kahekordse väärtuse siinuse</td>
    </tr>
    <tr>
      <td>`cos()`</td>
      <td>Arvutab double-tüüpi väärtuse koosinuse.</td>
    </tr>
    <tr>
      <td>`tan()`</td>
      <td>Arvutab kahekordse väärtuse tangensi väärtuse.</td>
    </tr>
    <tr>
      <td>`round()`</td>
      <td>Ümardab kahekordse väärtuse üles- või allapoole täisarvuks.</td>
    </tr>
    <tr>
      <td>`negateExact()`</td>
      <td>Kuvab argumendi vastandväärtuse</td>
    </tr>
    <tr>
      <td>`floor()`</td>
      <td>Ümardab alla suurima kahekordse väärtuse, mis on väiksem või võrdne antud argumendiga.</td>
    </tr>
    <tr>
      <td>13c5abf9d4e693b8376239553b263482</td>
      <td></td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/kuidas-kasutada-java-math-klassi/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/kuidas-kasutada-java-math-klassi/) for AI/LLM consumption.