Aprenda Java em 10 minutos

9 July 2025 — Linguagem De Programação

Java é uma linguagem de programação orientada a objetos de alto nível conhecida por seu princípio “escreva uma vez, execute em qualquer lugar”. Este tutorial cobre recursos do Java 21+, ajudando você a aprender rapidamente os fundamentos do Java.

1. Escrevendo seu primeiro programa Java

Os programas Java são organizados em classes. Vamos começar com um programa simples. Crie um arquivo chamado HelloWorld.java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Compile e execute o programa:

javac HelloWorld.java
java HelloWorld

A saída será:

Hello, World!

Este programa simples demonstra a estrutura básica do Java. Todo programa Java deve ter pelo menos uma classe, e o método main é o ponto de entrada.

2. Sintaxe Básica

A sintaxe Java é estruturada e segue regras específicas:

// Este é um comentário de linha única
/* Este é um
   comentário multilinha */

public class BasicSyntax {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

Regras básicas de sintaxe em Java:

Sensibilidade a maiúsculas: Java é sensível a maiúsculas. Variable e variable são diferentes.
Nomes de classes: Devem começar com uma letra maiúscula e seguir a convenção CamelCase.
Nomes de métodos: Devem começar com uma letra minúscula e seguir a convenção camelCase.
Ponto e vírgula: Toda instrução deve terminar com ponto e vírgula ;.
Chaves: Blocos de código são definidos usando chaves {}.
Comentários: Comentários de linha única usam //, comentários multilinha usam /* */.

3. Variáveis e Tipos de Dados

Java é uma linguagem estaticamente tipada, o que significa que você deve declarar os tipos de variáveis explicitamente.

Regras de nomenclatura de variáveis:

Deve começar com uma letra, sublinhado _, ou sinal de dólar $.
Pode conter letras, dígitos, sublinhados e sinais de dólar.
Não pode ser palavras-chave do Java.
Deve seguir a convenção camelCase.

Tipos de dados primitivos do Java:

byte: inteiro com sinal de 8 bits (-128 a 127)
short: inteiro com sinal de 16 bits (-32,768 a 32,767)
int: inteiro com sinal de 32 bits (-2^31 a 2^31-1)
long: inteiro com sinal de 64 bits (-2^63 a 2^63-1)
float: ponto flutuante de 32 bits
double: ponto flutuante de 64 bits
boolean: true ou false
char: caractere Unicode de 16 bits

public class DataTypes {
    public static void main(String[] args) {
        // Tipos inteiros
        byte age = 25;
        short year = 2024;
        int population = 1000000;
        long distance = 93000000L; // sufixo L para long
        
        // Tipos de ponto flutuante
        float temperature = 36.5f; // sufixo f para float
        double pi = 3.14159265359;
        
        // Booleano e caractere
        boolean isActive = true;
        char grade = 'A';
        
        // String (tipo de referência)
        String name = "Alice";
        
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

3.1 Operações com Strings

Strings em Java são objetos, não tipos primitivos:

public class StringExample {
    public static void main(String[] args) {
        String text = "Java Programming";
        
        System.out.println("Length: " + text.length());
        System.out.println("Uppercase: " + text.toUpperCase());
        System.out.println("Lowercase: " + text.toLowerCase());
        System.out.println("Character at index 0: " + text.charAt(0));
        System.out.println("Substring: " + text.substring(0, 4));
        System.out.println("Contains 'Java': " + text.contains("Java"));
        
        // Concatenação de strings
        String greeting = "Hello, " + "World!";
        System.out.println(greeting);
        
        // Formatação de strings
        String formatted = String.format("Pi is approximately %.2f", 3.14159);
        System.out.println(formatted);
    }
}

4. Arrays e Coleções

4.1 Arrays

Arrays armazenam múltiplos valores do mesmo tipo:

public class ArrayExample {
    public static void main(String[] args) {
        // Declaração e inicialização de array
        int[] numbers = {1, 2, 3, 4, 5};
        String[] fruits = new String[3];
        fruits[0] = "apple";
        fruits[1] = "banana";
        fruits[2] = "orange";
        
        // Acessando elementos do array
        System.out.println("First number: " + numbers[0]);
        System.out.println("Array length: " + numbers.length);
        
        // Iterando através de arrays
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Number " + i + ": " + numbers[i]);
        }
        
        // Loop for aprimorado (for-each)
        for (String fruit : fruits) {
            System.out.println("Fruit: " + fruit);
        }
        
        // Arrays multidimensionais
        int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
        System.out.println("Matrix element [1][1]: " + matrix[1][1]);
    }
}

4.2 Coleções

O Java Collections Framework fornece estruturas de dados dinâmicas:

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // ArrayList (array dinâmico)
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.remove("Bob");
        System.out.println("Names: " + names);
        
        // HashMap (pares chave-valor)
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 35);
        System.out.println("Alice's age: " + ages.get("Alice"));
        
        // HashSet (elementos únicos)
        HashSet<Integer> uniqueNumbers = new HashSet<>();
        uniqueNumbers.add(1);
        uniqueNumbers.add(2);
        uniqueNumbers.add(2); // Duplicado, não será adicionado
        uniqueNumbers.add(3);
        System.out.println("Unique numbers: " + uniqueNumbers);
        
