Tutorial Completo de Java: Guia Definitivo

Admin

Tutorial Completo de Java: Guia Definitivo para Iniciantes e Desenvolvedores Aprenda Java do zero com este tutorial completo. Inclui instalação, palavras reservadas, exemplo MVC, comandos essenciais. Java, tutorial Java, aprender Java, programação Java, palavras reservadas Java, MVC Java, comandos Java, JDK, VSCode, GitHub, desenvolvimento Java

Introdução ao Java

Java é uma linguagem de programação orientada a objetos, de alto nível, robusta e segura, desenvolvida pela Sun Microsystems (agora parte da Oracle) em 1995. É uma das linguagens mais populares do mundo, utilizada em uma vasta gama de aplicações, desde desenvolvimento web e mobile (Android) até sistemas empresariais complexos e big data.

Principais características do Java:

Orientada a Objetos: Tudo em Java é um objeto (exceto tipos primitivos), facilitando a modelagem do mundo real.
Plataforma Independente (Write Once, Run Anywhere - WORA): O código Java é compilado para bytecode, que pode ser executado em qualquer máquina que possua a Java Virtual Machine (JVM).
Robusta: Possui gerenciamento automático de memória (Garbage Collection) e um forte sistema de tratamento de exceções.
Segura: Oferece recursos de segurança integrados para proteger contra código malicioso.
Multithread: Suporta a execução de múltiplas tarefas simultaneamente.
Vasta Biblioteca Padrão (API): Oferece uma rica coleção de classes e métodos para diversas tarefas comuns.
Grande Comunidade e Ecossistema: Possui uma comunidade ativa e um vasto ecossistema de ferramentas, frameworks e bibliotecas.

Este tutorial guiará você desde a instalação do ambiente de desenvolvimento até a compreensão dos conceitos fundamentais e a criação de um exemplo prático usando o padrão MVC.

Instalação do Java, VSCode e GitHub

Instalação do Java Development Kit (JDK)

O JDK (Java Development Kit) é necessário para desenvolver aplicações em Java. Existem várias distribuições disponíveis, sendo as mais comuns o Oracle JDK e o OpenJDK.

Windows

Instalação do Oracle JDK

Acesse o site oficial de downloads do Java: https://www.oracle.com/java/technologies/downloads/
Selecione a versão do JDK (recomendamos a versão LTS mais recente, como JDK 21 ou JDK 24)
Clique na opção "Windows" para baixar o instalador (.exe ou .msi)
Execute o arquivo baixado
Siga as instruções do assistente de instalação
Após a instalação, configure as variáveis de ambiente:
- Abra o Painel de Controle > Sistema > Configurações avançadas do sistema
- Clique em "Variáveis de Ambiente"
- Em "Variáveis do Sistema", clique em "Novo"
- Nome da variável: JAVA_HOME
- Valor da variável: Caminho para a pasta de instalação do JDK (ex: C:\Program Files\Java\jdk-21)
- Edite a variável "Path" e adicione %JAVA_HOME%\bin
Verifique a instalação abrindo o Prompt de Comando e digitando:
```
java --version
```

Instalação do OpenJDK

Acesse o site do OpenJDK: https://openjdk.org/install/
Baixe a versão para Windows
Extraia o arquivo ZIP para uma pasta (ex: C:\Program Files\Java\)
Configure as variáveis de ambiente como descrito acima

macOS

Usando Homebrew (recomendado)

Abra o Terminal

Instale o Homebrew (se ainda não estiver instalado):

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Instale o JDK:
```
brew install openjdk@21
```
Siga as instruções exibidas no terminal para configurar as variáveis de ambiente

Instalação Manual

Acesse o site oficial de downloads do Java: https://www.oracle.com/java/technologies/downloads/
Selecione a versão do JDK
Clique na opção "macOS" para baixar o instalador (.dmg ou .pkg)
Execute o arquivo baixado
Siga as instruções do assistente de instalação
Verifique a instalação abrindo o Terminal e digitando:
```
java --version
```

Linux

Ubuntu/Debian

Abra o Terminal
Atualize os repositórios:
```
sudo apt update
```
Instale o OpenJDK:
```
sudo apt install openjdk-21-jdk
```
Verifique a instalação:
```
java --version
```

Fedora/Red Hat

Abra o Terminal
Instale o OpenJDK:
```
sudo dnf install java-21-openjdk-devel
```
Verifique a instalação:
```
java --version
```

Instalação do Visual Studio Code

Windows

