6.8. Operadores em Java (aritméticos, lógicos, etc.): Conversão de Tipos (casting)

Página 38

6.8 Operadores em Java: Conversão de Tipos (Casting)

Java é uma linguagem de programação fortemente tipada, o que significa que cada variável deve ser declarada com um tipo de dado específico. Em Java, os operadores desempenham um papel crucial na manipulação desses tipos de dados. Vamos explorar os operadores aritméticos, lógicos e de conversão de tipos (casting) em Java.

Operadores Aritméticos

Os operadores aritméticos são usados para realizar operações matemáticas básicas como adição, subtração, multiplicação e divisão. Eles incluem:

• + (Adição)
• - (Subtração)
• * (Multiplicação)
• / (Divisão)
• % (Módulo - resto da divisão)

Exemplo de uso:

int a = 10;
int b = 5;
int soma = a + b; // soma = 15
int subtracao = a - b; // subtracao = 5
int multiplicacao = a * b; // multiplicacao = 50
int divisao = a / b; // divisao = 2
int modulo = a % b; // modulo = 0

Operadores Lógicos

Os operadores lógicos são usados para realizar operações lógicas, como conjunção (AND), disjunção (OR) e negação (NOT). Eles são amplamente utilizados em estruturas de controle de fluxo, como instruções if e loops. Os operadores lógicos em Java incluem:

• && (AND lógico)
• || (OR lógico)
• ! (NOT lógico)

Exemplo de uso:

boolean verdadeiro = true;
boolean falso = false;
boolean resultadoAND = verdadeiro && falso; // resultadoAND = false
boolean resultadoOR = verdadeiro || falso; // resultadoOR = true
boolean resultadoNOT = !verdadeiro; // resultadoNOT = false

Operadores de Comparação

Operadores de comparação são usados para comparar dois valores. Eles incluem:

• == (Igual a)
• != (Diferente de)
• > (Maior que)
• < (Menor que)
• >= (Maior ou igual a)
• <= (Menor ou igual a)

Exemplo de uso:

int x = 10;
int y = 20;
boolean igual = (x == y); // igual = false
boolean diferente = (x != y); // diferente = true
boolean maiorQue = (x > y); // maiorQue = false
boolean menorQue = (x < y); // menorQue = true
boolean maiorOuIgual = (x >= y); // maiorOuIgual = false
boolean menorOuIgual = (x <= y); // menorOuIgual = true

Conversão de Tipos (Casting)

Em Java, a conversão de tipos (casting) é o processo de converter uma variável de um tipo para outro. Existem dois tipos de casting: implícito (automático) e explícito (manual).

Casting Implícito

O casting implícito ocorre quando o compilador Java automaticamente converte um tipo menor para um tipo maior, sem a necessidade de sintaxe especial. Por exemplo, converter um int para um long:

int meuInt = 100;
long meuLong = meuInt; // casting implícito de int para long

Casting Explícito

O casting explícito é necessário quando precisamos converter um tipo maior para um tipo menor ou quando a conversão não é direta. Isso é feito colocando o tipo desejado entre parênteses antes da variável que estamos convertendo:

double meuDouble = 9.78;
int meuInt = (int) meuDouble; // casting explícito de double para int, meuInt será 9

É importante notar que o casting explícito pode resultar em perda de informação se o tipo para o qual estamos convertendo não puder acomodar o valor original. Por exemplo, converter um double para um int resultará na perda da parte fracionária.

Considerações Finais

Operadores são fundamentais na programação Java, permitindo a execução de operações aritméticas, lógicas e comparações. A conversão de tipos é igualmente crucial, pois permite a manipulação de diferentes tipos de dados de forma eficaz. Ao entender como e quando usar operadores e casting, você poderá desenvolver programas mais robustos e flexíveis.

É essencial praticar e se familiarizar com esses conceitos para se tornar um programador Java competente. Experimente escrever seu próprio código, utilizando operadores e realizando conversões de tipos, para ver esses conceitos em ação.

Siguiente página del libro electrónico gratuito:

397. Controle de fluxo (if, else, switch, loops)