# Hvordan Java Math-klassen fungerer

Du kan utføre enkle beregninger med Java Math. Den har forskjellige metoder som dekker logaritmer og trigonometri, samt alle grunnleggende funksjoner. Syntaksen er relativt enkel, noe som gjør den lett å lære.

## Hva er Java Math?

Hvis du vil utføre grunnleggende numeriske beregninger i Java, kan du bruke Math-klassen. Java-klassen trenger ikke importeres separat og har mange metoder som vi vil gå nærmere inn på senere i denne artikkelen.

Math-klassen er **ikke instansiert, og metodene i den er kun tilgjengelige statisk**. De to konstantene i klassen er også statiske: Eulers tall (omtrent e = 2,7182818284590), som er grunnlaget for den naturlige logaritmen og den naturlige eksponensialfunksjonen, og tallet Pi (omtrent π = 3,1415926535). ProgrammeringsspråketsMath-klasse finnes i java.lang-pakken, og beregningsresultatene for denne klassen er vanligvis av datatypen double.

## Hvordan utføre forskjellige beregninger med Java Math

Den beste måten å forstå funksjonaliteten og syntaksen til Java-klassen Math er å bruke eksempler. Det er lettere å forstå klassen og hvordan den brukes i sammenheng med individuelle metoder. Nedenfor har vi inkludert en rekke forskjellige beregninger for å vise deg hvordan klassen fungerer.

### Bestem absolutte verdier

Hvis du vil bestemme absoluttverdien til en parameter, kan du bruke `abs()`. En absoluttverdi er avstanden mellom et tall og 0 eller et tall uten fortegn. Dette betyr at resultatet alltid vil være positivt. Datatypene som er tillatt for denne metoden er double, float, int og long. Nedenfor viser vi deg hvordan `Math.abs` fungerer med et positivt tall. For utdataene i eksemplene som følger, bruker vi Java-kommandoen `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));
}
}
```

Resultatet ser slik ut:

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

Startverdien kan også være negativ. Resultatet vil fortsatt være positivt. La oss se hva som skjer når vi gjør 7 i eksemplet ovenfor negativt:

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

Resultatet er stort sett det samme som i forrige eksempel:

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

Metoden ignorerer fortegnet til det negative heltallet (-7) og gir 7 som resultat.

### Bestem den største verdien

Bruk `max()` -metoden for å finne den største verdien av to inngangsverdier. Slik fungerer det:

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

Resultatet er:

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

### Bestem den minste verdien

Koden for å bestemme en mindre verdi er lik koden i forrige eksempel. Bruk metode `min()` for å gjøre dette:

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

Her er resultatet:

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

### Beregn potenser

Mens de foregående eksemplene var ganske enkle, finnes det mer sofistikerte beregninger som Java-klassen Math kan utføre. Du kan for eksempel også beregne potenser. Metoden for å beregne potenser heter **pow()**. Med denne metoden må vi først definere en basis og en eksponent før vi utfører beregningen.

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

Slik vil resultatet se ut:

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

### Beregn kvadratrøtter

Klassen kan også brukes til kvadratrotberegninger med `sqrt()`. I det følgende eksemplet skal vi beregne kvadratroten av 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);
}
}
```

Dette er resultatet:

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

### Generer tilfeldige tall

Med metoden `random()` genererer Java et tilfeldig tall mellom 0,0 og 1,0 eller i et område som du selv angir.

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

Et mulig resultat kan være:

```java
0.7488711506123137
```

Du kan imidlertid også begrense de mulige resultatene, for eksempel ved å bare tillate hele tall mellom 0 og 100. For å gjøre dette, bruk følgende kode:

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

Dette vil gi deg et tilfeldig resultat som dette:

```java
27
```

## Hva er de viktigste metodene?

Det finnes mange metoder du kan bruke med Java Math-klassen. Vi har listet opp de viktigste for deg her:

<table>
  <thead>
    <tr>
      <th><strong>Metode</strong></th>
      <th><strong>Funksjon</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`abs()`</td>
      <td>Returnerer absoluttverdien av et argument</td>
    </tr>
    <tr>
      <td>`max()`</td>
      <td>Returnerer den største av to verdier</td>
    </tr>
    <tr>
      <td>`min()`</td>
      <td>Returnerer den minste av to verdier</td>
    </tr>
    <tr>
      <td>`pow()`</td>
      <td>Returnerer potensverdien</td>
    </tr>
    <tr>
      <td>`sqrt()`</td>
      <td>Beregner kvadratroten</td>
    </tr>
    <tr>
      <td>`random()`</td>
      <td>Returnerer en tilfeldig dobbel verdi</td>
    </tr>
    <tr>
      <td>`cbrt()`</td>
      <td>Beregner kubikkroten</td>
    </tr>
    <tr>
      <td>`log()`</td>
      <td>Returnerer den naturlige logaritmen til en dobbel verdi</td>
    </tr>
    <tr>
      <td>`sin()`</td>
      <td>Beregner sinus av en dobbel verdi</td>
    </tr>
    <tr>
      <td>`cos()`</td>
      <td>Beregner cosinus av en dobbel verdi</td>
    </tr>
    <tr>
      <td>`tan()`</td>
      <td>Beregner tangensverdien av en dobbel verdi</td>
    </tr>
    <tr>
      <td>`round()`</td>
      <td>Avrunder en dobbel verdi opp eller ned til et heltall</td>
    </tr>
    <tr>
      <td>`negateExact()`</td>
      <td>Viser den motsatte verdien av et argument</td>
    </tr>
    <tr>
      <td>`floor()`</td>
      <td>Avrunder ned den største doble verdien som er mindre enn eller lik det gitte argumentet.</td>
    </tr>
    <tr>
      <td>13c5abf9d4e693b8376239553b263482</td>
      <td></td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/hvordan-bruke-java-math-klassen/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/hvordan-bruke-java-math-klassen/) for AI/LLM consumption.