# Hoe de Java Math-klasse werkt

Je kunt eenvoudige berekeningen uitvoeren met Java Math. Het heeft verschillende methoden die logaritmen en trigonometrie omvatten, evenals alle basisbeginselen. De syntaxis is relatief eenvoudig, waardoor het gemakkelijk te leren is.

## Wat is Java Math?

Als u eenvoudige numerieke berekeningen wilt uitvoeren in Java, kunt u de Math-klasse gebruiken. De Java-klasse hoeft niet apart te worden geïmporteerd en bevat talrijke methoden die we later in dit artikel nader zullen bespreken.

De Math-klasse wordt **niet geïnstantieerd en de methoden ervan zijn alleen statisch toegankelijk**. De twee constanten van de klasse zijn ook statisch: het getal van Euler (ongeveer e = 2,7182818284590), dat de basis vormt voor de natuurlijke logaritme en de natuurlijke exponentiële functie, en het getal Pi (ongeveer π = 3,1415926535). De Math-klasse van de programmeertaalis opgenomen in het java.lang-pakket en de berekeningsresultaten van deze klasse zijn meestal van het gegevenstype double.

## Hoe verschillende berekeningen uitvoeren met Java Math

De beste manier om de functionaliteit en syntaxis van de Java-klasse Math te begrijpen, is door voorbeelden te gebruiken. Het is gemakkelijker om de klasse en het gebruik ervan te begrijpen in de context van individuele methoden. Hieronder hebben we een reeks verschillende berekeningen opgenomen om te laten zien hoe de klasse werkt.

### Bepaal absolute waarden

Als u de absolute waarde van een parameter wilt bepalen, kunt u `abs()` gebruiken. Een absolute waarde is de afstand tussen een getal en 0 of een getal zonder teken. Dit betekent dat het resultaat altijd positief zal zijn. De gegevenstypen die voor deze methode zijn toegestaan, zijn double, float, int en long. Hieronder laten we u zien hoe `Math.abs` werkt met een positief getal. Voor de uitvoer in de volgende voorbeelden gebruiken we het Java-commando `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));
}
}
```

De uitvoer ziet er als volgt uit:

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

De beginwaarde kan ook negatief zijn. Het resultaat blijft positief. Laten we eens kijken wat er gebeurt als we de 7 in het bovenstaande voorbeeld negatief maken:

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

De uitvoer is grotendeels hetzelfde als die van het vorige voorbeeld:

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

De methode negeert het teken van het negatieve gehele getal (-7) en geeft 7 als resultaat weer.

### Bepaal de grootste waarde

Gebruik de `max()` om de grootste waarde van twee invoeren te bepalen. Zo werkt het:

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

De uitvoer is:

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

### Bepaal de kleinste waarde

De code voor het bepalen van een kleinere waarde is vergelijkbaar met de code in het vorige voorbeeld. Gebruik hiervoor methode `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);
}
}
```

Dit is de uitvoer:

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

### Vermogens berekenen

Hoewel de vorige voorbeelden vrij eenvoudig waren, zijn er ook meer geavanceerde berekeningen die de Java-klasse Math kan uitvoeren. Je kunt bijvoorbeeld ook machten berekenen. De methode voor het berekenen van machten heet **pow()**. Bij deze methode moeten we eerst een basis en een exponent definiëren voordat we de berekening kunnen uitvoeren.

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

Dit is hoe de uitvoer eruit zal zien:

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

### Wortels berekenen

De klasse kan ook worden gebruikt voor wortelberekeningen met de `sqrt()`. In het volgende voorbeeld berekenen we de wortel van 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);
}
}
```

Dit is de uitvoer:

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

### Willekeurige getallen genereren

Met de `random()` genereert Java een willekeurig getal tussen 0,0 en 1,0 of binnen een door u zelf opgegeven bereik.

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

Een mogelijke uitvoer zou zijn:

```java
0.7488711506123137
```

Je kunt echter ook de mogelijke resultaten beperken, bijvoorbeeld door alleen hele getallen tussen 0 en 100 toe te staan. Gebruik hiervoor de volgende code:

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

Dit levert een willekeurig resultaat op, zoals dit:

```java
27
```

## Wat zijn de belangrijkste methoden?

Er zijn tal van methoden die u kunt gebruiken met de Java Math-klasse. We hebben hier de belangrijkste voor u op een rijtje gezet:

<table>
  <thead>
    <tr>
      <th><strong>Methode</strong></th>
      <th><strong>Functie</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`abs()`</td>
      <td>Geeft de absolute waarde van een argument terug</td>
    </tr>
    <tr>
      <td>`max()`</td>
      <td>Geeft de grootste van twee waarden terug</td>
    </tr>
    <tr>
      <td>`min()`</td>
      <td>Geeft de kleinste van twee waarden terug</td>
    </tr>
    <tr>
      <td>`pow()`</td>
      <td>Geeft de machtswaarde terug</td>
    </tr>
    <tr>
      <td>`sqrt()`</td>
      <td>Berekent de vierkantswortel</td>
    </tr>
    <tr>
      <td>`random()`</td>
      <td>Geeft een willekeurige dubbele waarde terug</td>
    </tr>
    <tr>
      <td>`cbrt()`</td>
      <td>Berekent de kubieke wortel</td>
    </tr>
    <tr>
      <td>`log()`</td>
      <td>Geeft de natuurlijke logaritme van een dubbele waarde terug</td>
    </tr>
    <tr>
      <td>`sin()`</td>
      <td>Berekent de sinus van een dubbele waarde</td>
    </tr>
    <tr>
      <td>`cos()`</td>
      <td>Berekent de cosinus van een dubbele waarde</td>
    </tr>
    <tr>
      <td>`tan()`</td>
      <td>Berekent de tangenswaarde van een dubbele waarde</td>
    </tr>
    <tr>
      <td>`round()`</td>
      <td>Rondt een dubbele waarde naar boven of beneden af naar een geheel getal</td>
    </tr>
    <tr>
      <td>`negateExact()`</td>
      <td>Geeft de tegengestelde waarde van een argument weer</td>
    </tr>
    <tr>
      <td>`floor()`</td>
      <td>Rondt de grootste dubbele waarde die kleiner is dan of gelijk is aan het opgegeven argument naar beneden af</td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/hoe-gebruik-je-de-java-math-klasse/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/hoe-gebruik-je-de-java-math-klasse/) for AI/LLM consumption.