Acesse o site oficial do VSCode: https://code.visualstudio.com/download
Clique no botão "Windows" para baixar o instalador (.exe)
Execute o arquivo baixado
Siga as instruções do assistente de instalação
Durante a instalação, recomendamos marcar as opções:
- "Adicionar ao PATH"
- "Adicionar 'Abrir com Code' ao menu de contexto"
- "Registrar Code como editor para tipos de arquivo suportados"

macOS

Acesse o site oficial do VSCode: https://code.visualstudio.com/download
Clique no botão "Mac" para baixar o instalador (.zip)
Extraia o arquivo baixado
Mova o aplicativo Visual Studio Code para a pasta Aplicativos
Abra o VSCode a partir da pasta Aplicativos ou da Launchpad

Linux

Ubuntu/Debian

Acesse o site oficial do VSCode: https://code.visualstudio.com/download
Baixe o pacote .deb
Instale o pacote:
```
sudo apt install ./nome-do-arquivo.deb
```

Configuração do VSCode para Desenvolvimento Java

Instalação do Extension Pack para Java

Abra o VSCode
Clique no ícone de extensões na barra lateral (ou pressione Ctrl+Shift+X)
Pesquise por "Extension Pack for Java"
Clique em "Instalar"

Este pacote inclui as seguintes extensões essenciais:

Language Support for Java™ by Red Hat
Debugger for Java
Test Runner for Java
Maven for Java
Project Manager for Java
Visual Studio IntelliCode

Instalação do GitHub Desktop

Windows

Acesse o site oficial do GitHub Desktop: https://desktop.github.com/
Clique em "Download for Windows"
Execute o arquivo baixado
Siga as instruções do assistente de instalação
Faça login com sua conta GitHub ou crie uma nova

macOS

Acesse o site oficial do GitHub Desktop: https://desktop.github.com/
Clique em "Download for macOS"
Extraia o arquivo baixado
Mova o aplicativo GitHub Desktop para a pasta Aplicativos
Abra o GitHub Desktop a partir da pasta Aplicativos
Faça login com sua conta GitHub ou crie uma nova

Linux

O GitHub Desktop oficial não está disponível para Linux, mas você pode usar o Git diretamente pelo terminal ou instalar alternativas como GitKraken ou GitAhead.

Para instalar o Git no Linux:

sudo apt update
sudo apt install git  # Ubuntu/Debian

sudo dnf install git  # Fedora/Red Hat

As Palavras Reservadas do Java

Java possui 53 palavras-chave reservadas que não podem ser usadas como identificadores (nomes de variáveis, classes, métodos, etc.). Vamos explicar as principais com exemplos simples e claros.

1. abstract

Usado para declarar classes abstratas e métodos abstratos. Classes abstratas não podem ser instanciadas e métodos abstratos não têm implementação.

// Classe abstrata
abstract class Animal {
    // Método abstrato (sem implementação)
    abstract void fazerSom();
    
    // Método concreto (com implementação)
    void dormir() {
        System.out.println("ZzZzZz...");
    }
}

// Classe concreta que estende a classe abstrata
class Cachorro extends Animal {
    // Implementação obrigatória do método abstrato
    void fazerSom() {
        System.out.println("Au au!");
    }
}

2. boolean

Tipo de dado primitivo que armazena valores verdadeiro (true) ou falso (false).

boolean estaChovendo = true;
boolean temSol = false;

if (estaChovendo) {
    System.out.println("Leve um guarda-chuva!");
} else if (temSol) {
    System.out.println("Use protetor solar!");
}

3. break

Usado para sair de loops (for, while, do-while) ou blocos switch.

// Uso em um loop
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // Sai do loop quando i for igual a 5
    }
    System.out.println(i);
}

// Uso em um switch
int opcao = 2;
switch (opcao) {
    case 1:
        System.out.println("Opção 1 selecionada");
        break;
    case 2:
        System.out.println("Opção 2 selecionada");
        break;
    default:
        System.out.println("Opção inválida");
}

4. class

Usado para definir uma classe, que é a estrutura básica para criar objetos.

public class Pessoa {
    // Atributos
    String nome;
    int idade;
    
    // Construtor
    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }
    
    // Método
    public void apresentar() {
        System.out.println("Olá, meu nome é " + nome + " e tenho " + idade + " anos.");
    }
}

5. extends

Usado para indicar que uma classe herda de outra classe.

// Classe pai
class Veiculo {
    String marca;
    
    void acelerar() {
        System.out.println("Veículo acelerando");
    }
}

