Java Basic Syntax - Guia Completo para

Aprendizado Profundo
Introdução e Contexto de Aprendizagem
Você já compreende os fundamentos de programação por sua formação em Ciência da Computação.
Este material assume esse conhecimento prévio e vai direto aos aspectos específicos de Java, com
ênfase na profundidade necessária para dominar completamente a sintaxe básica.

O [Link] destaca que "Understanding the basics is the key to a solid foundation". Neste
sentido, exploraremos não apenas como fazer algo em Java, mas também por quê a linguagem foi
projetada dessa forma, como ela evoluiu, e quais são as armadilhas que até programadores
experientes enfrentam.

1. Terminologias Fundamentais
1.1 Identificadores (Identifiers)

Definição: Um identificador é um nome que você atribui a variáveis, métodos, classes, pacotes e
outras estruturas do seu programa.

Regras para Identificadores em Java:

1. Começam com letra, underscore ( _ ) ou sinal de dólar ( $ )

✅ myVariable , _privateVar , $dollarVar

❌ 9variable , -invalid

2. Contêm apenas letras, dígitos, underscores e sinais de dólar

✅ userName123 , user_name

❌ user-name , user name

3. São case-sensitive — Total , total e TOTAL são três identificadores diferentes

4. Não podem ser palavras-chave reservadas

 5. Significância prática: Não podem conter hífens ou períodos

Exemplo Prático:

public class IdentifierDemo {

public static void main(String[] args) {
// ✅ Válidos
int myAge = 25;
String _internalName = "Alice";
double $price = 99.99;
boolean isValidUser = true;

// ❌ Inválidos (geram compilação erro)

// int 123invalid = 5; // Começa com número
// String user-name = "Bob"; // Contém hífen
// int class = 10; // Keyword reservada

[Link]("Age: " + myAge);

}
}

1.2 Palavras-Chave Reservadas (Reserved Keywords)

Java possui exatamente 50 palavras-chave e 3 literais que não podem ser usados como
identificadores.

Categorias de Palavras-Chave:

Categoria Palavras-Chave Versão Introduzida

Tipos de Dados byte , short , int , long , float , double , Java 1.0
char , boolean , void

Controle de if , else , switch , case , default , while , Java 1.0

Fluxo do , for , break , continue , return

OOP class , interface , extends , implements , Java 1.0

this , super , new
 Categoria Palavras-Chave Versão Introduzida

Modificadores public , private , protected , static , final , Java 1.0+

abstract , synchronized , volatile ,
transient , native , strictfp

Tratamento de try , catch , finally , throw , throws Java 1.0

Exceções

Pacotes e package , import Java 1.0

Imports

Modernos var (Java 10), sealed (Java 17), records Java 10+
(Java 17)

Não Utilizados goto , const Java 1.0 (reservados,

não implementados)

Três Literais Especiais:

true — valor booleano verdadeiro

false — valor booleano falso

null — representa ausência de valor (referência nula)

⚠️ Armadilha Comum: Confundir null com 0 ou false

String name = null; // ✅ Representa "sem valor"

int count = 0; // ✅ Número zero
boolean isActive = false; // ✅ Booleano falso

// ❌ Isso gera compilação erro:

// int result = null;
// String text = false;

1.3 Comentários

Java suporta três tipos de comentários:

 // Comentário de linha única (single-line comment)

/*
Comentário de múltiplas linhas (multi-line comment)
Pode ocupar várias linhas
*/

/**
* Comentário de documentação (JavaDoc)
* @param args argumentos da linha de comando
* @return descrição do retorno
*/
public static void main(String[] args) {
// ...
}

2. Convenções de Nomes (Naming Conventions)

A comunidade Java segue convenções rígidas de nomenclatura. Seguir essas convenções é essencial
para produzir código legível e manutenível.

Elemento Convenção Exemplos

Classes PascalCase (primeira letra maiúscula) StudentManager , DatabaseConnection

Interfaces PascalCase Comparable , Serializable

