Guia Completo de Java: Do B sico á à

çã
Orienta o a Objetos
Este guia abrangente foi elaborado para fornecer uma introdução sólida à linguagem de
programação Java, cobrindo os conceitos fundamentais e preparando o leitor para os princípios
da Programação Orientada a Objetos (POO). Através de explicações claras e exemplos
práticos, este material visa capacitar iniciantes a desenvolver uma compreensão robusta e
habilidades essenciais em Java.

Sumário
1. Introdução ao Java
2. Configuração do Ambiente
3. Primeiro Programa em Java
4. Variáveis e Tipos de Dados
5. Operadores
6. Estruturas de Controle
Estruturas Condicionais (if, else if, else, switch)
Estruturas de Repetição (for, while, do-while)

7. Arrays
8. ArrayList
9. Introdução à Programação Orientada a Objetos (POO)

1. Introdução ao Java
Java é uma linguagem de programação orientada a objetos, de alto nível, desenvolvida pela
Sun Microsystems (agora Oracle) no início dos anos 90. É conhecida por sua portabilidade,
segurança e robustez. A principal característica do Java é a filosofia “Write Once, Run
Anywhere” (WORA), que significa que o código Java compilado pode ser executado em
qualquer plataforma que possua uma Java Virtual Machine (JVM).

Principais Características do Java:

Orientada a Objetos: Tudo em Java é tratado como um objeto, facilitando a modularidade

e a reutilização de código.
 Plataforma Independente: O código compilado (bytecode) é executado pela JVM,
tornando-o independente do sistema operacional subjacente.
Simples: Java foi projetada para ser fácil de aprender e usar, com uma sintaxe limpa e
organizada.
Segura: Possui recursos de segurança integrados, como o gerenciador de segurança da
JVM, que restringe o acesso de programas a recursos do sistema.
Robusta: Gerenciamento automático de memória (Garbage Collector) e tratamento de
exceções ajudam a criar aplicações mais confiáveis.
Multithreaded: Suporta a execução de múltiplas tarefas simultaneamente, o que é
essencial para aplicações de alto desempenho.

2. Configuração do Ambiente
Para começar a programar em Java, você precisará instalar o Java Development Kit (JDK), que
inclui o compilador Java (javac) e a Java Virtual Machine (JVM). Além disso, é altamente
recomendável usar um Ambiente de Desenvolvimento Integrado (IDE) como o IntelliJ IDEA,
Eclipse ou VS Code.

Passos para Configuração (Exemplo com OpenJDK e VS Code):

1. Instalar o OpenJDK: Baixe e instale a versão mais recente do OpenJDK a partir do site
oficial ou de um gerenciador de pacotes (ex: sudo apt install openjdk-17-jdk no
Ubuntu).

2. Configurar Variáveis de Ambiente: Certifique-se de que as variáveis JAVA_HOME e

PATH estejam configuradas corretamente para apontar para a instalação do JDK.

3. Instalar o VS Code: Baixe e instale o Visual Studio Code.

4. Instalar Extensões Java: No VS Code, instale as extensões do “Extension Pack for Java”
da Microsoft.

3. Primeiro Programa em Java

Vamos criar um programa simples que imprime “Olá, Mundo!” no console. Este é o ponto de
partida para qualquer linguagem de programação.
 // Nome do arquivo: [Link]
public class OlaMundo {
public static void main(String[] args) {
[Link]("Olá, Mundo!"); // Imprime a mensagem no consol
}
}

Explicação do Código:

public class OlaMundo : Declara uma classe pública chamada OlaMundo . Em Java,
todo o código reside dentro de classes.
public static void main(String[] args) : Este é o método principal (entry point)
do programa. Quando você executa um programa Java, a JVM procura e executa este
método.
public : O método é acessível de qualquer lugar.

static : O método pertence à classe, não a uma instância específica do objeto.

void : O método não retorna nenhum valor.

main : É o nome padrão do método principal.

(String[] args) : Permite que o programa receba argumentos de linha de

comando.

[Link]("Olá, Mundo!"); : Esta linha imprime a string “Olá, Mundo!” no

console, seguida por uma nova linha.

Como Compilar e Executar:

1. Salvar: Salve o código acima em um arquivo chamado [Link] .

