Java Basic Syntax - Exemplos Práticos

Completos
Tabela de Referência Rápida
Tipos de Dados Primitivos

Tipo Tamanho Range Exemplo Wrapper

byte 1 byte -128 a 127 byte b = 100; Byte

short 2 bytes -32.768 a 32.767 short s = 1000; Short

int 4 bytes ±2.1B int i = 100000; Integer

long 8 bytes ±9.2E18 long l = 100000L; Long

float 4 bytes ~7 dígitos float f = 3.14f; Float

double 8 bytes ~15 dígitos double d = 3.14159; Double

char 2 bytes 0-65535 char c = 'A'; Character

boolean 1 bit true/false boolean b = true; Boolean

Exemplo 1: Programa Completo de Cálculo IMC

import [Link];

public class BMICalculatorComplete {

// Constantes (boas práticas)

private static final double UNDERWEIGHT_LIMIT = 18.5;
private static final double NORMAL_LIMIT = 25.0;
private static final double OVERWEIGHT_LIMIT = 30.0;
public static void main(String[] args) {
// Input
Scanner scanner = new Scanner([Link]);

[Link]("=== Calculadora de IMC ===");

[Link]("Peso (kg): ");
double weight = [Link]();

[Link]("Altura (metros): ");

double height = [Link]();

[Link]();

// Processing
double bmi = calculateBMI(weight, height);
String category = determineBMICategory(bmi);

// Output
[Link]("\nResultado:\n");
[Link]("IMC: %.2f\n", bmi);
[Link]("Categoria: %s\n", category);

// Recomendação
if (bmi > OVERWEIGHT_LIMIT) {
[Link]("⚠️ Considere consultar um médico.");
} else {
[Link]("✅ Você está na faixa saudável!");
}
}

// Método auxiliar para calcular IMC

private static double calculateBMI(double weight, double height) {
return weight / (height * height);
}

// Método auxiliar para determinar categoria

private static String determineBMICategory(double bmi) {
return switch ((int) bmi) {
 case 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 ->
"Abaixo do peso";
case 19, 20, 21, 22, 23, 24 ->
"Peso normal";
case 25, 26, 27, 28, 29 ->
"Sobrepeso";
default ->
"Obeso";
};
}
}

Exemplo 2: Trabalhando com Arrays

import [Link];
import [Link];

public class GradeCalculator {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Quantas notas? ");

int quantityOfGrades = [Link]();

// Criando array
double[] grades = new double[quantityOfGrades];

// Preenchendo array
for (int i = 0; i < [Link]; i++) {
[Link]("Nota %d: ", i + 1);
grades[i] = [Link]();
}

[Link]();
 // Processando dados
double average = calculateAverage(grades);
double max = findMax(grades);
double min = findMin(grades);

// Exibindo resultados
[Link]("\n=== Relatório ===");
[Link]("Notas: %s\n", [Link](grades));
[Link]("Média: %.2f\n", average);
[Link]("Máxima: %.2f\n", max);
[Link]("Mínima: %.2f\n", min);
[Link]("Aprovado: %s\n", average >= 6.0 ? "SIM" : "NÃO");
}

private static double calculateAverage(double[] grades) {

double sum = 0;
for (double grade : grades) {
sum += grade;
}
return sum / [Link];
}

private static double findMax(double[] grades) {

double max = grades[0];
for (double grade : grades) {
if (grade > max) {
max = grade;
}
}
return max;
}

private static double findMin(double[] grades) {

double min = grades[0];
for (double grade : grades) {
if (grade < min) {
min = grade;
}
 }
return min;
}
}

Exemplo 3: Jogo da Adivinhação

import [Link];
import [Link];

public class GuessNumberGame {

private static final int MIN_NUMBER = 1;

private static final int MAX_NUMBER = 100;
private static final int MAX_ATTEMPTS = 10;

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);
Random random = new Random();

boolean playAgain = true;

while (playAgain) {
playGame(scanner, random);

[Link]("Deseja jogar novamente? (s/n): ");

String response = [Link]().toLowerCase();
playAgain = [Link]("s") || [Link]("sim");
}

[Link]();
[Link]("Obrigado por jogar! Até logo!");
}