Métodos camelCase (primeira palavra calculateTotal() , getUserName()

minúscula)

Variáveis camelCase (primeira palavra studentName , isActive , maxRetries

minúscula)

Constantes UPPER_SNAKE_CASE (todas MAX_ATTEMPTS , PI_VALUE

maiúsculas)

Pacotes minúsculas com pontos [Link] ,

[Link]
Por que isso importa? Essas convenções fazem parte da identidade visual do código Java. Um
desenvolvedor experiente reconhece instantaneamente o tipo de um elemento pela sua nomenclatura.

Exemplo Profissional vs Amador:

// ❌ Amador - Ignora convenções

public class userdbconnection {
private String UN = "admin";
private int MX = 100;

public void getdata() {

// ...
}
}

// ✅ Profissional - Segue convenções

public class UserDatabaseConnection {
private String username = "admin";
private static final int MAX_CONNECTIONS = 100;

public void fetchData() {

// ...
}
}

3. Tipos de Dados Primitivos

Java possui 8 tipos de dados primitivos divididos em 4 categorias. Ao contrário de linguagens como
Python, Java requer declaração explícita de tipo.
3.1 Tipos Integrais (Whole Numbers)

Tipo Tamanho Range Valor Quando Usar

Padrão

byte 1 byte (8 -128 a 127 0 Arrays grandes

bits) (economia de
memória)

short 2 bytes (16 -32.768 a 32.767 0 Dados que cabem

bits) em 2 bytes

int 4 bytes (32 -[Link] a [Link] 0 Padrão para

bits) inteiros

long 8 bytes (64 -[Link].854.775.808 a 0L Números muito

bits) [Link].854.775.807 grandes (ex:
timestamps)

Exemplo Prático:

public class IntegralTypesDemo {

public static void main(String[] args) {
byte age = 25; // OK: 25 < 127
// byte invalid = 200; // ❌ Erro: 200 > 127

short yearOfBirth = 1999; // OK

int population = 7800000000; // ❌ Erro: Muito grande para int

int populationCorrect = 7_800_000; // ✅ OK: Usando underscores para
legibilidade (Java 7+)

long worldPopulation = 7_800_000_000L; // ✅ OK: Sufixo 'L' obrigatório

para long

[Link]("Age: " + age);

[Link]("Population: " + populationCorrect);
}
}
3.2 Tipos Ponto-Flutuante (Decimal Numbers)

Tipo Tamanho Precisão Valor Quando Usar

Padrão

float 4 bytes (32 ~7 dígitos 0.0f Economia de memória, não requer alta
bits) precisão

double 8 bytes (64 ~15 0.0d Padrão para decimais, cálculos

bits) dígitos científicos

Exemplo Prático:

public class FloatingPointDemo {

public static void main(String[] args) {
float price = 19.99f; // Sufixo 'f' obrigatório
double pi = 3.14159265359; // Sem sufixo, double é padrão
double scientificNotation = 1.5e-3; // 0.0015

// ⚠️ Armadilha: Imprecisão em cálculos

double result = 0.1 + 0.2;
[Link](result); // Imprime: 0.30000000000000004

// Solução para situações de alta precisão: BigDecimal

// import [Link];
// BigDecimal preciseResult = new BigDecimal("0.1").add(new
BigDecimal("0.2"));
}
}

3.3 Tipo Caractere (Character)

Tipo Tamanho Range Valor Padrão

char 2 bytes (16 bits) Unicode de 0 a 65.535 (\u0000 a \uffff) '\u0000'

public class CharacterDemo {

public static void main(String[] args) {
char letter = 'A';
 char digit = '5';
char unicode = '\u0048'; // 'H' (Unicode)
char newline = '\n'; // Escape sequence

// Operações com char

char next = (char)(letter + 1); // 'B'

[Link]("Letter: " + letter);

[Link]("Next: " + next);
[Link]("Unicode: " + unicode);
}
}

3.4 Tipo Booleano (Logical)

Tipo Tamanho Valores Valor Padrão

boolean 1 bit true ou false false