2. Compilar: Abra o terminal/prompt de comando, navegue até o diretório onde salvou o

arquivo e execute:

javac [Link]

Se não houver erros, um arquivo [Link] será gerado.

3. Executar: Execute o programa compilado:

 java OlaMundo

Você verá a saída: Olá, Mundo!

4. Variáveis e Tipos de Dados

Variáveis são contêineres para armazenar valores de dados. Em Java, cada variável deve ter
um tipo de dado especificado, que determina o tipo de valor que ela pode armazenar e a
quantidade de memória que será alocada.

Declaração e Inicialização de Variáveis:

// Declaração de uma variável

int idade;

// Inicialização de uma variável

idade = 30;

// Declaração e inicialização na mesma linha

String nome = "Maria";
double altura = 1.75;
boolean isEstudante = true;

Tipos de Dados Primitivos:

Java possui oito tipos de dados primitivos, que são os blocos de construção básicos para a
manipulação de dados.
 Tipo de Tamanho Faixa de Valores Exemplo de Uso
Dado (bits)

byte 8 -128 a 127 byte b = 10;

short 16 -32,768 a 32,767 short s = 1000;

int 32 -2,147,483,648 a 2,147,483,647 int i = 50000;

long 64 -9,223,372,036,854,775,808 a long l =

9,223,372,036,854,775,807 15000000000L;

float 32 Aproximadamente ±3.4e-38 a float f =

±3.4e+38 (7 casas decimais) 23.5f;

double 64 Aproximadamente ±1.7e-308 a double d =

±1.7e+308 (15 casas decimais) 19.99d;

boolean 1 true ou false boolean ativo =

true;

char 16 Caractere Unicode único char letra =

'A';

Tipos de Dados Não Primitivos (Tipos de Referência):

Além dos primitivos, Java possui tipos de dados não primitivos, que são objetos. Os mais
comuns incluem String , Arrays e Classes (que você criará).

String : Usado para armazenar sequências de caracteres.

String saudacao = "Olá, Java!";

String frase = new String("Aprendendo Java");

Constantes (final):
Para declarar uma variável cujo valor não pode ser alterado após a inicialização, use a palavra-
chave final .
 final double PI = 3.14159;
// PI = 3.14; // Isso causaria um erro de compilação

Exemplos de Uso de Variáveis:

public class ExemploVariaveis {

public static void main(String[] args) {
// Variáveis primitivas
int numeroInteiro = 10;
double numeroDecimal = 20.5;
boolean isVerdadeiro = true;
char primeiraLetra = 'J';

// Variável de referência (String)

String mensagem = "Bem-vindo ao Java!";

[Link]("Número Inteiro: " + numeroInteiro);

[Link]("Número Decimal: " + numeroDecimal);
[Link]("É Verdadeiro: " + isVerdadeiro);
[Link]("Primeira Letra: " + primeiraLetra);
[Link]("Mensagem: " + mensagem);

// Modificando valores
numeroInteiro = 15;
mensagem = "Java é poderoso!";

[Link]("Novo Número Inteiro: " + numeroInteiro);

[Link]("Nova Mensagem: " + mensagem);

// Constante
final int IDADE_MINIMA = 18;
[Link]("Idade Mínima: " + IDADE_MINIMA);
}
}
5. Operadores
Operadores são símbolos que realizam operações em variáveis e valores. Java suporta vários
tipos de operadores.

Operadores Aritméticos:
Usados para realizar operações matemáticas básicas.

Operador Descrição Exemplo Resultado

+ Adição 10 + 5 15

- Subtração 10 - 5 5

* Multiplicação 10 * 5 50

/ Divisão 10 / 5 2

% Módulo (resto) 10 % 3 1

++ Incremento int x = 5; x++; x se torna 6

-- Decremento int y = 5; y--; y se torna 4

Operadores de Atribuição:
Usados para atribuir valores a variáveis.

Operador Exemplo Equivalente a

= int x = 10; x = 10

+= x += 5; x = x + 5

-= x -= 5; x = x - 5

*= x *= 5; x = x * 5

/= x /= 5; x = x / 5

%= x %= 3; x = x % 3
Operadores de Comparação (Relacionais):
Usados para comparar dois valores e retornar um boolean ( true ou false ).

Operador Descrição Exemplo Resultado

