Questões JavaDoc - Marcos Leonel Bortoli
1) Temperatura
/**
* Classe Temperatura
* Demonstra a declaração de variáveis explícitas e a conversão de
* temperatura de Celsius para Fahrenheit.
*/
public class Temperatura {
/**
* Método principal que executa a conversão e exibe os resultados.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
double celsius = 25.0; // Temperatura em Celsius
double fahrenheit = (celsius * 9 / 5) + 32; // Conversão para Fahrenheit
[Link]("Temperatura em Celsius: " + celsius);
[Link]("Temperatura em Fahrenheit: " + fahrenheit);
}
}
2) Área
/**
* Classe Area
* Demonstra o uso de declaração implícita (var) e cálculo dinâmico da área.
*/
public class Area {
/**
* Método principal que calcula a área de um retângulo e exibe o resultado.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
var largura = 5.0;
var altura = 10.0;
double area = largura * altura;
[Link]("Área: " + area);
}
}
3) Preço com Desconto
/**
* Classe PrecoComDesconto
* Demonstra a aplicação de desconto em um preço original.
*/
public class PrecoComDesconto {
/**
* Método principal que calcula o preço final com desconto de 10%.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
float precoOriginal = 100.0f;
var precoComDesconto = precoOriginal * 0.9;
[Link]("Preço original: " + precoOriginal);
[Link]("Preço com 10% de desconto: " + precoComDesconto);
}
}
4) Soma de Caracteres
/**
* Classe SomaCaracteres
* Demonstra manipulação de caracteres com incremento no valor ASCII.
*/
public class SomaCaracteres {
/**
* Método principal que gera a próxima letra do alfabeto a partir de uma inicial.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
char letra = 'A';
char proximaLetra = (char) (letra + 1);
[Link]("Letra: " + letra);
[Link]("Próxima letra: " + proximaLetra);
}
}
5) Distância em Viagem
/**
* Classe DistanciaViagem
* Calcula a distância percorrida em uma viagem a partir da velocidade média e do tempo.
*/
public class DistanciaViagem {
/**
* Método principal que executa o cálculo da distância.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
double velocidadeMedia = 80.0;
var tempoViagem = 2.5;
var distancia = velocidadeMedia * tempoViagem;
[Link]("Distância percorrida: " + distancia + " km");
}
}
6) Operações Lógicas
/**
* Classe OperacoesLogicas
* Demonstra operações lógicas com variáveis booleanas.
*/
public class OperacoesLogicas {
/**
* Método principal que exibe os resultados de operações booleanas.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
boolean a = true, b = false;
[Link]("a & b: " + (a & b)); // AND lógico
[Link]("a | b: " + (a | b)); // OR lógico
[Link]("a ^ b: " + (a ^ b)); // XOR lógico
[Link]("!a: " + !a); // NOT lógico
}
}
7) Condições com Erro
/**
* Classe CondicoesComErro
* Demonstra o comportamento de curto-circuito nos operadores lógicos
* OR (||) e AND (&&) em expressões que podem causar exceção.
*/
public class CondicoesComErro {
/**
* Método principal que testa expressões lógicas com divisão por zero.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
int x = 10;
// OR lógico evita erro (curto-circuito)
if (x > 5 || (10 / 0 == 0)) {
[Link]("Primeira condição: Verdadeira (não deu erro)");
}
// AND lógico pode gerar erro, pois precisa avaliar ambas as condições
if (x < 5 && (10 / 0 == 0)) {
[Link]("Segunda condição: Verdadeira");
}
}
}
8) Operações Bitwise
/**
* Classe OperacoesBitwise
* Demonstra operações bitwise (AND, OR, XOR) com números inteiros.
*/
public class OperacoesBitwise {
/**
* Método principal que realiza operações de bits e exibe resultados em decimal e binário.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
int num1 = 12, num2 = 7;
[Link]("num1 & num2: " + (num1 & num2));
[Link]("num1 | num2: " + (num1 | num2));
[Link]("num1 ^ num2: " + (num1 ^ num2));
[Link]("num1 (binário): " + [Link](num1));
[Link]("num2 (binário): " + [Link](num2));
}
}
9) Deslocamento de Bits
/**
* Classe DeslocamentoDeBits
* Demonstra operações de deslocamento de bits em inteiros.
*/
public class DeslocamentoDeBits {
/**
* Método principal que aplica <<, >> e >>> e exibe resultados.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
int num = 8;
[Link]("Valor original: " + num + " (" + [Link](num) + ")");
[Link]("num << 2: " + (num << 2) + " (" + [Link](num << 2) + ")")
[Link]("num >> 2: " + (num >> 2) + " (" + [Link](num >> 2) + ")")
[Link]("num >>> 2: " + (num >>> 2) + " (" + [Link](num >>> 2) + "
}
}
10) Login Sistema
/**
* Classe LoginSistema
* Simula o login de um sistema com validação de senha e idade mínima.
*/
public class LoginSistema {
/**
* Método principal que valida o acesso de um usuário.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
boolean senhaValida = true;
int idade = 20;
if (senhaValida && idade >= 18) {
[Link]("Acesso permitido!");
} else {
[Link]("Acesso negado!");
}
}
}
11) Conversão Implícita
/**
* Classe ConversaoImplicit
* Demonstra conversão implícita de tipos numéricos.
*/
public class ConversaoImplicit {
/**
* Método principal que mostra conversão automática de int para double.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
int x = 50;
double y = x;
[Link]("Valor de x: " + x);
[Link]("Valor de y: " + y);
}
}
12) Conversão Explícita
/**
* Classe ConversaoExplicita
* Demonstra conversão explícita (casting) de double para int.
*/
public class ConversaoExplícita {
/**
* Método principal que converte double em int e exibe os valores.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
double nota = 8.75;
int notaInt = (int) nota;
[Link]("Nota original: " + nota);
[Link]("Nota convertida: " + notaInt);
}
}
13) Conversão Long para Int
/**
* Classe ConversaoLongInt
* Demonstra a conversão de long para int, com possível perda de dados.
*/
public class ConversaoLongInt {
/**
* Método principal que converte um long para int e exibe os valores.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
long numeroGrande = 123456789123L;
int numeroPequeno = (int) numeroGrande;
[Link]("Número grande: " + numeroGrande);
[Link]("Número pequeno: " + numeroPequeno);
}
}
14) Conversão de Caracteres
/**
* Classe ConversaoDeCaracteres
* Demonstra conversão de um caractere em valor numérico e vice-versa.
*/
import [Link];
public class ConversaoDeCaracteres {
/**
* Método principal que lê um caractere e converte para int e de volta para char.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
[Link]("Digite uma letra: ");
char letra = [Link]().charAt(0);
int valorNumerico = (int) letra;
char letraConvertida = (char) valorNumerico;
[Link]("Valor numérico da letra: " + valorNumerico);
[Link]("Letra convertida de volta: " + letraConvertida);
}
}
15) Soma Tipos Diferentes
/**
* Classe SomaTiposDiferentes
* Demonstra soma de variáveis de tipos diferentes sem casting explícito.
*/
public class SomaTiposDiferentes {
/**
* Método principal que soma int e double e exibe o resultado.
*
* @param args argumentos da linha de comando (não utilizados)
*/
public static void main(String[] args) {
int a = 5;
double b = 2.5;
double resultado = a + b;
[Link]("Resultado da soma: " + resultado);
}
}