public class BooleanDemo {

public static void main(String[] args) {
boolean isJavaFun = true;
boolean isHard = false;

// ❌ Erro comum: Confundir com inteiros

// if (isJavaFun) {
// isJavaFun = 1; // ❌ Erro: 1 não é boolean
// }

// ✅ Correto
if (isJavaFun) {
[Link]("Java é incrível!");
}
}
}
3.5 Tabela Comparativa: Velho vs Moderno

Java 8 (Antigo) - Declaração Explícita de Tipos:

int count = 10;

double price = 19.99;
String name = "Alice";
List<String> names = new ArrayList<>();

Java 10+ (Moderno) - Palavra-Chave var :

var count = 10; // Compilador infere: int

var price = 19.99; // Compilador infere: double
var name = "Alice"; // Compilador infere: String
var names = new ArrayList<String>(); // Compilador infere: List<String>

Quando usar var ?

✅ Quando o tipo é óbvio no lado direito da atribuição

✅ Para código mais conciso
❌ Não use quando o tipo for implícito (dificulta leitura)
❌ Não use em campos de classe (requer tipo explícito)

4. Variáveis e Inicialização
4.1 Declaração e Inicialização

public class VariablesDemo {

// Variáveis de classe (class variables) - inicializadas com valores padrão
private static int classCounter = 0; // Static
private String instanceName = "Default"; // Instance

public void methodVariables() {

// Variáveis locais - devem ser inicializadas antes do uso
int localCounter; // ❌ Não inicializada
 // [Link](localCounter); // Erro de compilação

int initialized = 0; // ✅ Inicializada

[Link](initialized);
}
}

Regra de Ouro: Toda variável local deve ser inicializada antes de seu primeiro uso. Variáveis de
classe recebem valores padrão automaticamente.

4.2 Valores Padrão por Tipo

public class DefaultValuesDemo {

// Valores padrão em campos de classe
private byte byteValue; // 0
private short shortValue; // 0
private int intValue; // 0
private long longValue; // 0L
private float floatValue; // 0.0f
private double doubleValue; // 0.0d
private char charValue; // '\u0000'
private boolean booleanValue; // false
private String stringValue; // null
private Object objectValue; // null

public void printDefaults() {

[Link]("int: " + intValue); // 0
[Link]("String: " + stringValue); // null
[Link]("boolean: " + booleanValue); // false
}
}

5. Arrays
Arrays são coleções de tamanho fixo de elementos do mesmo tipo.
5.1 Declaração e Inicialização

Três formas de criar um array:

public class ArrayDemo {

public static void main(String[] args) {
// Forma 1: Declaração + Alocação
int[] numbers; // Declaração (sem alocação)
numbers = new int[5]; // Alocação (5 zeros)

// Forma 2: Declaração + Inicialização em uma linha

int[] scores = new int[3]; // [0, 0, 0]

// Forma 3: Inicialização com valores (inline)

int[] ages = {25, 30, 28, 35}; // Tamanho inferido: 4

// Forma 4: Com 'new' (verbose, não recomendado)

int[] moreScores = new int[]{10, 20, 30};

// Arrays de referência (objetos)

String[] names = new String[3]; // [null, null, null]
names[0] = "Alice";
names[1] = "Bob";

// Acessando elementos
[Link](ages[0]); // 25
[Link](names[0]); // Alice

// Propriedade length
[Link]([Link]); // 4
}
}

5.2 Arrays Multidimensionais

public class MultiDimensionalArrayDemo {

public static void main(String[] args) {
// Matriz 3x3
 int[][] matrix = new int[3][3];

// Inicialização
int[][] matrix2D = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

// Acessando
[Link](matrix2D[0][0]); // 1
[Link](matrix2D[1][1]); // 5

// Arrays irregulares (colunas diferentes)

int[][] irregular = {
{1, 2},
{3, 4, 5},
{6}
};
}
}

5.3 ⚠️ Armadilhas Comuns com Arrays

Problema 1: Índices começam em 0