// Classe filha que herda de Veiculo
class Carro extends Veiculo {
    int numeroDePortas;
    
    void ligarArCondicionado() {
        System.out.println("Ar condicionado ligado");
    }
}

6. final

Usado para declarar constantes, impedir herança de classes ou sobrescrita de métodos.

// Constante
final double PI = 3.14159;

// Classe que não pode ser herdada
final class Configuracao {
    // Método que não pode ser sobrescrito
    final void metodoImportante() {
        System.out.println("Este método não pode ser alterado");
    }
}

7. if-else

Usado para execução condicional.

int temperatura = 30;

if (temperatura > 30) {
    System.out.println("Está muito quente!");
} else if (temperatura > 20) {
    System.out.println("Está agradável.");
} else {
    System.out.println("Está frio.");
}

8. implements

Usado para indicar que uma classe implementa uma interface.

// Definição da interface
interface Nadador {
    void nadar();
}

interface Corredor {
    void correr();
}

// Classe que implementa múltiplas interfaces
class Atleta implements Nadador, Corredor {
    @Override
    public void nadar() {
        System.out.println("Atleta nadando");
    }
    
    @Override
    public void correr() {
        System.out.println("Atleta correndo");
    }
}

9. import

Usado para importar classes, interfaces ou pacotes.

// Importando uma classe específica
import java.util.ArrayList;

// Importando todas as classes de um pacote
import java.util.*;

public class ExemploImport {
    public static void main(String[] args) {
        ArrayList lista = new ArrayList<>();
        lista.add("Item 1");
        System.out.println(lista);
    }
}

10. interface

Usado para declarar uma interface, que é um contrato que as classes devem seguir.

// Definição da interface
interface Veiculo {
    void acelerar(int velocidade);
    void frear();
    String obterMarca();
}

// Classe que implementa a interface
class Carro implements Veiculo {
    private String marca;
    
    public Carro(String marca) {
        this.marca = marca;
    }
    
    @Override
    public void acelerar(int velocidade) {
        System.out.println("Carro acelerando a " + velocidade + " km/h");
    }
    
    @Override
    public void frear() {
        System.out.println("Carro freando");
    }
    
    @Override
    public String obterMarca() {
        return marca;
    }
}

Estas são apenas algumas das 53 palavras-chave do Java. Outras palavras-chave importantes incluem: public, private, protected, static, void, new, try, catch, throw, throws, for, while, do, switch, case, default, return, this, super, package, synchronized, volatile, transient, instanceof, enum, assert, entre outras.

Exemplo de Aplicação MVC em Java

O padrão MVC (Model-View-Controller) é uma arquitetura de software que separa a aplicação em três componentes principais:

Model: Gerencia os dados e a lógica de negócios
View: Apresenta os dados ao usuário
Controller: Processa as entradas do usuário e coordena o Model e a View

Vamos criar um exemplo simples de uma aplicação MVC em Java para gerenciar uma lista de tarefas.

Estrutura de Diretórios

projeto-mvc-java/
├── src/
│   ├── model/
│   │   └── Task.java
│   ├── view/
│   │   └── TaskView.java
│   ├── controller/
│   │   └── TaskController.java
│   └── Main.java

Passo 1: Criando o Model

Primeiro, vamos criar o modelo que representa uma tarefa:

src/model/Task.java

package model;

import java.time.LocalDateTime;

/**
 * Classe que representa uma tarefa no sistema.
 */
public class Task {
    private int id;
    private String title;
    private String description;
    private boolean completed;
    private LocalDateTime createdAt;
    
    /**
     * Construtor para criar uma nova tarefa.
     * 
     * @param id Identificador único da tarefa
     * @param title Título da tarefa
     * @param description Descrição detalhada da tarefa
     */
    public Task(int id, String title, String description) {
        this.id = id;
        this.title = title;
        this.description = description;
        this.completed = false;
        this.createdAt = LocalDateTime.now();
    }
    
    // Getters e Setters
    
    public int getId() {
        return id;
    }
    
    public String getTitle() {
        return title;
    }
    
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getDescription() {
        return description;
    }
    
    public void setDescription(String description) {
        this.description = description;
    }
    
    public boolean isCompleted() {
        return completed;
    }
    
    public void setCompleted(boolean completed) {
        this.completed = completed;
    }
    
    public LocalDateTime getCreatedAt() {
        return createdAt;
    }
    
    @Override
    public String toString() {
        return "Task [id=" + id + ", title=" + title + ", completed=" + completed + "]";
    }
}

