# Sådan fungerer Java Math-klassen

Du kan udføre enkle beregninger med Java Math. Det har forskellige metoder, der dækker logaritmer og trigonometri samt alle de grundlæggende emner. Syntaksen er forholdsvis enkel, hvilket gør det let at lære.

## Hvad er Java Math?

Hvis du vil udføre grundlæggende numeriske beregninger i Java, kan du bruge klassen Math. Java-klassen behøver ikke importeres separat og har adskillige metoder, som vi vil gennemgå mere detaljeret senere i denne artikel.

Math-klassen er **ikke instansieret, og dens metoder er kun tilgængelige statisk**. Klassens to konstanter er også statiske: Eulers tal (ca. e = 2,7182818284590), som er grundlaget for den naturlige logaritme og den naturlige eksponentialfunktion, og tallet Pi (ca. π = 3,1415926535). ProgrammeringssprogetsMath-klasse findes i java.lang-pakken, og beregningsresultaterne for denne klasse er normalt af datatypen double.

## Sådan udfører du forskellige beregninger med Java Math

Den bedste måde at forstå funktionaliteten og syntaksen i Java-klassen Math er at bruge eksempler. Det er lettere at forstå klassen og hvordan den bruges i sammenhæng med individuelle metoder. Nedenfor har vi inkluderet en række forskellige beregninger for at vise dig, hvordan klassen fungerer.

### Bestem absolutte værdier

Hvis du vil bestemme den absolutte værdi af en parameter, kan du bruge `abs()`. En absolut værdi er afstanden mellem et tal og 0 eller et tal uden fortegn. Det betyder, at resultatet altid vil være positivt. De datatyper, der er tilladt for denne metode, er double, float, int og long. Nedenfor viser vi dig, hvordan `Math.abs` fungerer med et positivt tal. Til output i de følgende eksempler bruger 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 således ud:

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

Den oprindelige værdi kan også være negativ. Resultatet vil stadig være positivt. Lad os se, hvad der sker, når vi gør 7 i ovenstående eksempel 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));
}
}
```

Outputtet er stort set det samme som i det foregående eksempel:

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

Metoden ignorerer fortegnet for det negative heltal (-7) og udgiver 7 som resultat.

### Bestem den største værdi

Brug metoden `max()` til at bestemme den største værdi af to indgange. Sådan 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);
}
}
```

Outputtet er:

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

### Bestem den mindste værdi

Koden til at bestemme en mindre værdi ligner koden i det foregående eksempel. Brug metode `min()` til at gø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 eksempler var ret enkle, er der mere sofistikerede beregninger, som Java-klassen Math kan udføre. For eksempel kan du også beregne potenser. Metoden til beregning af potenser hedder **pow()**. Med denne metode skal vi først definere en base og en eksponent, før vi kan udføre 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);
}
}
```

Sådan vil resultatet se ud:

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

### Beregn kvadratrødder

Klassen kan også bruges til kvadratrodsberegninger med `sqrt()`. I det følgende eksempel beregner vi kvadratroden af 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 tilfældige tal

Med metoden `random()` genererer Java et tilfældigt tal mellem 0,0 og 1,0 eller inden for et interval, som du selv angiver.

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

Et muligt resultat kunne være:

```java
0.7488711506123137
```

Du kan dog også begrænse de mulige resultater, for eksempel ved kun at tillade hele tal mellem 0 og 100. For at gøre dette skal du bruge følgende kode:

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

Dette giver dig et tilfældigt resultat som dette:

```java
27
```

## Hvad er de vigtigste metoder?

Der er mange metoder, du kan bruge med Java Math-klassen. Vi har listet de vigtigste for dig her:

<table>
  <thead>
    <tr>
      <th><strong>Metode</strong></th>
      <th><strong>Funktion</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`abs()`</td>
      <td>Returnerer den absolutte værdi af et argument</td>
    </tr>
    <tr>
      <td>`max()`</td>
      <td>Returnerer den største af to værdier</td>
    </tr>
    <tr>
      <td>`min()`</td>
      <td>Returnerer den mindste af to værdier</td>
    </tr>
    <tr>
      <td>`pow()`</td>
      <td>Returnerer potensværdien</td>
    </tr>
    <tr>
      <td>`sqrt()`</td>
      <td>Beregner kvadratroden</td>
    </tr>
    <tr>
      <td>`random()`</td>
      <td>Returnerer en tilfældig dobbeltværdi</td>
    </tr>
    <tr>
      <td>`cbrt()`</td>
      <td>Beregner kubikroden</td>
    </tr>
    <tr>
      <td>`log()`</td>
      <td>Returnerer den naturlige logaritme af en dobbeltværdi.</td>
    </tr>
    <tr>
      <td>`sin()`</td>
      <td>Beregner sinus for en dobbeltværdi</td>
    </tr>
    <tr>
      <td>`cos()`</td>
      <td>Beregner cosinus for en dobbeltværdi.</td>
    </tr>
    <tr>
      <td>`tan()`</td>
      <td>Beregner tangensværdien af en dobbeltværdi.</td>
    </tr>
    <tr>
      <td>`round()`</td>
      <td>Afrunder en dobbeltværdi op eller ned til et heltal</td>
    </tr>
    <tr>
      <td>`negateExact()`</td>
      <td>Viser den modsatte værdi af et argument</td>
    </tr>
    <tr>
      <td>`floor()`</td>
      <td>Afrunder den største dobbeltværdi, der er mindre end eller lig med det givne argument, nedad.</td>
    </tr>
    <tr>
      <td>13c5abf9d4e693b8376239553b263482</td>
      <td></td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/saadan-bruges-java-math-klassen/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/saadan-bruges-java-math-klassen/) for AI/LLM consumption.