int[] data = {10, 20, 30};

// [Link](data[3]); // ❌ ArrayIndexOutOfBoundsException
[Link](data[2]); // ✅ 30 (último elemento)

Problema 2: Não inicializar antes de usar

int[] uninitialized;
// [Link](uninitialized[0]); // ❌ Erro de compilação

Problema 3: Tamanho é imutável

 int[] fixed = new int[5];
// [Link] = 10; // ❌ Erro: length é read-only
// Solução: Usar ArrayList se tamanho dinâmico é necessário

Problema 4: Arrays de objetos apontam para null

String[] names = new String[3];

[Link](names[0]); // null
// [Link](names[0].length()); // ❌ NullPointerException
names[0] = "Alice"; // ✅ Agora é seguro
[Link](names[0].length()); // ✅ 5

6. Expressões, Statements e Blocos

6.1 Expressões (Expressions)

Uma expressão é uma sequência de variáveis, operadores e chamadas de métodos que avalia um
valor.

public class ExpressionDemo {

public static void main(String[] args) {
// Expressões simples
int x = 5;
int y = 2;

int result = x + y; // Expressão: x + y

boolean comparison = (x > y); // Expressão booleana
String concatenation = "Total: " + result; // Expressão com String

// Expressões com side effects

int z = ++x; // Expresssão + atualização
[Link](z); // 6
}
}
6.2 Statements

Um statement é uma unidade de execução completa. Geralmente termina com ponto-e-vírgula.

int age = 25; // Declaration statement

age = 26; // Expression statement
if (age > 18) { // Control flow statement
[Link]("Adulto");
}

6.3 Blocos

Um bloco é um grupo de statements entre chaves {} .

public class BlockDemo {

public static void main(String[] args) {
{ // Bloco aninhado
int localVar = 10;
[Link](localVar);
}
// [Link](localVar); // ❌ Erro: fora do escopo
}
}

7. Operadores
7.1 Operadores Aritméticos

Operador Símbolo Descrição Exemplo

Adição + Soma 5 + 3 = 8

Subtração - Subtrai 5 - 3 = 2

Multiplicação * Multiplica 5 * 3 = 15

Divisão / Divide (inteira se ambos são 5 / 2 = 2 (int), 5.0 / 2 = 2.5

int) (double)
 Operador Símbolo Descrição Exemplo

Módulo % Resto 5 % 2 = 1

public class ArithmeticDemo {

public static void main(String[] args) {
int a = 10, b = 3;

[Link]("Soma: " + (a + b)); // 13

[Link]("Subtração: " + (a - b)); // 7
[Link]("Multiplicação: " + (a * b)); // 30
[Link]("Divisão: " + (a / b)); // 3 (inteira!)
[Link]("Divisão Decimal: " + (a / (double) b)); // 3.333...
[Link]("Módulo: " + (a % b)); // 1
}
}

7.2 Operadores de Atribuição

public class AssignmentDemo {

public static void main(String[] args) {
int x = 10;

x += 5; // x = x + 5 = 15
x -= 3; // x = x - 3 = 12
x *= 2; // x = x * 2 = 24
x /= 4; // x = x / 4 = 6
x %= 5; // x = x % 5 = 1

// Atribuição múltipla
int a = b = c = 5; // c = 5, b = 5, a = 5
}
}
7.3 Operadores Relacionais

Operador Descrição Resultado

== Igual a Booleano

!= Diferente de Booleano

> Maior que Booleano

< Menor que Booleano

>= Maior ou igual Booleano

<= Menor ou igual Booleano

public class RelationalDemo {

public static void main(String[] args) {
int x = 5;

[Link](x == 5); // true

[Link](x != 5); // false
[Link](x > 3); // true
[Link](x >= 5); // true
}
}

7.4 Operadores Lógicos

Operador Símbolo Descrição Exemplo

AND (E lógico) && Ambas verdadeiras true && true = true

OR (OU lógico) \|\| Pelo menos uma verdadeira true \|\| false = true