src/model/TaskManager.java

package model;

import java.util.ArrayList;
import java.util.List;

/**
 * Classe responsável por gerenciar a coleção de tarefas.
 * Implementa a lógica de negócios relacionada às tarefas.
 */
public class TaskManager {
    private List tasks;
    private int nextId;
    
    /**
     * Construtor que inicializa a lista de tarefas vazia.
     */
    public TaskManager() {
        this.tasks = new ArrayList<>();
        this.nextId = 1;
    }
    
    /**
     * Adiciona uma nova tarefa à lista.
     * 
     * @param title Título da tarefa
     * @param description Descrição da tarefa
     * @return A tarefa criada
     */
    public Task addTask(String title, String description) {
        Task newTask = new Task(nextId++, title, description);
        tasks.add(newTask);
        return newTask;
    }
    
    /**
     * Retorna todas as tarefas.
     * 
     * @return Lista de tarefas
     */
    public List getAllTasks() {
        return new ArrayList<>(tasks); // Retorna uma cópia da lista
    }
    
    /**
     * Busca uma tarefa pelo ID.
     * 
     * @param id ID da tarefa
     * @return A tarefa encontrada ou null se não existir
     */
    public Task getTaskById(int id) {
        for (Task task : tasks) {
            if (task.getId() == id) {
                return task;
            }
        }
        return null;
    }
    
    /**
     * Marca uma tarefa como concluída.
     * 
     * @param id ID da tarefa
     * @return true se a tarefa foi encontrada e atualizada, false caso contrário
     */
    public boolean markTaskAsCompleted(int id) {
        Task task = getTaskById(id);
        if (task != null) {
            task.setCompleted(true);
            return true;
        }
        return false;
    }
    
    /**
     * Remove uma tarefa da lista.
     * 
     * @param id ID da tarefa a ser removida
     * @return true se a tarefa foi removida, false caso contrário
     */
    public boolean removeTask(int id) {
        Task task = getTaskById(id);
        if (task != null) {
            tasks.remove(task);
            return true;
        }
        return false;
    }
}

Passo 2: Criando a View

Agora, vamos criar a view que exibirá as tarefas:

src/view/TaskView.java

package view;

import model.Task;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Scanner;

/**
 * Classe responsável pela interface com o usuário.
 * Exibe informações e coleta entradas do usuário.
 */
public class TaskView {
    private Scanner scanner;
    private DateTimeFormatter formatter;
    
    /**
     * Construtor que inicializa o scanner para entrada de dados.
     */
    public TaskView() {
        this.scanner = new Scanner(System.in);
        this.formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");
    }
    
    /**
     * Exibe o menu principal da aplicação.
     * 
     * @return A opção escolhida pelo usuário
     */
    public int showMainMenu() {
        System.out.println("\n===== GERENCIADOR DE TAREFAS =====");
        System.out.println("1. Listar todas as tarefas");
        System.out.println("2. Ver detalhes de uma tarefa");
        System.out.println("3. Adicionar nova tarefa");
        System.out.println("4. Marcar tarefa como concluída");
        System.out.println("5. Remover tarefa");
        System.out.println("0. Sair");
        System.out.print("\nEscolha uma opção: ");
        
        try {
            return Integer.parseInt(scanner.nextLine());
        } catch (NumberFormatException e) {
            return -1; // Retorna opção inválida
        }
    }
    
    /**
     * Exibe todas as tarefas.
     * 
     * @param tasks Lista de tarefas a serem exibidas
     */
    public void displayAllTasks(List tasks) {
        if (tasks.isEmpty()) {
            System.out.println("\nNenhuma tarefa encontrada.");
            return;
        }
        
        System.out.println("\n===== LISTA DE TAREFAS =====");
        for (Task task : tasks) {
            String status = task.isCompleted() ? "[✓]" : "[ ]";
            System.out.printf("%s #%d: %s%n", status, task.getId(), task.getTitle());
        }
    }
    
    // Outros métodos da view...
}

Passo 3: Criando o Controller

Agora, vamos criar o controller que coordenará o model e a view:

src/controller/TaskController.java

package controller;

import model.Task;
import model.TaskManager;
import view.TaskView;
import java.util.List;

/**
 * Classe responsável por coordenar as interações entre o Model e a View.
 * Processa as entradas do usuário e atualiza o Model e a View conforme necessário.
 */
public class TaskController {
    private TaskManager taskManager;
    private TaskView taskView;
    