== Igual a 10 == 5 false

!= Diferente de 10 != 5 true

> Maior que 10 > 5 true

< Menor que 10 < 5 false

>= Maior ou igual a 10 >= 10 true

<= Menor ou igual a 10 <= 5 false

Operadores Lógicos:
Usados para combinar expressões booleanas.

Operador Descrição Exemplo Resultado

&& AND lógico (true && false) false

|| OR lógico (true || false) true

! NOT lógico !true false

Operador Ternário (Condicional):

Um operador de atalho para a instrução if-else .

// sintaxe: variavel = (condicao) ? expressao_se_verdadeiro : expressao_se

int idade = 20;
String status = (idade >= 18) ? "Adulto" : "Menor";
[Link](status); // Saída: Adulto
Exemplos de Uso de Operadores:

public class ExemploOperadores {

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

// Operadores Aritméticos
[Link]("a + b = " + (a + b)); // 15
[Link]("a - b = " + (a - b)); // 5
[Link]("a * b = " + (a * b)); // 50
[Link]("a / b = " + (a / b)); // 2
[Link]("a % b = " + (a % b)); // 0

// Incremento e Decremento
int x = 7;
x++; // x agora é 8
[Link]("x depois do incremento: " + x);
int y = 7;
y--; // y agora é 6
[Link]("y depois do decremento: " + y);

// Operadores de Atribuição
int c = 10;
c += 3; // c = c + 3 -> c = 13
[Link]("c depois de c += 3: " + c);

// Operadores de Comparação
[Link]("a == b: " + (a == b)); // false
[Link]("a != b: " + (a != b)); // true
[Link]("a > b: " + (a > b)); // true

// Operadores Lógicos
boolean condicao1 = (a > b); // true
boolean condicao2 = (a < 20); // true
[Link]("condicao1 && condicao2: " + (condicao1 && cond
[Link]("condicao1 || condicao2: " + (condicao1 || cond
[Link]("!condicao1: " + (!condicao1)); // false

// Operador Ternário
String resultado = (a > b) ? "a é maior" : "b é maior";
[Link]("Resultado do ternário: " + resultado);
 }
}

6. Estruturas de Controle
As estruturas de controle permitem que você controle o fluxo de execução do seu programa,
tomando decisões e repetindo blocos de código.

Estruturas Condicionais:

if , else if , else
Usadas para executar um bloco de código se uma condição for verdadeira.

public class ExemploIfElse {

public static void main(String[] args) {
int hora = 14;

if (hora < 12) {

[Link]("Bom dia!");
} else if (hora < 18) {
[Link]("Boa tarde!");
} else {
[Link]("Boa noite!");
}

int idade = 20;

if (idade >= 18) {
[Link]("Você é maior de idade.");
} else {
[Link]("Você é menor de idade.");
}
}
}

switch
Usado para selecionar um dos muitos blocos de código a serem executados.
public class ExemploSwitch {
public static void main(String[] args) {
int diaDaSemana = 3; // 1=Domingo, 2=Segunda, ..., 7=Sábado
String nomeDoDia;

switch (diaDaSemana) {
case 1:
nomeDoDia = "Domingo";
break;
case 2:
nomeDoDia = "Segunda-feira";
break;
case 3:
nomeDoDia = "Terça-feira";
break;
case 4:
nomeDoDia = "Quarta-feira";
break;
case 5:
nomeDoDia = "Quinta-feira";
break;
case 6:
nomeDoDia = "Sexta-feira";
break;
case 7:
nomeDoDia = "Sábado";
break;
default:
nomeDoDia = "Dia inválido";
break;
}
[Link]("Hoje é " + nomeDoDia);

char nota = 'B';

switch (nota) {
case 'A':
[Link]("Excelente!");
break;
case 'B':
case 'C':
[Link]("Bom trabalho!");
break;
case 'D':
 [Link]("Você passou.");
break;
case 'F':
[Link]("Você reprovou.");
break;
default:
[Link]("Nota inválida.");
}
}
}

Estruturas de Repetição (Loops):

for Loop
Usado para iterar um bloco de código um número conhecido de vezes.

public class ExemploFor {

public static void main(String[] args) {
// Loop para imprimir números de 0 a 4
for (int i = 0; i < 5; i++) {
[Link]("Contagem: " + i);
}

// Loop para iterar sobre um array (veremos arrays em detalhes dep

String[] frutas = {"Maçã", "Banana", "Laranja"};
for (int i = 0; i < [Link]; i++) {
[Link]("Fruta: " + frutas[i]);
}

// For-each loop (enhanced for loop) - mais simples para iterar co

for (String fruta : frutas) {
[Link]("Fruta (for-each): " + fruta);
}
}
}

while Loop
Executa um bloco de código enquanto uma condição especificada for verdadeira.
 public class ExemploWhile {
public static void main(String[] args) {
int contador = 0;
while (contador < 5) {
[Link]("Contador: " + contador);
contador++;
}

// Exemplo com condição mais complexa

int numero = 10;
while (numero > 0) {
[Link]("Número decrescente: " + numero);
numero -= 2;
}
}
}

do-while Loop
Semelhante ao while loop, mas garante que o bloco de código seja executado pelo menos
uma vez, pois a condição é avaliada após a execução do bloco.

public class ExemploDoWhile {

public static void main(String[] args) {
int i = 0;
do {
[Link]("Do-While Contador: " + i);
i++;
} while (i < 5);

// Exemplo onde a condição é falsa desde o início

int j = 10;
do {
[Link]("Este será impresso uma vez: " + j);
j++;
} while (j < 5);
}
}
break e continue

break : Usado para sair de um loop ou de uma instrução switch .

continue : Usado para pular a iteração atual de um loop e continuar com a próxima.

public class ExemploBreakContinue {

public static void main(String[] args) {
// Exemplo com break
for (int i = 0; i < 10; i++) {
if (i == 5) {
[Link]("Quebrando o loop no 5.");
break; // Sai do loop
}
[Link]("Break Loop: " + i);
}

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

// Exemplo com continue

for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
[Link]("Pulando número par: " + i);
continue; // Pula para a próxima iteração se for par
}
[Link]("Continue Loop (ímpar): " + i);
}
}
}

7. Arrays
Arrays são estruturas de dados que armazenam uma coleção de elementos do mesmo tipo de
dado em posições de memória contíguas. Eles têm um tamanho fixo, definido no momento da
criação.
Declaração e Inicialização de Arrays:

// Declaração de um array de inteiros

int[] numeros;

// Inicialização de um array com tamanho 5

numeros = new int[5];

// Declaração e inicialização na mesma linha

String[] nomes = new String[3];

// Inicialização com valores diretamente

double[] notas = {8.5, 7.0, 9.2, 6.8};

Acessando Elementos do Array:

Os elementos de um array são acessados por meio de um índice, que começa em 0 .
 public class ExemploArrayAcesso {
public static void main(String[] args) {
int[] idades = {25, 30, 22, 40};

[Link]("Primeira idade: " + idades[0]); // Saída: 25

[Link]("Terceira idade: " + idades[2]); // Saída: 22

// Modificando um elemento
idades[1] = 31;
[Link]("Segunda idade modificada: " + idades[1]); // S

// Obtendo o tamanho do array

[Link]("Tamanho do array: " + [Link]); // Saída

// Iterando sobre o array com for loop

[Link]("\nIdades no array (for loop):");
for (int i = 0; i < [Link]; i++) {
[Link]("Idade na posição " + i + ": " + idades[i])
}

// Iterando sobre o array com for-each loop

[Link]("\nIdades no array (for-each loop):");
for (int idade : idades) {
[Link]("Idade: " + idade);
}
}
}

Arrays Multidimensionais:
Arrays podem ter mais de uma dimensão, como matrizes.
 public class ExemploArrayMultidimensional {
public static void main(String[] args) {
// Declaração e inicialização de uma matriz 2x3
int[][] matriz = {
{1, 2, 3},
{4, 5, 6}
};

// Acessando elementos
[Link]("Elemento [0][0]: " + matriz[0][0]); // Saída:
[Link]("Elemento [1][2]: " + matriz[1][2]); // Saída:

// Iterando sobre a matriz

[Link]("\nElementos da Matriz:");
for (int i = 0; i < [Link]; i++) { // Percorre as linhas
for (int j = 0; j < matriz[i].length; j++) { // Percorre as co
[Link](matriz[i][j] + " ");
}
[Link](); // Nova linha após cada linha da matriz
}
}
}

8. ArrayList
ArrayList é uma classe da API Collections do Java que implementa a interface List .
Diferente dos arrays tradicionais, ArrayList é dinâmico, o que significa que seu tamanho
pode crescer ou diminuir conforme a necessidade. Ele armazena elementos como objetos, não
tipos primitivos.

Vantagens do ArrayList sobre Arrays:

Tamanho Dinâmico: Não é necessário definir o tamanho no momento da criação.

Métodos Úteis: Oferece métodos convenientes para adicionar, remover, buscar e
manipular elementos.

Declaração e Uso de ArrayList :

Para usar ArrayList , você precisa importá-lo do pacote [Link] .
import [Link];

public class ExemploArrayList {

public static void main(String[] args) {
// Declaração e inicialização de um ArrayList de Strings
ArrayList<String> carros = new ArrayList<String>();

// Adicionando elementos
[Link]("Volvo");
[Link]("BMW");
[Link]("Ford");
[Link]("Mazda");

[Link]("ArrayList de Carros: " + carros);

// Acessando elementos (índice)

[Link]("Primeiro carro: " + [Link](0)); // Saída:

// Modificando um elemento
[Link](1, "Mercedes");
[Link]("ArrayList após modificação: " + carros);

// Removendo um elemento
[Link](3); // Remove "Mazda"
[Link]("ArrayList após remoção: " + carros);

// Obtendo o tamanho do ArrayList

[Link]("Tamanho do ArrayList: " + [Link]());

// Iterando sobre o ArrayList com for loop

[Link]("\nCarros no ArrayList (for loop):");
for (int i = 0; i < [Link](); i++) {
[Link]("Carro na posição " + i + ": " + [Link]
}

// Iterando sobre o ArrayList com for-each loop

[Link]("\nCarros no ArrayList (for-each loop):");
for (String carro : carros) {
[Link]("Carro: " + carro);
}

// Verificando se um elemento existe

[Link]("Contém 'Ford'? " + [Link]("Ford")); //
 // Limpando o ArrayList
[Link]();
[Link]("ArrayList após limpar: " + carros);
[Link]("Está vazio? " + [Link]()); // Saída: t
}
}

ArrayList com Tipos Primitivos (Autoboxing/Unboxing):

ArrayList não pode armazenar tipos primitivos diretamente. Em vez disso, ele usa classes
wrapper (como Integer para int , Double para double , etc.). Java realiza
automaticamente o autoboxing (conversão de primitivo para wrapper) e unboxing (conversão de
wrapper para primitivo).

import [Link];

public class ExemploArrayListPrimitivos {

public static void main(String[] args) {
ArrayList<Integer> numeros = new ArrayList<Integer>();

[Link](10); // autoboxing: int para Integer

[Link](20);
[Link](30);

int primeiroNumero = [Link](0); // unboxing: Integer para int

[Link]("Primeiro número: " + primeiroNumero);

for (Integer num : numeros) {

[Link]("Número: " + num);
}
}
}

9. Introdução à Programação Orientada a Objetos (POO)

Programação Orientada a Objetos (POO) é um paradigma de programação que organiza o
design do software em torno de objetos, em vez de funções e lógica. Um objeto pode ser
definido como uma instância de uma classe, que é um modelo ou blueprint para criar objetos.
Conceitos Fundamentais da POO:

1. Classe: Um modelo ou blueprint para criar objetos. Define as características

(atributos/variáveis) e comportamentos (métodos/funções) que os objetos terão.

// Exemplo de Classe: Carro

public class Carro {
// Atributos (variáveis de instância)
String marca;
String modelo;
int ano;

// Métodos (comportamentos)
public void acelerar() {
[Link]("O carro está acelerando!");
}

public void frear() {

[Link]("O carro está freando.");
}
}

2. Objeto: Uma instância de uma classe. É uma entidade real que possui estado (valores dos
atributos) e comportamento (métodos).
 public class ExemploObjeto {
public static void main(String[] args) {
// Criando um objeto (instância) da classe Carro
Carro meuCarro = new Carro();

// Atribuindo valores aos atributos do objeto

[Link] = "Toyota";
[Link] = "Corolla";
[Link] = 2022;

// Acessando atributos e chamando métodos

[Link]("Marca: " + [Link]);
[Link]("Modelo: " + [Link]);
[Link]("Ano: " + [Link]);

[Link]();
[Link]();

// Criando outro objeto da mesma classe

Carro outroCarro = new Carro();
[Link] = "Honda";
[Link] = "Civic";
[Link] = 2023;

[Link]("\nOutro Carro:");
[Link]("Marca: " + [Link]);
[Link]();
}
}

3. Atributos (Variáveis de Instância): São as características ou propriedades de um objeto.

Representam o estado do objeto.

4. Métodos: São as ações ou comportamentos que um objeto pode realizar. Definem como o
objeto interage com seus dados e com outros objetos.

Construtores:
Um construtor é um método especial usado para inicializar objetos. Ele tem o mesmo nome da
classe e não tem tipo de retorno. Se você não definir um construtor, Java fornecerá um
construtor padrão (sem argumentos).
 public class Pessoa {
String nome;
int idade;

// Construtor com dois parâmetros

public Pessoa(String nomePessoa, int idadePessoa) {
[Link] = nomePessoa;
[Link] = idadePessoa;
[Link]("Objeto Pessoa criado: " + [Link]);
}

// Método para exibir informações

public void exibirInformacoes() {
[Link]("Nome: " + nome + ", Idade: " + idade);
}

public static void main(String[] args) {

// Criando objetos usando o construtor
Pessoa pessoa1 = new Pessoa("Ana", 25);
[Link]();

Pessoa pessoa2 = new Pessoa("Bruno", 30);

[Link]();
}
}

Encapsulamento:
É o conceito de agrupar dados (atributos) e os métodos que operam nesses dados em uma
única unidade (a classe), e restringir o acesso direto a alguns dos componentes do objeto. Isso
é feito usando modificadores de acesso ( public , private , protected ).

private : O membro (atributo ou método) é acessível apenas dentro da própria classe.

public : O membro é acessível de qualquer lugar.

Para acessar atributos private , usamos métodos public chamados getters (para obter o
valor) e setters (para definir o valor).
public class ContaBancaria {
private String numeroConta;
private double saldo;

public ContaBancaria(String numeroConta, double saldoInicial) {

[Link] = numeroConta;
[Link] = saldoInicial;
}

// Getter para numeroConta

public String getNumeroConta() {
return numeroConta;
}

// Getter para saldo

public double getSaldo() {
return saldo;
}

// Setter para saldo (com validação)

public void depositar(double valor) {
if (valor > 0) {
saldo += valor;
[Link]("Depósito de " + valor + " realizado. Novo
} else {
[Link]("Valor de depósito inválido.");
}
}

public void sacar(double valor) {

if (valor > 0 && saldo >= valor) {
saldo -= valor;
[Link]("Saque de " + valor + " realizado. Novo sal
} else {
[Link]("Saque inválido. Saldo insuficiente ou valo
}
}

public static void main(String[] args) {

ContaBancaria minhaConta = new ContaBancaria("12345-6", 1000.0);

[Link]("Número da Conta: " + [Link]

[Link]("Saldo Inicial: " + [Link]());
 [Link](500.0);
[Link](200.0);
[Link](1500.0); // Tentativa de saque inválido

[Link]("Saldo Final: " + [Link]());

}
}

Herança:
É um mecanismo que permite que uma classe (subclasse/classe filha) herde atributos e
métodos de outra classe (superclasse/classe pai). Isso promove a reutilização de código e
estabelece uma relação “é um tipo de”.
// Superclasse (Classe Pai)
class Animal {
String nome;

public Animal(String nome) {

[Link] = nome;
}

public void comer() {

[Link](nome + " está comendo.");
}

public void dormir() {

[Link](nome + " está dormindo.");
}
}

// Subclasse (Classe Filha) que herda de Animal

class Cachorro extends Animal {
String raca;

public Cachorro(String nome, String raca) {

super(nome); // Chama o construtor da superclasse
[Link] = raca;
}

public void latir() {

[Link](nome + " está latindo: Au Au!");
}

public static void main(String[] args) {

Cachorro meuCachorro = new Cachorro("Rex", "Labrador");

[Link]("Nome do cachorro: " + [Link]);

[Link]("Raça do cachorro: " + [Link]);

[Link](); // Método herdado de Animal

[Link](); // Método herdado de Animal
[Link](); // Método próprio de Cachorro
}
}
Polimorfismo:
Significa “muitas formas”. Em POO, refere-se à capacidade de um objeto assumir muitas
formas. Isso geralmente ocorre através da herança e da sobrescrita de métodos (override).
// Superclasse
class Forma {
public void desenhar() {
[Link]("Desenhando uma forma genérica.");
}
}

// Subclasse 1
class Circulo extends Forma {
@Override // Anotação opcional, mas boa prática para indicar sobrescri
public void desenhar() {
[Link]("Desenhando um círculo.");
}
}

// Subclasse 2
class Retangulo extends Forma {
@Override
public void desenhar() {
[Link]("Desenhando um retângulo.");
}
}

public class ExemploPolimorfismo {

public static void main(String[] args) {
Forma forma1 = new Forma();
Forma forma2 = new Circulo(); // Um objeto Circulo é também uma
Forma forma3 = new Retangulo(); // Um objeto Retangulo é também um

[Link](); // Saída: Desenhando uma forma genérica.

[Link](); // Saída: Desenhando um círculo.
[Link](); // Saída: Desenhando um retângulo.

// Exemplo em um array de Formas

Forma[] minhasFormas = new Forma[3];
minhasFormas[0] = new Circulo();
minhasFormas[1] = new Retangulo();
minhasFormas[2] = new Forma();

[Link]("\nDesenhando com array polimórfico:");

for (Forma f : minhasFormas) {
[Link]();
}
 }
}

Abstração:
É o processo de ocultar os detalhes de implementação e mostrar apenas a funcionalidade para
o usuário. Em Java, a abstração é alcançada usando classes abstratas e interfaces.

Classes Abstratas: Não podem ser instanciadas diretamente e podem conter métodos
abstratos (sem implementação) e métodos concretos.
Interfaces: Um contrato que define um conjunto de métodos que uma classe deve
implementar. Todos os métodos em uma interface são implicitamente public e
abstract .
Exemplo de Classe Abstrata:

// Classe Abstrata
abstract class Veiculo {
String marca;

public Veiculo(String marca) {

[Link] = marca;
}

// Método abstrato (sem implementação)

public abstract void acelerar();

// Método concreto
public void parar() {
[Link](marca + " está parando.");
}
}

// Subclasse concreta que estende Veiculo

class CarroEsportivo extends Veiculo {
public CarroEsportivo(String marca) {
super(marca);
}

@Override
public void acelerar() {
[Link](marca + " está acelerando rapidamente!");
}

public static void main(String[] args) {

CarroEsportivo ferrari = new CarroEsportivo("Ferrari");
[Link]();
[Link]();

// Veiculo meuVeiculo = new Veiculo("Generico"); // Erro: Não pode

}
}
Exemplo de Interface:

// Interface
interface Eletrodomestico {
void ligar();
void desligar();
void exibirStatus();
}

// Classe que implementa a interface Eletrodomestico

class Televisao implements Eletrodomestico {
private boolean ligado;

public Televisao() {
[Link] = false;
}

@Override
public void ligar() {
ligado = true;
[Link]("Televisão ligada.");
}

@Override
public void desligar() {
ligado = false;
[Link]("Televisão desligada.");
}

@Override
public void exibirStatus() {
[Link]("Status da TV: " + (ligado ? "Ligada" : "Deslig
}

public static void main(String[] args) {

Televisao tvSala = new Televisao();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
 }
}

Conclusão
Este guia forneceu uma base sólida nos fundamentos do Java, desde a configuração do
ambiente e a escrita do primeiro programa, passando por variáveis, operadores, estruturas de
controle, arrays e ArrayLists. A introdução à Programação Orientada a Objetos (POO) com seus
pilares de Classe, Objeto, Construtor, Encapsulamento, Herança, Polimorfismo e Abstração,
serve como um trampolim para o desenvolvimento de aplicações mais complexas e bem
estruturadas. Com este conhecimento, você está pronto para explorar tópicos mais avançados
em Java e construir soluções robustas.

Referências
Oracle Java Documentation

W3Schools Java Tutorial

GeeksforGeeks Java Tutorial