NOT (NÃO lógico) ! Inverte booleano !true = false

public class LogicalDemo {

public static void main(String[] args) {
boolean a = true, b = false;

[Link](a && b); // false (AND)

 [Link](a || b); // true (OR)
[Link](!a); // false (NOT)

// Short-circuit evaluation
if (false && expensiveOperation()) {
// expensiveOperation() nunca é chamado!
}
}

static boolean expensiveOperation() {

[Link]("Executado");
return true;
}
}

7.5 Operadores Unários

public class UnaryDemo {

public static void main(String[] args) {
int x = 5;

// Incremento e Decremento
[Link](x++); // 5 (pós-incremento)
[Link](x); // 6

[Link](++x); // 7 (pré-incremento)
[Link](x); // 7

[Link](x--); // 7 (pós-decremento)
[Link](x); // 6

// Diferença prática
int[] arr = {10, 20, 30};
int result1 = arr[x++]; // arr[6], depois x = 7
int result2 = arr[++x]; // x = 8, depois arr[8] ❌ IndexOutOfBounds
}
}
7.6 Operador Ternário (Condicional)

public class TernaryDemo {

public static void main(String[] args) {
int age = 20;
String status = (age >= 18) ? "Adulto" : "Menor";
[Link](status); // Adulto

// Nested (use com cuidado)

int score = 85;
String grade = (score >= 90) ? "A" : (score >= 80) ? "B" : "C";
[Link](grade); // B
}
}

8. Controle de Fluxo
8.1 Declaração If-Else

public class IfElseDemo {

public static void main(String[] args) {
int age = 20;

// If simples
if (age >= 18) {
[Link]("Você é adulto");
}

// If-Else
if (age < 13) {
[Link]("Criança");
} else if (age < 18) {
[Link]("Adolescente");
} else {
[Link]("Adulto");
}
 }
}

8.2 Declaração Switch

Java 8 e anterior:

public class SwitchOld {

public static void main(String[] args) {
String day = "MONDAY";
int dayNumber;

switch (day) {
case "MONDAY":
dayNumber = 1;
break; // ⚠️ Obrigatório!
case "TUESDAY":
dayNumber = 2;
break;
default:
dayNumber = 0;
}

[Link](dayNumber);
}
}

Java 17+ (Modern - Switch Expressions):

public class SwitchModern {

public static void main(String[] args) {
String day = "MONDAY";

// Switch como expressão (sem necessidade de break)

int dayNumber = switch (day) {
case "MONDAY" -> 1;
case "TUESDAY" -> 2;
 case "WEDNESDAY" -> 3;
case "THURSDAY" -> 4;
case "FRIDAY" -> 5;
case "SATURDAY", "SUNDAY" -> 0; // Múltiplos casos
};

[Link](dayNumber); // 1

// Switch com blocos de código

String type = switch (dayNumber) {
case 1, 2, 3, 4, 5 -> "Weekday";
case 0 -> "Weekend";
default -> "Invalid";
};

[Link](type); // Weekday
}
}

Vantagens do Switch Moderno:

✅ Sem necessidade de break

✅ Pode ser usado como expressão (retorna valor)

✅ Suporta múltiplos casos na mesma linha
✅ Mais seguro (compiler avisa se não há cobertura completa)

8.3 Loops

For Loop:

public class ForLoopDemo {

public static void main(String[] args) {
// For tradicional
for (int i = 0; i < 5; i++) {
[Link]("i: " + i);
}
 // For-each (enhanced for loop)
String[] fruits = {"Maçã", "Banana", "Laranja"};
for (String fruit : fruits) {
[Link](fruit);
}

// Loop com arrays bidimensionais

int[][] matrix = {{1, 2}, {3, 4}};
for (int[] row : matrix) {
for (int val : row) {
[Link](val + " ");
}
[Link]();
}
}
}

While Loop:

public class WhileLoopDemo {

public static void main(String[] args) {
int count = 0;
while (count < 3) {
[Link]("Count: " + count);
count++;
}

// Do-while (executa pelo menos uma vez)

int num = 0;
do {
[Link]("Num: " + num);
num++;
} while (num < 3);
}
}