private static void playGame(Scanner scanner, Random random) {

int secretNumber = [Link](MAX_NUMBER - MIN_NUMBER + 1) + MIN_NUMBER;
 int attempts = 0;
int guess = -1;

[Link]("\n=== Jogo da Adivinhação ===");

[Link]("Adivinhe um número entre %d e %d\n", MIN_NUMBER,
MAX_NUMBER);

while (guess != secretNumber && attempts < MAX_ATTEMPTS) {

[Link]("Seu palpite: ");

// Validação de entrada
if (![Link]()) {
[Link]("❌ Por favor, digite um número inteiro!");
[Link](); // Limpar buffer
continue;
}

guess = [Link]();
[Link](); // Limpar newline
attempts++;

// Validação de range
if (guess < MIN_NUMBER || guess > MAX_NUMBER) {
[Link]("⚠️ O número deve estar entre %d e %d\n",
MIN_NUMBER, MAX_NUMBER);
continue;
}

// Feedback
if (guess < secretNumber) {
[Link]("🔼 O número é MAIOR!");
} else if (guess > secretNumber) {
[Link]("🔽 O número é MENOR!");
} else {
[Link]("🎉 Parabéns! Você acertou em %d tentativas!\n",
attempts);
}
}
 // Se não adivinhou
if (guess != secretNumber) {
[Link]("😞 Game Over! O número era %d\n", secretNumber);
}
}
}

Exemplo 4: Conversão de Temperatura

import [Link];

public class TemperatureConverter {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);
boolean continueProgram = true;

while (continueProgram) {
displayMenu();
int choice = getMenuChoice(scanner);

switch (choice) {
case 1 -> celsiusToFahrenheit(scanner);
case 2 -> fahrenheitToCelsius(scanner);
case 3 -> continueProgram = false;
default -> [Link]("❌ Opção inválida!");
}
}

[Link]();
[Link]("Até logo!");
}

private static void displayMenu() {

[Link]("\n=== Conversor de Temperatura ===");
 [Link]("1. Celsius → Fahrenheit");
[Link]("2. Fahrenheit → Celsius");
[Link]("3. Sair");
}

private static int getMenuChoice(Scanner scanner) {

[Link]("Escolha uma opção: ");
if ([Link]()) {
return [Link]();
} else {
[Link](); // Limpar entrada inválida
return -1;
}
}

private static void celsiusToFahrenheit(Scanner scanner) {

[Link]("Digite a temperatura em Celsius: ");
if ([Link]()) {
double celsius = [Link]();
double fahrenheit = (celsius * 9/5) + 32;
[Link]("%.2f°C = %.2f°F\n", celsius, fahrenheit);
} else {
[Link]("❌ Entrada inválida!");
[Link]();
}
}

private static void fahrenheitToCelsius(Scanner scanner) {

[Link]("Digite a temperatura em Fahrenheit: ");
if ([Link]()) {
double fahrenheit = [Link]();
double celsius = (fahrenheit - 32) * 5/9;
[Link]("%.2f°F = %.2f°C\n", fahrenheit, celsius);
} else {
[Link]("❌ Entrada inválida!");
[Link]();
}
}
 }

Exemplo 5: Gerenciador de Tabuada

import [Link];

public class MultiplicationTableManager {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("=== Gerenciador de Tabuada ===");

boolean continueProgram = true;

while (continueProgram) {
[Link]("Digite um número (1-10) ou 0 para sair: ");

if (![Link]()) {
[Link]("❌ Digite um número inteiro!");
[Link]();
continue;
}

int number = [Link]();

if (number == 0) {
continueProgram = false;
} else if (number >= 1 && number <= 10) {
printMultiplicationTable(number);
} else {
[Link]("❌ Digite um número entre 1 e 10!");
}
}

[Link]();
 [Link]("Obrigado por usar o programa!");
}

private static void printMultiplicationTable(int number) {

[Link]("\n=== Tabuada de %d ===\n", number);

for (int i = 1; i <= 10; i++) {

int result = number * i;
[Link]("%d x %2d = %3d\n", number, i, result);
}
}
}

Exemplo 6: Validador de Dados

import [Link];

public class DataValidator {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("=== Validador de Dados ===");

// Coletar dados
[Link]("Nome: ");
String name = [Link]();

[Link]("Idade: ");
int age = readValidAge(scanner);

[Link]("Email: ");
String email = [Link]();

[Link]("Salário: ");
double salary = readValidSalary(scanner);
 [Link]();

// Validar
boolean isValid = validateData(name, age, email, salary);

// Exibir resultado
if (isValid) {
[Link]("\n✅ Dados válidos!");
[Link]("Nome: %s\nIdade: %d\nEmail: %s\nSalário: R$ %.2f\n",
name, age, email, salary);
} else {
[Link]("\n❌ Dados inválidos!");
}
}