    /**
     * Construtor que inicializa o controller com o model e a view.
     * 
     * @param taskManager O gerenciador de tarefas (model)
     * @param taskView A interface com o usuário (view)
     */
    public TaskController(TaskManager taskManager, TaskView taskView) {
        this.taskManager = taskManager;
        this.taskView = taskView;
    }
    
    /**
     * Inicia a aplicação e processa as interações do usuário.
     */
    public void run() {
        boolean running = true;
        
        while (running) {
            int choice = taskView.showMainMenu();
            
            switch (choice) {
                case 1:
                    listAllTasks();
                    break;
                case 2:
                    showTaskDetails();
                    break;
                case 3:
                    addNewTask();
                    break;
                case 4:
                    markTaskAsCompleted();
                    break;
                case 5:
                    removeTask();
                    break;
                case 0:
                    running = false;
                    taskView.showSuccessMessage("Aplicação encerrada.");
                    taskView.close();
                    break;
                default:
                    taskView.showErrorMessage("Opção inválida. Tente novamente.");
                    taskView.pressEnterToContinue();
            }
        }
    }
    
    // Métodos para implementar as operações do menu...
}

Passo 4: Criando a Classe Principal

Finalmente, vamos criar a classe principal que inicializa e executa a aplicação:

src/Main.java

import controller.TaskController;
import model.TaskManager;
import view.TaskView;

/**
 * Classe principal que inicializa e executa a aplicação.
 */
public class Main {
    public static void main(String[] args) {
        // Inicializa o Model
        TaskManager taskManager = new TaskManager();
        
        // Adiciona algumas tarefas de exemplo
        taskManager.addTask("Estudar Java", "Aprender os conceitos básicos de Java e programação orientada a objetos");
        taskManager.addTask("Entender o padrão MVC", "Compreender como implementar o padrão Model-View-Controller em Java");
        taskManager.addTask("Criar um projeto", "Desenvolver um projeto prático usando os conhecimentos adquiridos");
        
        // Inicializa a View
        TaskView taskView = new TaskView();
        
        // Inicializa o Controller
        TaskController taskController = new TaskController(taskManager, taskView);
        
        // Inicia a aplicação
        System.out.println("Iniciando o Gerenciador de Tarefas...");
        taskController.run();
    }
}

Explicação do Padrão MVC neste Exemplo

1. Model (Modelo)

O Model representa os dados e a lógica de negócios da aplicação. Neste exemplo, temos:

Task.java: Representa uma tarefa individual com seus atributos e comportamentos.
TaskManager.java: Gerencia uma coleção de tarefas e implementa a lógica de negócios relacionada às tarefas.

O Model não tem conhecimento sobre a View ou o Controller. Ele é independente da interface do usuário e apenas gerencia os dados e a lógica de negócios.

2. View (Visão)

A View é responsável pela interface com o usuário. Neste exemplo, temos:

TaskView.java: Exibe informações ao usuário e coleta entradas.

A View não tem conhecimento direto sobre o Model. Ela apenas exibe os dados que recebe do Controller e envia as entradas do usuário de volta para o Controller.

3. Controller (Controlador)

O Controller coordena as interações entre o Model e a View. Neste exemplo, temos:

TaskController.java: Processa as entradas do usuário, atualiza o Model e solicita atualizações da View.

O Controller conhece tanto o Model quanto a View. Ele recebe entradas da View, processa essas entradas (possivelmente atualizando o Model) e atualiza a View conforme necessário.

Benefícios do Padrão MVC

Separação de Responsabilidades: Cada componente tem uma função específica, o que torna o código mais organizado e fácil de manter.
Reutilização de Código: Os componentes podem ser reutilizados em diferentes partes da aplicação ou em outras aplicações.
Facilidade de Manutenção: Alterações em um componente têm impacto mínimo nos outros componentes.
Testabilidade: Os componentes podem ser testados isoladamente, facilitando a criação de testes unitários.
Desenvolvimento Paralelo: Diferentes desenvolvedores podem trabalhar em diferentes componentes simultaneamente.

Comandos para Criar, Rodar e Compilar Programas Java

Este guia apresenta os comandos essenciais para criar, compilar e executar programas Java, tanto pela linha de comando quanto pelo Visual Studio Code.

Comandos Básicos da Linha de Comando

1. Verificar a Instalação do Java

Antes de começar, verifique se o Java está instalado corretamente:

java --version

Para verificar o compilador Java:

javac --version

2. Criar um Programa Java

Crie um arquivo com extensão .java. Por exemplo, HelloWorld.java:

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

