# Java Math -luokan toiminta

Java Mathilla voi tehdä yksinkertaisia laskutoimituksia. Siinä on erilaisia menetelmiä, jotka kattavat logaritmit ja trigonometrian sekä kaikki perusasiat. Syntaksi on suhteellisen yksinkertainen, joten se on helppo oppia.

## Mikä on Java Math?

Jos haluat suorittaa peruslaskutoimituksia Java-kielellä, voit käyttää sen Math-luokkaa. Java-luokkaa ei tarvitse tuoda erikseen, ja se sisältää lukuisia menetelmiä, joita käsittelemme tarkemmin myöhemmin tässä artikkelissa.

Math-luokkaa **ei instansioida, ja sen metodeihin pääsee käsiksi vain staattisesti**. Luokan kaksi vakioarvoa ovat myös staattisia: Eulerin luku (noin e = 2,7182818284590), joka on luonnollisen logaritmin ja luonnollisen eksponenttifunktion perusta, sekä luku Pi (noin π = 3,1415926535). OhjelmointikielenMath-luokka sisältyy java.lang-pakettiin, ja tämän luokan laskentatulokset ovat yleensä double-tietotyyppiä.

## Kuinka suorittaa erilaisia laskelmia Java Mathilla

Java-luokan Math toiminnallisuus ja syntaksi on helpointa ymmärtää esimerkkien avulla. Luokan ja sen käytön ymmärtäminen on helpompaa yksittäisten menetelmien yhteydessä. Alla on esitetty erilaisia laskelmia, jotka havainnollistavat luokan toimintaa.

### Määritä absoluuttiset arvot

Jos haluat määrittää parametrin absoluuttisen arvon, voit käyttää `abs()`. Absoluuttinen arvo on luvun ja 0:n tai etumerkittömän luvun välinen etäisyys. Tämä tarkoittaa, että tulos on aina positiivinen. Tämän menetelmän sallitut tietotyypit ovat double, float, int ja long. Alla näytämme, miten `Math.abs` toimii positiivisen luvun kanssa. Seuraavien esimerkkien tulosteissa käytämme Java-komentoa `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));
}
}
```

Tulostus näyttää tältä:

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

Alkuarvo voi olla myös negatiivinen. Tulos on silti positiivinen. Katsotaanpa, mitä tapahtuu, kun muutamme yllä olevan esimerkin luvun 7 negatiiviseksi:

```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));
}
}
```

Tulostus on suurelta osin sama kuin edellisessä esimerkissä:

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

Menetelmä jättää huomiotta negatiivisen kokonaisluvun (-7) merkin ja tulostaa tulokseksi 7.

### Määritä suurin arvo

Käytä `max()` -menetelmää kahden syötteen suuremman arvon määrittämiseen. Näin se toimii:

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

Tulostus on:

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

### Määritä pienin arvo

Pienemmän arvon määrittämiseen käytettävä koodi on samanlainen kuin edellisessä esimerkissä. Käytä tätä varten menetelmää `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);
}
}
```

Tässä on tulos:

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

### Laske potenssit

Edelliset esimerkit olivat melko yksinkertaisia, mutta Java-luokka Math pystyy suorittamaan myös monimutkaisempia laskutoimituksia. Voit esimerkiksi laskea potensseja. Potenssin laskemiseen käytetään **pow()**-metodia. Tätä metodia käytettäessä on ensin määriteltävä kanta ja eksponentti ennen laskennan suorittamista.

```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);
}
}
```

Tulos näyttää tältä:

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

### Laske neliöjuuret

Luokkaa voidaan käyttää myös neliöjuuren laskemiseen `sqrt()` -menetelmällä. Seuraavassa esimerkissä laskemme 64:n neliöjuuren:

```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);
}
}
```

Tämä on tulos:

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

### Luo satunnaislukuja

`random()` -menetelmällä Java luo satunnaislukua välillä 0,0 ja 1,0 tai itse määrittämässäsi alueella.

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

Mahdollinen tulos voisi olla:

```java
0.7488711506123137
```

Voit kuitenkin myös rajoittaa mahdollisia tuloksia, esimerkiksi sallimalla vain kokonaislukuja välillä 0–100. Tätä varten käytä seuraavaa koodia:

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

Tämä antaa sinulle satunnaisen tuloksen, kuten tämän:

```java
27
```

## Mitkä ovat tärkeimmät menetelmät?

Java Math -luokassa on useita menetelmiä, joita voit käyttää. Olemme listanneet tärkeimmät niistä tässä:

<table>
  <thead>
    <tr>
      <th><strong>Menetelmä</strong></th>
      <th><strong>Toiminto</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`abs()`</td>
      <td>Palauttaa argumentin absoluuttisen arvon</td>
    </tr>
    <tr>
      <td>`max()`</td>
      <td>Palauttaa kahden arvon suuremman</td>
    </tr>
    <tr>
      <td>`min()`</td>
      <td>Palauttaa pienemmän kahdesta arvosta.</td>
    </tr>
    <tr>
      <td>`pow()`</td>
      <td>Palauttaa potenssin arvon</td>
    </tr>
    <tr>
      <td>`sqrt()`</td>
      <td>Laskee neliöjuuren</td>
    </tr>
    <tr>
      <td>`random()`</td>
      <td>Palauttaa satunnaisen kaksoisarvon</td>
    </tr>
    <tr>
      <td>`cbrt()`</td>
      <td>Laskee kuutiojuuren</td>
    </tr>
    <tr>
      <td>`log()`</td>
      <td>Palauttaa double-arvon luonnollisen logaritmin</td>
    </tr>
    <tr>
      <td>`sin()`</td>
      <td>Laskee double-arvon sini</td>
    </tr>
    <tr>
      <td>`cos()`</td>
      <td>Laskee double-arvon kosinin</td>
    </tr>
    <tr>
      <td>`tan()`</td>
      <td>Laskee kaksoisarvon tangentin arvon.</td>
    </tr>
    <tr>
      <td>`round()`</td>
      <td>Pyöristää kaksoisarvon ylöspäin tai alaspäin kokonaisluvuksi</td>
    </tr>
    <tr>
      <td>`negateExact()`</td>
      <td>Näyttää argumentin vastakkaisen arvon.</td>
    </tr>
    <tr>
      <td>`floor()`</td>
      <td>Pyöristää alaspäin suurimman kaksoisarvon, joka on pienempi tai yhtä suuri kuin annettu argumentti.</td>
    </tr>
    <tr>
      <td>13c5abf9d4e693b8376239553b263482</td>
      <td></td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-math-luokan-kaeyttoe/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-math-luokan-kaeyttoe/) for AI/LLM consumption.