private static int readValidAge(Scanner scanner) {

while (true) {
if ([Link]()) {
int age = [Link]();
if (age >= 0 && age <= 150) {
[Link](); // Consumir newline
return age;
} else {
[Link]("Idade deve estar entre 0 e 150. Tente novamente:
");
}
} else {
[Link]("Digite um número inteiro válido: ");
[Link]();
}
}
}

private static double readValidSalary(Scanner scanner) {

while (true) {
if ([Link]()) {
double salary = [Link]();
 if (salary >= 0) {
[Link](); // Consumir newline
return salary;
} else {
[Link]("Salário não pode ser negativo. Tente novamente:
");
}
} else {
[Link]("Digite um valor decimal válido: ");
[Link]();
}
}
}

private static boolean validateData(String name, int age, String email, double
salary) {
// Validar nome (não vazio)
if (name == null || [Link]().isEmpty()) {
[Link](" - Nome não pode estar vazio");
return false;
}

// Validar idade
if (age < 18) {
[Link](" - Idade mínima é 18 anos");
return false;
}

// Validar email (simples check)

if (![Link]("@")) {
[Link](" - Email inválido (deve conter @)");
return false;
}

// Validar salário
if (salary < 1412.0) { // Salário mínimo brasileiro
[Link](" - Salário abaixo do mínimo legal");
return false;
 }

return true;
}
}

Comparação de Sintaxes (Java 8 vs Java 17+)

String Concatenation

Java 8:

String result = "Nome: " + name +

"\nIdade: " + age +
"\nEmail: " + email;

Java 15+:

String result = """

Nome: %s
Idade: %d
Email: %s
""".formatted(name, age, email);

Switch Statement

Java 8:

String dayType;
switch (day) {
case "SATURDAY":
case "SUNDAY":
dayType = "Weekend";
break;
case "MONDAY":
case "TUESDAY":
 case "WEDNESDAY":
case "THURSDAY":
case "FRIDAY":
dayType = "Weekday";
break;
default:
dayType = "Unknown";
}

Java 17+:

String dayType = switch (day) {

case "SATURDAY", "SUNDAY" -> "Weekend";
case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> "Weekday";
default -> "Unknown";
};

Instance Check

Java 8:

if (obj instanceof String) {

String str = (String) obj;
[Link]([Link]());
}

Java 16+:

if (obj instanceof String str) {

[Link]([Link]());
}
Dicas Profissionais de Debug
1. Usando Print Statements

[Link]("Debug: valor de x = " + x);

[Link]("Debug: x=%d, y=%d\n", x, y);

2. Verificando Nulls

if (str == null) {
[Link]("String é null!");
} else {
[Link]("String: " + str);
}

3. Verificando Array Bounds

[Link]("Array length: " + [Link]);

for (int i = 0; i < [Link]; i++) {
[Link]("arr[%d] = %d\n", i, arr[i]);
}

4. Try-Catch para Input

try {
int value = [Link]([Link]());
[Link]("Valor: " + value);
} catch (NumberFormatException e) {
[Link]("Erro: entrada não é um número");
}
Checklist de Implementação
Antes de considerar um programa "pronto", verifique:

Todas as variáveis são inicializadas antes de usar

Todos os loops têm condição de saída

Entrada do usuário é validada

Recursos (Scanner, BufferedReader) são fechados

Mensagens de erro são informativas

Código segue convenções de nomenclatura

Constantes estão em UPPER_CASE

Métodos têm responsabilidade única

Sem números mágicos (use constantes)

Código é legível e bem indentado

Estrutura Recomendada para Programas

import [Link];

/**
* Descrição breve do programa
* @author Seu Nome
* @version 1.0
*/
public class NomeDoProgramaPrincipal {

// Constantes (se houver)

private static final int CONSTANTE = 100;

/**
* Método principal - ponto de entrada
*/
public static void main(String[] args) {
// 1. Input
 Scanner scanner = new Scanner([Link]);
// Ler dados...

// 2. Processing
// Processar dados...

// 3. Output
// Exibir resultados...

// 4. Cleanup
[Link]();
}

/**
* Método auxiliar - descrever função
* @param param descrição do parâmetro
* @return descrição do retorno
*/
private static void metodoAuxiliar(int param) {
// Implementação
}
}

Este documento complementa o guia principal e fornece código pronto para usar e adaptar.