# Página 1
## Introdução ao Java
### O que é Java?
Java é uma linguagem de programação orientada a objetos, de alto nível, criada pela Sun
Microsystems (atualmente pertencente à Oracle Corporation) em 1995 por James Gosling e
sua equipe. O lema da linguagem é "Write Once, Run Anywhere" (Escreva uma vez, execute
em qualquer lugar), significando que o código Java compilado pode ser executado em qualquer
plataforma que possua uma Máquina Virtual Java (JVM).
### Características Principais
| Característica | Descrição |
|----------------|-----------|
| **Orientada a Objetos** | Tudo em Java é objeto (exceto tipos primitivos) |
| **Portável** | Funciona em qualquer sistema com JVM |
| **Robusta** | Gerenciamento automático de memória, tratamento de exceções |
| **Segura** | Execução em ambiente controlado (sandbox) |
| **Multithread** | Suporte nativo a programação concorrente |
| **Dinâmica** | Suporte a carregamento dinâmico de classes |
### A Máquina Virtual Java (JVM)
A JVM é o coração da portabilidade do Java:
1. **Compilação**: O código fonte (.java) é compilado para bytecode (.class)
2. **Execução**: A JVM interpreta o bytecode e o traduz para código de máquina
3. **Garbage Collector**: Gerencia automaticamente a memória
### Instalando o Java
Para desenvolver em Java, você precisa do **JDK** (Java Development Kit):
1. Acesse o site da Oracle ou OpenJDK
2. Baixe o JDK compatível com seu sistema
3. Configure as variáveis de ambiente (JAVA_HOME e PATH)
**Verificando a instalação:**
```bash
java -version
javac -version
```
### Primeiro Programa em Java
```java
// [Link]
public class MeuPrimeiroPrograma {
public static void main(String[] args) {
[Link]("Olá, mundo!");
```
**Para compilar e executar:**
```bash
javac [Link] # compila (gera .class)
java MeuPrimeiroPrograma # executa
```
### Estrutura Básica de um Programa Java
```java
// Pacote (organização de classes)
package [Link];
// Importações
import [Link];
// Definição da classe (nome deve ser igual ao arquivo)
public class MinhaClasse {
// Atributos (variáveis de instância)
private String nome;
private int idade;
// Construtor
public MinhaClasse(String nome, int idade) {
[Link] = nome;
[Link] = idade;
// Método main (ponto de entrada)
public static void main(String[] args) {
[Link]("Executando programa...");
// Outros métodos
public void exibirDados() {
[Link]("Nome: " + nome);
[Link]("Idade: " + idade);
}
```
---
# Página 2
## Sintaxe Básica e Tipos de Dados
### Comentários em Java
```java
// Comentário de uma linha
/*
Comentário de
múltiplas linhas
*/
/**
* Comentário de documentação (JavaDoc)
* @param nome descrição do parâmetro
* @return descrição do retorno
*/
```
### Tipos Primitivos
Java possui 8 tipos primitivos:
| Tipo | Tamanho | Faixa de Valores | Exemplo |
|------|---------|------------------|---------|
| **byte** | 8 bits | -128 a 127 | `byte b = 100;` |
| **short** | 16 bits | -32.768 a 32.767 | `short s = 30000;` |
| **int** | 32 bits | -2³¹ a 2³¹-1 | `int i = 1000000;` |
| **long** | 64 bits | -2⁶³ a 2⁶³-1 | `long l = 10000000000L;` |
| **float** | 32 bits | ±3.4E-38 a ±3.4E+38 | `float f = 3.14f;` |
| **double** | 64 bits | ±1.7E-308 a ±1.7E+308 | `double d = 3.14159;` |
| **char** | 16 bits | 0 a 65.535 (Unicode) | `char c = 'A';` |
| **boolean** | 1 bit | true ou false | `boolean b = true;` |
### Declaração de Variáveis
```java
// Declaração e inicialização
int idade = 25;
double salario = 3500.50;
char letra = 'J';
boolean ativo = true;
// Constantes (final)
final double PI = 3.14159;
final int DIAS_DA_SEMANA = 7;
// Múltiplas variáveis na mesma linha
int a = 10, b = 20, c = 30;
// Inferência de tipo (Java 10+)
var nome = "João"; // String
var numero = 42; // int
var decimal = 3.14; // double
```
### Strings
String não é tipo primitivo, é uma classe:
```java
String nome = "João Silva";
String mensagem = new String("Olá"); // forma alternativa
// Operações com Strings
String nomeCompleto = "João" + " " + "Silva"; // concatenação
int tamanho = [Link](); // comprimento
char primeira = [Link](0); // primeiro caractere
String maiusculo = [Link](); // maiúsculas
String minusculo = [Link](); // minúsculas
boolean contem = [Link]("Silva"); // contém substring
String[] partes = [Link](" "); // dividir string
// Comparação (NÃO USAR ==)
if ([Link]("João")) { } // correto
if ([Link]("joão")) { } // ignorando maiúsculas
```
### Operadores
**Operadores Aritméticos:**
```java
int a = 10, b = 3;
int soma = a + b; // 13
int subtracao = a - b; // 7
int multiplicacao = a * b; // 30
int divisao = a / b; // 3 (divisão inteira)
double divisaoExata = (double) a / b; // 3.333...
int resto = a % b; // 1
int incremento = a++; // a = 11 (pós-incremento)
int decremento = b--; // b = 2 (pós-decremento)
```
**Operadores de Comparação:**
```java
boolean igual = (a == b);
boolean diferente = (a != b);
boolean maior = (a > b);
boolean menor = (a < b);
boolean maiorOuIgual = (a >= b);
boolean menorOuIgual = (a <= b);
```
**Operadores Lógicos:**
```java
boolean e = (a > 5) && (b < 10); // AND
boolean ou = (a > 5) || (b < 10); // OR
boolean nao = !(a > 5); // NOT
```
**Operador Ternário:**
```java
int idade = 18;
String status = (idade >= 18) ? "Maior de idade" : "Menor de idade";
```
---
# Página 3
## Estruturas de Controle
### Estruturas Condicionais
**if/else:**
```java
int idade = 18;
if (idade >= 18) {
[Link]("Pode votar");
} else if (idade >= 16) {
[Link]("Voto facultativo");
} else {
[Link]("Não pode votar");
```
**switch (tradicional):**
```java
int dia = 3;
String nomeDia;
switch (dia) {
case 1:
nomeDia = "Domingo";
break;
case 2:
nomeDia = "Segunda";
break;
case 3:
nomeDia = "Terça";
break;
case 4:
nomeDia = "Quarta";
break;
case 5:
nomeDia = "Quinta";
break;
case 6:
nomeDia = "Sexta";
break;
case 7:
nomeDia = "Sábado";
break;
default:
nomeDia = "Dia inválido";
```
**switch (moderno - Java 12+):**
```java
String nomeDia = switch (dia) {
case 1 -> "Domingo";
case 2 -> "Segunda";
case 3 -> "Terça";
case 4 -> "Quarta";
case 5 -> "Quinta";
case 6 -> "Sexta";
case 7 -> "Sábado";
default -> "Dia inválido";
};
```
### Estruturas de Repetição
**for (tradicional):**
```java
for (int i = 0; i < 5; i++) {
[Link]("Contador: " + i);
// Saída: Contador: 0, 1, 2, 3, 4
```
**for (enhanced - for each):**
```java
int[] numeros = {10, 20, 30, 40, 50};
for (int numero : numeros) {
[Link](numero);
```
**while:**
```java
int contador = 0;
while (contador < 5) {
[Link]("While: " + contador);
contador++;
```
**do/while:**
```java
int i = 0;
do {
[Link]("Do-while: " + i);
i++;
} while (i < 5);
```
**Controle de fluxo em loops:**
```java
// break - interrompe o loop
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // sai do loop quando i = 5
[Link](i); // imprime 0,1,2,3,4
// continue - pula para próxima iteração
for (int i = 0; i < 5; i++) {
if (i == 2) {
continue; // pula quando i = 2
[Link](i); // imprime 0,1,3,4
```
### Arrays
```java
// Declaração e inicialização
int[] numeros = new int[5]; // array de 5 posições
numeros[0] = 10;
numeros[1] = 20;
// Inicialização direta
int[] valores = {1, 2, 3, 4, 5};
// Array de Strings
String[] nomes = {"João", "Maria", "Pedro"};
// Percorrendo arrays
for (int i = 0; i < [Link]; i++) {
[Link](nomes[i]);
// Com for-each
for (String nome : nomes) {
[Link](nome);
// Arrays multidimensionais
int[][] matriz = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int valor = matriz[1][2]; // 6 (linha 1, coluna 2)
```
---
# Página 4
## Programação Orientada a Objetos
### Classes e Objetos
```java
// Definição da classe
public class Pessoa {
// Atributos (variáveis de instância)
private String nome;
private int idade;
private String email;
// Construtor padrão
public Pessoa() {
[Link] = "Sem nome";
[Link] = 0;
// Construtor com parâmetros
public Pessoa(String nome, int idade) {
[Link] = nome;
[Link] = idade;
// Métodos getters e setters
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
public int getIdade() {
return idade;
public void setIdade(int idade) {
if (idade >= 0) {
[Link] = idade;
// Método da classe
public void exibirInformacoes() {
[Link]("Nome: " + nome);
[Link]("Idade: " + idade);
if (email != null) {
[Link]("Email: " + email);
// Utilizando a classe
public class Main {
public static void main(String[] args) {
// Criando objetos
Pessoa pessoa1 = new Pessoa("João", 25);
Pessoa pessoa2 = new Pessoa();
// Usando setters
[Link]("Maria");
[Link](30);
// Usando métodos
[Link]();
[Link]();
```
### Os Quatro Pilares da POO
**1. Encapsulamento:**
```java
public class ContaBancaria {
private double saldo; // atributo privado
public void depositar(double valor) {
if (valor > 0) {
saldo += valor;
public void sacar(double valor) {
if (valor > 0 && valor <= saldo) {
saldo -= valor;
}
public double getSaldo() {
return saldo;
```
**2. Herança:**
```java
// Classe pai
public class Animal {
protected String nome;
public void emitirSom() {
[Link]("Animal emitindo som");
// Classe filha
public class Cachorro extends Animal {
@Override
public void emitirSom() {
[Link]("Au au!");
public void abanarRabo() {
[Link]("Abanando o rabo");
```
**3. Polimorfismo:**
```java
Animal meuAnimal = new Cachorro();
[Link](); // Chama o método da classe Cachorro
// Método polimórfico
public void fazerBarulho(Animal animal) {
[Link]();
fazerBarulho(new Cachorro()); // Au au!
fazerBarulho(new Gato()); // Miau!
```
**4. Abstração:**
```java
// Classe abstrata
public abstract class Forma {
public abstract double calcularArea();
public void exibirTipo() {
[Link]("Sou uma forma geométrica");
public class Circulo extends Forma {
private double raio;
public Circulo(double raio) {
[Link] = raio;
}
@Override
public double calcularArea() {
return [Link] * raio * raio;
```
### Interfaces
```java
// Definição da interface
public interface Tributavel {
double calcularImposto();
// Método default (Java 8+)
default void exibirRegra() {
[Link]("Todo produto paga imposto");
// Implementação
public class Produto implements Tributavel {
private String nome;
private double preco;
@Override
public double calcularImposto() {
return preco * 0.1; // 10% de imposto
}
```
---
# Página 5
## Tratamento de Exceções e Entrada/Saída
### Tratamento de Exceções
```java
public class ExemploExcecao {
public static void main(String[] args) {
try {
// Código que pode gerar exceção
int[] numeros = {1, 2, 3};
[Link](numeros[5]); // IndexOutOfBoundsException
int divisao = 10 / 0; // ArithmeticException
} catch (ArithmeticException e) {
[Link]("Erro aritmético: " + [Link]());
} catch (ArrayIndexOutOfBoundsException e) {
[Link]("Índice do array inválido");
} catch (Exception e) { // Captura qualquer outra exceção
[Link]("Erro genérico: " + [Link]());
} finally {
// Sempre executado
[Link]("Bloco finally executado");
```
**Criando exceções personalizadas:**
```java
// Exceção verificada (checked)
public class SaldoInsuficienteException extends Exception {
public SaldoInsuficienteException(String mensagem) {
super(mensagem);
// Exceção não verificada (unchecked)
public class ValorInvalidoException extends RuntimeException {
public ValorInvalidoException(String mensagem) {
super(mensagem);
// Utilizando
public void sacar(double valor) throws SaldoInsuficienteException {
if (valor > saldo) {
throw new SaldoInsuficienteException("Saldo insuficiente para saque");
saldo -= valor;
```
### Entrada de Dados com Scanner
```java
import [Link];
public class LeituraDados {
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
try {
[Link]("Digite seu nome: ");
String nome = [Link]();
[Link]("Digite sua idade: ");
int idade = [Link]();
[Link](); // Consumir quebra de linha
[Link]("Digite seu email: ");
String email = [Link]();
[Link]("\nDados informados:");
[Link]("Nome: " + nome);
[Link]("Idade: " + idade);
[Link]("Email: " + email);
} catch (Exception e) {
[Link]("Erro na leitura dos dados");
} finally {
[Link](); // Sempre fechar o Scanner
}
}
```
### Leitura e Escrita em Arquivos
```java
import [Link].*;
import [Link].*;
public class ManipulacaoArquivos {
// Escrever em arquivo
public static void escreverArquivo(String nomeArquivo, String conteudo) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(nomeArquivo))) {
[Link](conteudo);
[Link]("Arquivo escrito com sucesso!");
} catch (IOException e) {
[Link]("Erro ao escrever arquivo: " + [Link]());
// Ler arquivo
public static void lerArquivo(String nomeArquivo) {
try (BufferedReader reader = new BufferedReader(new FileReader(nomeArquivo))) {
String linha;
while ((linha = [Link]()) != null) {
[Link](linha);
} catch (IOException e) {
[Link]("Erro ao ler arquivo: " + [Link]());
}
// Usando Files (Java 7+)
public static void lerComFiles(String nomeArquivo) {
try {
String conteudo = [Link]([Link](nomeArquivo));
[Link](conteudo);
} catch (IOException e) {
[Link]("Erro: " + [Link]());
```
### Collections Framework
```java
import [Link].*;
public class ExemploCollections {
public static void main(String[] args) {
// List (ArrayList)
List<String> nomes = new ArrayList<>();
[Link]("João");
[Link]("Maria");
[Link]("Pedro");
[Link](1, "Ana"); // insere na posição 1
[Link]("Lista: " + nomes);
[Link]("Primeiro: " + [Link](0));
// Set (HashSet) - não permite duplicatas
Set<Integer> numeros = new HashSet<>();
[Link](10);
[Link](20);
[Link](10); // ignorado (já existe)
[Link](30);
[Link]("Set: " + numeros);
// Map (HashMap) - chave-valor
Map<String, Integer> idades = new HashMap<>();
[Link]("João", 25);
[Link]("Maria", 30);
[Link]("Pedro", 28);
[Link]("Idade do João: " + [Link]("João"));
// Iterando sobre Collections
for (String nome : nomes) {
[Link]("Nome: " + nome);
// Usando Iterator
Iterator<String> iterator = [Link]();
while ([Link]()) {
[Link]([Link]());
// Usando forEach com lambda (Java 8+)
[Link](nome -> [Link]("Lambda: " + nome));
```
### Programação Funcional (Java 8+)
```java
import [Link].*;
import [Link].*;
public class ExemploStream {
public static void main(String[] args) {
List<Integer> numeros = [Link](1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// Filtrar números pares e multiplicar por 2
List<Integer> resultado = [Link]()
.filter(n -> n % 2 == 0)
.map(n -> n * 2)
.collect([Link]());
[Link](resultado); // [4, 8, 12, 16, 20]
// Somar todos os números
int soma = [Link]()
.reduce(0, (a, b) -> a + b);
[Link]("Soma: " + soma); // 55
// Agrupar por paridade
Map<Boolean, List<Integer>> grupos = [Link]()
.collect([Link](n -> n % 2 == 0));
[Link]("Pares: " + [Link](true));
[Link]("Ímpares: " + [Link](false));
```
---
## Conclusão
Java é uma linguagem robusta, madura e amplamente utilizada no mercado. Este guia cobriu
os fundamentos essenciais para começar a programar em Java.
### Próximos Passos
1. **Frameworks**: Spring Boot, Hibernate, Jakarta EE
2. **Bancos de Dados**: JDBC, JPA, Spring Data
3. **Desenvolvimento Web**: Servlets, JSP, Spring MVC
4. **Testes**: JUnit, Mockito
5. **Ferramentas**: Maven, Gradle
6. **Boas Práticas**: Design Patterns, Clean Code
7. **Java Avançado**: Reflection, Annotations, Generics
### Dicas para Estudo
- Pratique todos os dias, mesmo que por pouco tempo
- Crie projetos pessoais para aplicar o conhecimento
- Participe de comunidades Java
- Leia código de projetos open source
- Mantenha-se atualizado com as novas versões do Java
Lembre-se: a jornada para se tornar um bom desenvolvedor Java é contínua. Comece com os
fundamentos, pratique bastante e gradualmente explore tópicos mais avançados.
Bons estudos e ótima programação!