# Java Math: Tudo sobre a classe Math em Java e seus métodos

A classe Math permite que você realize cálculos simples em códigos escritos em Java. Os muitos métodos suportados abrangem não somente cálculos básicos, como também cálculos logarítmicos, trigonométricos, exponenciais e outros. A sintaxe da classe Math em Java é relativamente simples e fácil de se aprender.

## O que é Java Math?

Se você precisa realizar operações numéricas simples em códigos em Java, já deve saber que essa [linguagem de programação](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web") oferece suporte ao padrão Math, não precisando, este, ser importado. Ainda, a classe Math em Java, um tipo de classe **não instanciado, cujos métodos são usados somente estaticamente**, suporta vários métodos, que serão devidamente listados e explicados por este tutorial. Da mesma forma, as duas constantes de Java Math também são estáticas: a primeira diz respeito ao número de Euler (aproximadamente 2,7182818284590), usado como base para o logaritmo natural e para a função exponencial natural; a segunda corresponde ao número pi (aproximadamente 3,1415926535). Java Math está contida no pacote *java.lang*, já o tipo de resultado dos cálculos geralmente é *double*.

## Java Math para calcular valores absolutos

Tanto o funcionamento quanto a sintaxe da classe Math em Java podem ser mais bem ilustrados por exemplos de códigos que adotam diferentes métodos. Se você deseja calcular o valor absoluto de um parâmetro, por exemplo, basta usar o método `abs()` — um valor absoluto é a distância entre um número e 0 ou entre um número e outro sem sinal; esse valor sempre será positivo. Os tipos de dados aceitos pelo método `abs()` são *double*, *float*, *int* e *long*. Observe, abaixo, como Math.abs funciona com um número positivo — para obtermos os resultados desejados, utilizamos neste e nos próximos exemplos o [comando em Java](https://www.ionos.com/digitalguide/websites/web-development/java-commands/ "Comandos em Java") `System.out.println`:

```java
public class Main {
public static void main(String args[]) {
int number = +7;
System.out.println ("O número original é: " + number);
System.out.println ("O número absoluto é: " + "Math.abs (" + number + ") = " + Math.abs(number));
}
}
```

O resultado obtido pela operação acima será:

```java
O número original é 7. O valor absoluto é Math.abs ( 7 ) = 7
```

Também é possível utilizar valores de entrada negativos em operações que utilizam o método Math.abs. Ainda assim, o resultado será positivo, como prova o próximo exemplo:

```java
public class Main {
public static void main(String args[]) {
int number = -7;
System.out.println ("O número original é: " + number);
System.out.println ("O número absoluto é: " + “Math.abs (" + number + ") = " + Math.abs(number));
}
}
```

Veja que o resultado é praticamente o mesmo do exemplo anterior:

```java
O número original é -7 O número absoluto é Math.abs( -7 ) = 7
```

O método Math.abs ignora o sinal do número inteiro negativo (-7), também retornando “7” como resultado.

## Java Math para retornar o maior valor

Se você adotar o método `max()`, poderá encontra o maior valor entre duas entradas. O código abaixo exemplifica seu uso:

```java
public class Main {
public static void main(String args[]) {
double número = Math.max(3, 9);
System.out.println ("O número maior é: " + número);
}
}
```

Ao ser executado, esse código apresentará o seguinte resultado:

```java
O número maior é 9
```

## Java Math para retornar o menor valor

A classe Math em Java também pode ser usada para se descobrir o menor valor entre duas entradas. Para tanto, você deverá fazer uso do método `min()`, como mostra o exemplo abaixo:

```java
public class Main {
public static void main(String args[]) {
double número = Math.min(3, 9);
System.out.println ("O número menor é: " + número);
}
}
```

Ao ser executado, esse código retornará o seguinte resultado:

```java
O número menor é 3
```

## Java Math para calcular potências

Apesar de os exemplos anteriores poderem ser considerados simples, a classe Math em Java consegue realizar cálculos um pouco mais complexos. Para tanto, você deverá utilizar o método `pow()`. No nosso exemplo, primeiramente definimos uma base e um expoente, para só então realizarmos o cálculo:

```java
public class Main {
public static void main(String args[]) {
double basis = 4;
double exponent = 2;
double potência = Math.pow(basis, exponent);
System.out.println ("O resultado é: " + potência);
}
}
```

O resultado apresentado por esse código será:

```java
O resultado é 16
```

## Java Math para calcular raiz quadrada

A classe Math em Java também pode ser usada para a realização de cálculos com raiz quadrada: basta que se utilize o método `sqrt()`. No exemplo abaixo, calculamos a raiz quadrada de 64:

```java
public class Main {
public static void main(String args[]) {
double número = 64;
double raíz = Math.sqrt(número);
System.out.println ("O resultado é: " + raiz);
}
}
```

O seguinte resultado é apresentado pelo código:

```java
O resultado é 8.0
```

## Java Math para gerar números aleatórios

Ao fazer uso do método `random()` da classe Math em Java, você obterá um número aleatório entre 0,0 e 1,0, ou entre qualquer outro intervalo previamente definido. Ambas as possibilidades serão exploradas pelos exemplos próximos exemplos:

```java
public class Main {
public static void main(String args[]) {
double número aleatório
System.out.println(Math.random());
}
}
```

Um possível resultado para o código acima seria:

```java
0.7488711506123137
```

Se lhe parecer melhor, você também pode limitar os resultados possíveis, permitindo somente números inteiros entre 0 e 100. Para fazer isso, baseie o seu código no exemplo abaixo:

```java
public class Main {
public static void main(String args[]) {
int número aleatório= (int) (Math.random() * 101);
System.out.println(número aleatório);
}
}
```

Se você fizer isso, obterá outra forma de resultado aleatório, como esta:

```java
27
```

## Java Math: Lista dos principais métodos

Inúmeros métodos podem ser combinados à classe Math em Java para a realização de cálculos matemáticos, trigonométricos e outros. Nossa lista apresenta os mais importantes deles, e explica o que cada um é capaz de fazer:

<table>
  <thead>
    <tr>
      <th><strong>Método</strong></th>
      <th><strong>Função</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`abs()`</td>
      <td>Retorna o valor absoluto de um argumento.</td>
    </tr>
    <tr>
      <td>`max()`</td>
      <td>Retorna o maior de dois valores.</td>
    </tr>
    <tr>
      <td>`min()`</td>
      <td>Retorna o menor de dois valores.</td>
    </tr>
    <tr>
      <td>`pow()`</td>
      <td>Retorna o valor de uma potência.</td>
    </tr>
    <tr>
      <td>`sqrt()`</td>
      <td>Calcula uma raiz quadrada.</td>
    </tr>
    <tr>
      <td>`random()`</td>
      <td>Retorna um valor *double* aleatório.</td>
    </tr>
    <tr>
      <td>`cbrt()`</td>
      <td>Calcula uma raiz cúbica.</td>
    </tr>
    <tr>
      <td>`log()`</td>
      <td>Retorna o logaritmo natural de um valor *double*.</td>
    </tr>
    <tr>
      <td>`sin()`</td>
      <td>Calcula o seno de um valor *double*.</td>
    </tr>
    <tr>
      <td>`cos()`</td>
      <td>Calcula o cosseno de um valor *double*.</td>
    </tr>
    <tr>
      <td>`tan()`</td>
      <td>Calcula a tangente de um valor *double*.</td>
    </tr>
    <tr>
      <td>`round()`</td>
      <td>Arredonda um valor *double* em um valor inteiro.</td>
    </tr>
    <tr>
      <td>`negateExact()`</td>
      <td>Retorna o valor oposto de um argumento.</td>
    </tr>
    <tr>
      <td>`floor()`</td>
      <td>Arredonda para baixo o maior valor *double* menor ou igual ao argumento fornecido.</td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-math/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-math/) for AI/LLM consumption.