Break e Continue:
 public class BreakContinueDemo {
public static void main(String[] args) {
// Break - sai do loop
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // Para quando i == 5
}
[Link](i); // 0, 1, 2, 3, 4
}

// Continue - pula iteração

for (int i = 0; i < 5; i++) {
if (i == 2) {
continue; // Pula i == 2
}
[Link](i); // 0, 1, 3, 4
}
}
}

9. Input e Output (I/O)

9.1 Output: [Link]()

public class OutputDemo {

public static void main(String[] args) {
// println - imprime + quebra linha
[Link]("Olá, Java!");

// print - imprime sem quebra linha

[Link]("Nome: ");
[Link]("Alice");
[Link](); // Quebra linha

// String concatenation
String name = "Bob";
 int age = 30;
[Link]("Nome: " + name + ", Idade: " + age);

// String formatting (Java 5+)

[Link]("Nome: %s, Idade: %d\n", name, age);

// Text Blocks (Java 15+) - para strings multilinha

String json = """
{
"nome": "Alice",
"idade": 25
}
""";
[Link](json);
}
}

9.2 Input: Scanner

Quando usar: Interface moderna, fácil de usar, quebra entrada em tokens.

import [Link];

public class ScannerDemo {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

// Ler String
[Link]("Digite seu nome: ");
String name = [Link](); // Lê linha inteira

// Ler inteiro
[Link]("Digite sua idade: ");
int age = [Link]();

// Ler decimal
[Link]("Digite sua altura: ");
double height = [Link]();
 // Ler booleano
[Link]("É ativo? ");
boolean isActive = [Link]();

// Métodos úteis
if ([Link]()) {
int number = [Link]();
}

// Fechar scanner (importante!)

[Link]();

[Link]("\n--- Dados Capturados ---");

[Link]("Nome: " + name);
[Link]("Idade: " + age);
[Link]("Altura: " + height);
[Link]("Ativo: " + isActive);
}
}

9.3 Input: BufferedReader

Quando usar: Quando performance é crítica (lê strings mais rápido), ou para leitura de arquivos.

import [Link].*;

public class BufferedReaderDemo {

public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(
new InputStreamReader([Link])
);

// Ler linha (String)

[Link]("Digite seu nome: ");
String name = [Link]();

// Para ler números, é preciso converter

 [Link]("Digite sua idade: ");
int age = [Link]([Link]());

// Fechar leitor
[Link]();

[Link]("Nome: " + name);

[Link]("Idade: " + age);
}
}

9.4 Comparação: Scanner vs BufferedReader

Aspecto Scanner BufferedReader

Performance Mais lento (parsing) Mais rápido

Facilidade de Uso Muito fácil Requer conversão manual

Métodos Disponíveis nextInt(), nextDouble(), nextLine() readLine() apenas

Quando Usar Input interativo simples Leitura em lote, arquivos

Manejo de Exceções Não obrigatório Obrigatório (IOException)

Recomendação: Use Scanner para aplicações simples e BufferedReader quando performance

importa.

10. Comparação: Java Antigo vs Moderno

10.1 Inicialização de Dados

Java 8 (Antigo):

public class Person {

private final String name;
private final int age;

public Person(String name, int age) {

[Link] = name;
 [Link] = age;
}

public String getName() { return name; }

public int getAge() { return age; }

@Override
public String toString() {
return "Person{" + "name='" + name + '\'' +
", age=" + age + '}';
}
}

Java 17 (Moderno) - Records:

public record Person(String name, int age) {}

// Automaticamente gera: constructor, getters, toString(), equals(), hashCode()

10.2 Type Inference

Java 8:

List<String> names = new ArrayList<String>();

StringBuilder sb = new StringBuilder();

Java 10+:

var names = new ArrayList<String>();

var sb = new StringBuilder();

10.3 String Concatenation

Java 8:
 String json = "{" +
