No Java, para realizar cálculos matemáticos, usamos a classe Math, que é uma classe para cálculos matemáticos.
Os operadores são os mesmos da maioria das linguagens, adição (+), subtração(-), multiplicação(*), divisão (/) e módulo(%).
Para exemplificar, vamos criar uma nova aplicação Java com classe principal. Veja um exemplo:
int n1 = 3;
int n2 = 5;
float m = (n1 + n2) / 2;
System.out.println("A média entre as notas é de " + m);
PS: O resultado deverá ser em float, se for int, o Java dará erro.
Vamos fazer com Java Swing agora, com duas caixas de textos, para dividir números. Após você desenhar as caixas de texto, faça um código desse tipo no evento do botão:
int n = Integer.parseInt(txtNum.getText());
int d = Integer.parseInt(txtDem.getText());
int div = n / d;
int res = n % d;
lblDiv.setText(Integer.toString(div));
lblRes.setText(Integer.toString(res));
Os operadores unários também são usados em Java (por ser herança do C), que são o pré e pós incremento e decremento.
Nesse caso, o pós-incremento funcionou melhor:
int numero = 5;
numero++;
System.out.println(numero);
Já nesse caso, funcionou melhor o pré-incremento:
int numero = 5;
int valor = 5 + ++numero;
System.out.println(valor);
PS: O mesmo vale para decremento.
Também usamos os operadores de atribuição, que nada mais são do que os operadores aritméticos seguidos do igual. Para fazer incrementos e decrementos com mais de 1, usamos os operadores de adição e subtração com atribuição. Veja um exemplo:
int x = 4;
x += 2;
System.out.println(x);
A operação acima pode ser feita com qualquer valor numérico e com qualquer operador aritmético.
No Java também podemos fazer exponenciações como raiz quadrada e coisas do tipo. Para usar isso em Java, usamos a classe Math, que possuí constantes e métodos internos para realizar cálculos matemáticos (por exemplo, o PI).
| Valor | Significado | Exemplo de uso | Retorno |
|---|---|---|---|
| PI | Constante π | Math.PI | 3.141592653589793 |
| pow | Exponenciação | Math.pow(5, 2) | 25 |
| sqrt | Raiz Quadrada | Math.sqrt(25) | 5 |
| cbrt | Raiz Cúbica | Math.cbrt(27) | 3 |
| abs | Valor Absoluto | Math.abs(-10) | 10 |
| floor | Arredondamento para baixo | Math.floor(3.9) | 3 |
| ceil | Arredondamento para cima | Math.ceil(4.2) | 5 |
| round | Arredondamento aritmeticamente | Math.round(5.6) | 6 |
Vamos utilizar alguns valores em Java Swing para calcular raiz quadrada, assim:
int n = Integer.parseInt(txtNum.getText());
float res = (float)Math.sqrt(n);
lblRes.setText(Float.toString(res));
Pode ver nesse caso que foi necessário typecast.
Vamos criar um exemplo de arredondamento em Java no terminal, assim:
float v = 8.9f;
int ar = (int)Math.round(v);
System.out.println(ar);
O Java também tem suporte à geradores de números, no caso dele, usamos o método Math.random(), que gerará um número entre 0 e 1. Veja um exemplo que ele gerará números decimais aleatórios:
double ale = Math.random();
System.out.println(ale);
Mas você também pode usar esse método com outros números, colocando os números que você vai trabalhar, multiplicando depois do random (por exemplo, 5 e 10, subtraindo em ordem decrescente), e depois de tudo, coloca o menor número pra somar. Veja o exemplo:
Exemplo simples:
double ale = Math.random() * (10 - 5) + 5; // Primeiro número gerará o intervalo e o segundo é o mínimo.
System.out.println(ale);
Ou, simplificando, também gerará números entre 5 e 10, que serão arredondados pra inteiros:
double ale = Math.random() * 5 + 5; // O primeiro 5 seria o mesmo que (10 - 5).
int n = (int)Math.round(ale);
System.out.println(n);
Convertendo pra inteiro:
double ale = Math.random();
int n = (int)Math.round(ale * (2000 - 20) + 20);
System.out.println(n);
Podemos também usar um objeto Random pra isso (pra isso importe java.util.Random):
Random aleatorio = new Random(); // Importe java.util.Random.
int num = aleatorio.nextInt(5); // Gerará números de 0 a 4.
System.out.println(num);
Para gerar números de 1 a 5:
int num = aleatorio.nextInt(5) + 1;
Para gerar números de 12 a 14:
int num = aleatorio.nextInt(3) + 12;
Ou seja, dentro do método nextInt, colocamos o intervalo (contando o mínimo), e a soma é o mínimo.
Se quiser verificar se um valor numérico retorna NaN (não numérico), podemos utilizar o método isNaN(), veja um exemplo simples de uso:
Scanner teclado = new Scanner(System.in, "CP1252");
int num;
double raiz;
System.out.print("Digite um número pra ver a raiz: ");
num = teclado.nextInt();
raiz = !Double.isNaN(Math.sqrt(num)) ? Math.sqrt(num) : 0.0; // Isso é um operador ternário, que verifica dados.
System.out.println("A raiz quadrada de " + num + " é " + raiz);
Podemos também converter números decimais para octal, hexadecimais e binários, e vice-versa:
Scanner teclado = new Scanner(System.in, "CP1252");
System.out.print("Digite o número em decimal: ");
int num = teclado.nextInt();
String binario = Integer.toBinaryString(num); // Converte Decimal para Binário
String hexa = Integer.toHexString(num).toUpperCase(); // Converte Decimal para Hexadecimal
String octal = Integer.toOctalString(num); // Converte Decimal para Octal
System.out.println(num + " convertido para binário: " + binario);
System.out.println(num + " convertido para octal: " + octal);
System.out.println(num + " convertido para hexadecimal: " + hexa);
// Convertendo novamente para decimal:
int decimal1 = Integer.parseInt(binario, 2); // Converte o Binário pra Decimal
int decimal2 = Integer.parseInt(octal, 8); // Converte o Octal para Decimal
int decimal3 = Integer.parseInt(hexa, 16); // Converte o Hexadecimal para Decimal
System.out.println(binario + " convertido para decimal: " + decimal1);
System.out.println(octal + " convertido para decimal: " + decimal2);
System.out.println(hexa + " convertido para decimal: " + decimal3);
Vamos criar uma calculadora em Swing, que ao informar um valor, mostre o resto da divisão por 2, o cubo, a raiz quadrada, a raiz cúbica e o valor absoluto, tudo ao mesmo tempo. Com fotos e tudo. Veja o código:
int num = (int)inpNum.getValue();
int res = num % 2;
double cub = Math.pow(num, 3);
double rzQ = Math.sqrt(num);
double rzC = Math.cbrt(num);
int abs = Math.abs(num);
lblRes.setText(Integer.toString(res));
lblCub.setText(String.format("%.0f", cub));
lblRzQ.setText(String.format("%.2f", rzQ));
lblRzC.setText(String.format("%.2f", rzC));
lblAbs.setText(Integer.toString(abs));
Assim como o PHP, no Java temos o operador ternário. Veja um exemplo em Java:
int n1 = 10;
int n2 = 5;
int maior = n1 > n2 ? n1 : n2;
System.out.println(maior);
O que está antes da interrogação for verdadeiro, receberá o primeiro valor do lado direito, senão receberá o segundo do lado direito.
Vamos criar um projeto novo, no terminal mesmo, criando a classe principal. Criaremos um exemplo assim:
int n1, n2, r;
n1 = 4;
n2 = 8;
r = n1 > n2 ? 0 : 1;
System.out.println(r);
Também podemos criar fórmulas com ele, assim:
int n1, n2, r;
n1 = 14;
n2 = 8;
r = n1 > n2 ? n1 + n2 : n1 - n2;
System.out.println(r);
Os operadores relacionais são os mesmos da maioria das linguagens:
| Operador Aritmético | Significado |
|---|---|
| == | Igualdade. |
| != | Diferente. |
| > | Maior. |
| < | Menor. |
| >= | Maior ou Igual. |
| <= | Menor ou Igual. |
Num novo projeto de terminal com classe, vamos fazer um novo programa, usando alguns desses operadores:
String nome1 = "Gustavo";
String nome2 = "Gustavo";
String nome3 = new String("Gustavo");
String res;
res = nome1 == nome2 ? "igual" : "diferente";
System.out.println(res);
No caso acima, é um código simples em Java, mas tem um porém, se comparar o mesmo código com o nome3, ele declarará como diferente, já que foi declarada como "new String" (tem a estrutura diferente). Para comparar o conteúdo, usamos o método equals, assim:
String nome1 = "Gustavo";
String nome2 = "Gustavo";
String nome3 = new String("Gustavo");
String res;
res = nome1.equals(nome3) ? "igual" : "diferente";
System.out.println(res);
Sempre que a comparação for de classes (incluindo a String), é preferível usar o método equals.
PS: O construtor new String pode ser usado também pra converter arrays de char em uma string, como no caso de pegar valores de campos de senhas (getPassword()).
No Java também temos operadores lógicos. Só pra relembrar:
| Operador | Operação | Significado |
|---|---|---|
| && | AND | E |
| || | OR | Ou |
| ! | NOT | Não |
| ^ | XOR | Ou Exclusivo |
Relembrando que o XOR (xor ou ou exclusivo), recebe os mesmos valores do OR, menos quando todas as premissas são verdadeiras (pode ser uma coisa ou outra, mas nunca as duas. Ele retorna false pra iguais e true pra diferentes).
Vamos criar um novo projeto com classe principal pra exemplificar:
int x, y, z;
x = 4;
y = 7;
z = 12;
boolean r;
r = x < y && y < z ? true : false;
System.out.println(r);
Simplificando:
int x, y, z;
x = 4;
y = 7;
z = 12;
boolean r;
r = x < y && y < z;
System.out.println(r);
Teste o código acima com outros operadores no lugar dos menores.
Agora faremos uma tela em Swing. Veja o código do Action Perfomed:
int ano = (int)numAn.getValue();
int idade = 2018 - ano; // Prefira pegar o ano do sistema.
lblIdade.setText(Integer.toString(idade));
String sit = idade >= 18 ? "Maior" : "Menor";
lblSit.setText(sit);
As expressões lógicas compostas em Java funcionam de forma simples, vejam um exemplo que pode ser substituído no código acima, pra definir se um voto é obrigatório ou opcional:
String sit = (idade >= 16 && idade < 18 || idade > 70) ? "Opcional" : "Obrigatório";
Mas esse código tem um erro, se colocar uma idade menor que 16, ele mostrará obrigatório, isso será corrigido com estruturas condicionais, que serão vistas mais pra frente.
Vamos fazer um joguinho em Swing, no qual terá um gênio de adivinhação. Ele terá duas imagens, uma com o balão e outra com o gênio, como se ele tivesse falando os resultados.
PS: Para colocar um elemento em cima do outro, clique com o botão direito no layout e em "Definir Layout" e escolha "Layout Absoluto" (o default é Design Livre). Com o botão direito em cima do objeto você poderá ver se ele está acima de outro, e podemos escolher quais ficam na frente e atrás, tal como o Photoscape ou outro editor. A frase pode ser colocada entre tags <html></html> para encaixar dentro do balãozinho, inclusive, pode ser usados outras tags, como pra deixar em negrito ou itálico.
Esse é o código colocado no método do construtor do frame, logo abaixo do initComponents():
initComponents();
lblFrase.setText("<html>Vou pensar em um valor entre <b>1</b> e <b>10</b>.<br/>Tente adivinhar!</html>");
No evento clicar botão, você colocará esse código (não esqueça da importação java.awt.Font):
double n = Math.random() * 10 + 1;
int valor = (int)n;
int num = Integer.parseInt(numVal.getValue().toString());
String f1 = "<html>Acertou!!!</html>";
String f2 = "<html>Errou! Eu pensei no valor <b>" + valor + "</b>.<br/>Tente novamente!</html>";
String res = valor == num ? f1 : f2;
lblFrase.setFont(new Font("Arial Black", Font.PLAIN, 12)); // Exibirá o resultado com outra formatação! Não esqueça da importação.
lblFrase.setText(res);
PS: Antes de testar, pode usar um System.out.print() para ver os números gerados no terminal. Podemos usar outras imagens também.
Como visto acima, podemos também formatar fontes no Java.
Ao compilar o arquivo JAR, veja se não é necessário colocar novamente o layout como "Design Livre", para não ter erros de execução.