        // Iterando através de coleções
        for (String name : names) {
            System.out.println("Name: " + name);
        }
        
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

5. Operações e Operadores

Java fornece vários operadores para diferentes operações:

Operadores Aritméticos: +, -, *, /, % (módulo), ++ (incremento), -- (decremento)
Operadores de Comparação: ==, !=, >, <, >=, <=
Operadores Lógicos: && (e), || (ou), ! (não)
Operadores Bit a Bit: &, |, ^, ~, <<, >>, >>>
Operadores de Atribuição: =, +=, -=, *=, /=, %=

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        // Operações aritméticas
        System.out.println("Addition: " + (a + b));
        System.out.println("Subtraction: " + (a - b));
        System.out.println("Multiplication: " + (a * b));
        System.out.println("Division: " + (a / b));
        System.out.println("Modulus: " + (a % b));
        
        // Incremento e decremento
        System.out.println("Pre-increment: " + (++a));
        System.out.println("Post-decrement: " + (b--));
        
        // Operações de comparação
        System.out.println("Equal: " + (a == b));
        System.out.println("Not equal: " + (a != b));
        System.out.println("Greater than: " + (a > b));
        
        // Operações lógicas
        boolean x = true, y = false;
        System.out.println("AND: " + (x && y));
        System.out.println("OR: " + (x || y));
        System.out.println("NOT: " + (!x));
        
        // Operações de atribuição
        int c = 5;
        c += 3; // c = c + 3
        System.out.println("After += 3: " + c);
    }
}

6. Fluxo de Controle

6.1 Declarações Condicionais

public class ConditionalExample {
    public static void main(String[] args) {
        int score = 85;
        
        // declaração if-else
        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
        
        // Operador ternário
        String result = (score >= 60) ? "Pass" : "Fail";
        System.out.println("Result: " + result);
        
        // declaração switch
        char grade = 'B';
        switch (grade) {
            case 'A':
                System.out.println("Excellent!");
                break;
            case 'B':
                System.out.println("Good!");
                break;
            case 'C':
                System.out.println("Average");
                break;
            default:
                System.out.println("Invalid grade");
        }
    }
}

6.2 Loops

public class LoopExample {
    public static void main(String[] args) {
        // loop for
        System.out.println("For loop:");
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration: " + i);
        }
        
        // Loop for aprimorado (for-each)
        System.out.println("\nFor-each loop:");
        int[] numbers = {1, 2, 3, 4, 5};
        for (int num : numbers) {
            System.out.println("Number: " + num);
        }
        
        // loop while
        System.out.println("\nWhile loop:");
        int count = 0;
        while (count < 3) {
            System.out.println("Count: " + count);
            count++;
        }
        
        // loop do-while
        System.out.println("\nDo-while loop:");
        int x = 0;
        do {
            System.out.println("X: " + x);
            x++;
        } while (x < 3);
        
        // break e continue
        System.out.println("\nBreak and continue:");
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Sair do loop
            }
            if (i % 2 == 0) {
                continue; // Pular números pares
            }
            System.out.println("Odd number: " + i);
        }
    }
}

7. Métodos (Funções)

Métodos em Java são funções que pertencem a classes:

public class MethodExample {
    
    // Método sem parâmetros e sem valor de retorno
    public static void greet() {
        System.out.println("Hello, World!");
    }
    
    // Método com parâmetros e valor de retorno
    public static int add(int a, int b) {
        return a + b;
    }
    
    // Método com múltiplos parâmetros
    public static String formatName(String firstName, String lastName) {
        return firstName + " " + lastName;
    }
    
    // Sobrecarga de método (mesmo nome, parâmetros diferentes)
    public static int multiply(int a, int b) {
        return a * b;
    }
    
    public static double multiply(double a, double b) {
        return a * b;
    }
    
    // Argumentos variáveis (varargs)
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    public static void main(String[] args) {
        greet();
        
        int result = add(5, 3);
        System.out.println("Addition result: " + result);
        
        String fullName = formatName("John", "Doe");
        System.out.println("Full name: " + fullName);
        
        System.out.println("Multiply integers: " + multiply(4, 5));
        System.out.println("Multiply doubles: " + multiply(2.5, 3.0));
        
        System.out.println("Sum of multiple numbers: " + sum(1, 2, 3, 4, 5));
    }
}

8. Programação Orientada a Objetos

8.1 Classes e Objetos

public class Person {
    // Variáveis de instância (campos)
    private String name;
    private int age;
    private String email;
    
    // Construtor
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    // Construtor padrão
    public Person() {
        this("Unknown", 0, "");
    }
    
    // Métodos getter
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getEmail() {
        return email;
    }
    
    // Métodos setter
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        }
    }
    
    public void setEmail(String email) {
        this.email = email;
    }
    
    // Método de instância
    public void introduce() {
        System.out.println("Hi, I'm " + name + ", " + age + " years old.");
    }
    
    // Método com lógica
    public boolean isAdult() {
        return age >= 18;
    }
    
    // Método toString (sobrescrevendo o toString do Object)
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", email='" + email + "'}";
    }
    
    public static void main(String[] args) {
        // Criando objetos
        Person person1 = new Person("Alice", 25, "[email protected]");
        Person person2 = new Person();
        
        // Usando métodos
        person1.introduce();
        System.out.println("Is adult: " + person1.isAdult());
        
        person2.setName("Bob");
        person2.setAge(17);
        person2.setEmail("[email protected]");
        
        System.out.println(person1.toString());
        System.out.println(person2.toString());
    }
}

Este tutorial Java abrangente cobre os conceitos essenciais necessários para começar com programação Java. A tipagem forte da linguagem, recursos orientados a objetos e extensa biblioteca padrão a tornam poderosa para construir aplicações robustas. Pratique esses exemplos e experimente com o código para aprofundar sua compreensão dos conceitos de programação Java.