"\"name\": \"Alice\"," +
"\"age\": 25" +
"}";

Java 15+:

String json = """

{
"name": "Alice",
"age": 25
}
""";

10.4 Pattern Matching para instanceof

Java 8:

Object obj = "Hello";

if (obj instanceof String) {
String str = (String) obj; // Cast necessário
[Link]([Link]());
}

Java 16+:

Object obj = "Hello";

if (obj instanceof String str) { // Pattern matching
[Link]([Link]());
}
11. Boas Práticas (Best Practices)
1. Sempre feche recursos (Scanner, BufferedReader, etc.)

try (Scanner scanner = new Scanner([Link])) {

// Use scanner aqui
} // Fecha automaticamente

2. Siga convenções de nomenclatura — isso melhora legibilidade

3. Inicialize todas as variáveis locais antes de usá-las

4. Use final para constantes

private static final int MAX_ATTEMPTS = 3;

5. Evite números mágicos — use constantes significativas

// ❌ Ruim
if (age > 18) { ... }

// ✅ Bom
if (age > LEGAL_AGE) { ... }

6. Use var sensatamente — apenas quando o tipo for óbvio

7. Prefira for-each quando iterando coleções

// ❌ Antigo
for (int i = 0; i < [Link](); i++) { ... }

// ✅ Moderno
for (Item item : list) { ... }
12. Armadilhas Comuns (Pitfalls) - Resumido

Armadilha Problema Solução

Missing semicolon int x = 5 Sempre terminar statements com

;

Confundir == com equals() "a" == "b" compara Usar .equals() para Strings
referência

NullPointerException Acessar atributo de null Verificar antes: if (obj != null)

ArrayIndexOutOfBounds arr[[Link]] Lembrar que índices vão de 0 a

length-1

Imprecisão em Float 0.1 + 0.2 != 0.3 Usar BigDecimal para precisão

Não fechar Scanner Resource leak Usar try-with-resources ou

.close()

Atribuição em lugar de if (x = 5) Usar == : if (x == 5)

comparação

Esquecer break no switch Fall-through indesejado Sempre adicionar break (ou usar
switch moderno)

13. Checklist de Domínio

Você pode considerar que domina completamente "Basic Syntax" quando consegue fazer tudo isso
sem consultar documentação:

Explicar a diferença entre identificadores e keywords

Listar os 50 keywords e 3 literals de Java

Nomear elementos (classes, métodos, variáveis) seguindo convenções

Declarar e usar os 8 tipos de dados primitivos corretamente

Calcular o range de cada tipo integral e saber quando usá-lo

Diferenciar float de double e saber riscos de imprecisão

Criar arrays uni e multidimensionais e evitar IndexOutOfBoundsException

Trabalhar com valores padrão de cada tipo

 Usar operadores aritméticos, relacionais e lógicos corretamente

Implementar if-else e loops sem erros

Usar switch (antigo) e switch expressions (moderno) conforme versão

Ler e escrever entrada/saída com Scanner e BufferedReader

Entender diferenças entre versões de Java (8 vs 17+)

Reconhecer e evitar as armadilhas mais comuns

Aplicar boas práticas em todo código que escreve

14. Exercícios de Fixação

Exercício 1: Validação de Identificadores

Classifique cada um como válido ou inválido. Se inválido, explique por quê.

a) int myVariable = 10;

b) int 123variable = 5;
c) String _private_name = "test";
d) boolean isActive$ = true;
e) int class = 100;
f) double user-price = 19.99;
g) char $symbol = '@';

Solução:

a) ✅ Válido

b) ❌ Começa com número

c) ✅ Válido (underscore permitido)

d) ✅ Válido ($ permitido)

e) ❌ class é keyword

f) ❌ Hífen não permitido

g) ✅ Válido
Exercício 2: Tipos de Dados

Qual é o tipo mais apropriado para armazenar:

a) A idade de uma pessoa

b) O saldo de uma conta bancária
c) Uma letra do alfabeto
d) Se um usuário está ativo ou não
e) Coordenadas de latitude/longitude
f) A população mundial