Importante: O nome do arquivo deve corresponder exatamente ao nome da classe pública (incluindo maiúsculas e minúsculas).

3. Compilar um Programa Java

Para compilar um arquivo Java, use o comando javac:

javac HelloWorld.java

Este comando gera um arquivo HelloWorld.class contendo o bytecode Java.

4. Executar um Programa Java

Para executar o programa compilado, use o comando java:

java HelloWorld

Nota: Não inclua a extensão .class ao executar o programa.

5. Compilar e Executar com Pacotes

Se seu código estiver organizado em pacotes, você precisa especificar o caminho completo:

// Arquivo: src/com/exemplo/MeuPrograma.java
package com.exemplo;

public class MeuPrograma {
    public static void main(String[] args) {
        System.out.println("Programa com pacotes!");
    }
}

Compilar:

javac -d bin src/com/exemplo/MeuPrograma.java

O parâmetro -d bin especifica que os arquivos .class devem ser gerados no diretório bin, mantendo a estrutura de pacotes.

Executar:

java -cp bin com.exemplo.MeuPrograma

O parâmetro -cp bin (ou -classpath bin) especifica onde o Java deve procurar pelas classes.

Usando o Visual Studio Code

1. Criar um Novo Projeto Java

Abra o VS Code
Pressione Ctrl+Shift+P (ou Cmd+Shift+P no macOS)
Digite "Java: Create Java Project"
Selecione o tipo de projeto (No build tools, Maven, Gradle, etc.)
Siga as instruções para configurar o projeto

2. Executar um Programa Java no VS Code

Abra o arquivo Java com o método main
Clique no botão "Run" acima do método main
Alternativamente, clique com o botão direito no editor e selecione "Run Java"

3. Depurar um Programa Java no VS Code

Defina pontos de interrupção clicando na margem esquerda do editor
Clique com o botão direito no editor e selecione "Debug Java"
Use os controles de depuração para navegar pelo código

Usando Maven

1. Criar um Projeto Maven

mvn archetype:generate -DgroupId=com.exemplo -DartifactId=meu-projeto -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

2. Compilar um Projeto Maven

cd meu-projeto
mvn compile

3. Executar Testes

mvn test

4. Criar um JAR

mvn package

5. Executar o Programa

java -cp target/meu-projeto-1.0-SNAPSHOT.jar com.exemplo.App

Dicas e Truques

1. Compilar Múltiplos Arquivos

javac -d bin src/*.java

2. Especificar a Versão do Java

javac --release 17 MeuPrograma.java

3. Gerar Documentação Javadoc

javadoc -d docs src/*.java

4. Verificar Erros sem Compilar

javac -Xlint:all -proc:only MeuPrograma.java

5. Executar com Mais Memória

java -Xmx2g MeuPrograma

Solução de Problemas Comuns

1. "Class not found"

Verifique se o nome da classe está correto (incluindo maiúsculas/minúsculas)
Verifique se o classpath está configurado corretamente
Verifique se o arquivo .class foi gerado

2. "Main method not found"

Verifique se o método main está declarado corretamente:
```
public static void main(String[] args)
```

3. "Unsupported major.minor version"

Você está tentando executar um programa compilado com uma versão mais recente do Java em uma versão mais antiga
Solução: Atualize o JRE ou compile com uma versão compatível usando --release

Conclusão e Próximos Passos

Parabéns por completar este tutorial abrangente sobre Java! Você aprendeu a instalar o ambiente de desenvolvimento, entendeu o significado e o uso das palavras reservadas, explorou o padrão MVC com um exemplo prático e dominou os comandos essenciais para compilar e executar seus programas.

Java é uma linguagem poderosa e versátil com um vasto campo de aplicação. Os próximos passos em sua jornada de aprendizado podem incluir:

Aprofundar-se em conceitos de Orientação a Objetos (Herança, Polimorfismo, Encapsulamento).
Explorar a API padrão do Java (Coleções, I/O, Networking, Concorrência).
Aprender sobre frameworks populares como Spring (para desenvolvimento web e empresarial) e Jakarta EE (anteriormente Java EE).
Desenvolver aplicações Android.
Estudar bancos de dados e como integrá-los com Java usando JDBC ou frameworks ORM como Hibernate/JPA.
Praticar resolvendo problemas em plataformas como LeetCode, HackerRank ou Codewars.
Contribuir para projetos open-source em Java.

Continue praticando, construindo projetos e explorando o vasto ecossistema Java. Boa sorte em sua jornada como desenvolvedor Java!