Solução:

a) int ou byte (byte se economizar é crítico)

b) double ou melhor BigDecimal

c) char

d) boolean

e) double

f) long

Exercício 3: Arrays e Loops

Escreva código que:

1. Cria um array de 5 inteiros

2. Preenche com valores 10, 20, 30, 40, 50

3. Imprime cada valor em uma linha separada

4. Calcula e imprime a soma

 public class ArrayExercise {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};

int sum = 0;
for (int num : numbers) {
[Link](num);
sum += num;
}

[Link]("Soma: " + sum); // 150

}
}

Exercício 4: Scanner e Input

Escreva um programa que:

1. Pede ao usuário para digitar seu nome

2. Pede a idade

3. Pede a altura

4. Imprime um resumo formatado

import [Link];

public class UserInputExercise {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

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

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

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

double height = [Link]();
 [Link]();

[Link]("\n--- Dados ---");

[Link]("Nome: %s\nIdade: %d\nAltura: %.2f m\n", name, age, height);
}
}

Exercício 5: Operadores e Lógica

Escreva código que determina a categoria de um IMC:

IMC < 18.5: Abaixo do peso

18.5 ≤ IMC < 25: Peso normal

25 ≤ IMC < 30: Sobrepeso

IMC ≥ 30: Obeso

Cálculo: IMC = peso (kg) / (altura (m))²

import [Link];

public class BMICalculator {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

[Link]("Peso (kg): ");

double weight = [Link]();

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

double height = [Link]();

[Link]();

double bmi = weight / (height * height);

String category = (bmi < 18.5) ? "Abaixo do peso" :

(bmi < 25) ? "Peso normal" :
 (bmi < 30) ? "Sobrepeso" :
"Obeso";

[Link]("IMC: %.2f - %s\n", bmi, category);

}
}

Exercício 6: Switch Expressions (Java 17+)

Reescreva o exercício anterior usando switch expressions:

import [Link];

public class BMICalculatorModern {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

[Link]("Peso (kg): ");

double weight = [Link]();

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

double height = [Link]();

[Link]();

double bmi = weight / (height * height);

String category = 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";
};

[Link]("IMC: %.2f - %s\n", bmi, category);

}
 }

15. Pequenos Projetos para Praticar

Projeto 1: Calculadora Simples

Crie uma calculadora que:

Lê dois números

Lê uma operação (+, -, *, /)

Realiza a operação

Imprime o resultado

Projeto 2: Gerenciador de Notas

Crie um programa que:

Pede a quantidade de notas

Lê as notas em um array

Calcula média, máxima e mínima

Imprime relatório

Projeto 3: Jogo da Adivinhação

Crie um jogo que:

Gera um número aleatório 1-100

O usuário tenta adivinhar

Feedback "maior" ou "menor"

Conta tentativas

Parabeniza ao acertar
Projeto 4: Conversor de Temperaturas

Crie um programa que:

Converte Celsius para Fahrenheit

Converte Fahrenheit para Celsius

Usa menu (switch) para escolher operação

Valida entrada

Projeto 5: Gerenciador de Tabuada

Crie um programa que:

Pede um número de 1 a 10

Imprime sua tabuada (1-10)

Pergunta se deseja outra

Usa loop para múltiplas tabuadas

Conclusão
Dominar Java Basic Syntax não é apenas memorizar sintaxe — é entender por quê a linguagem
funciona dessa forma e como evitar armadilhas comuns.

Você agora tem:

✅ Compreensão profunda de cada elemento

✅ Comparações práticas entre versões (8 vs 17+)
✅ Conhecimento de boas práticas profissionais
✅ Consciência de armadilhas e como evitá-las
✅ Exercícios para consolidar aprendizado
✅ Pequenos projetos para praticar

O próximo passo é aplicar esses conceitos em projetos reais e explorar estruturas de controle mais
avançadas (métodos, classes, OOP).
Sucesso em sua jornada Java! 🚀