APOSTILA JAVA – LINHA POR LINHA
1. Calculadora Simples
import [Link]; // importa a classe Scanner para ler dados do teclado
public class Calculadora { // declara a classe chamada Calculadora
public static void main(String[] args) { // método principal (onde o programa
inicia)
Scanner sc = new Scanner([Link]); // cria objeto Scanner para entrada
de dados
double a = [Link](); // lê o primeiro número decimal digitado pelo
usuário
double b = [Link](); // lê o segundo número decimal
double resultado = a + b; // soma os dois números e guarda na variável
resultado
[Link](resultado); // imprime o resultado na tela
[Link](); // fecha o Scanner (boa prática para liberar recursos)
}
}
2. Número Primo
int n = 7; // número que será verificado
boolean primo = true; // assume inicialmente que o número é primo
if (n <= 1) { // verifica se o número é menor ou igual a 1
primo = false; // 0 e 1 não são primos
}
for (int i = 2; i < n; i++) { // laço que testa divisores de 2 até n-1
if (n % i == 0) { // verifica se n é divisível por i
primo = false; // se for divisível, não é primo
break; // interrompe o loop
}
}
[Link](primo); // imprime true ou false
3. Cadastro de Pessoas
class Pessoa { // define uma classe chamada Pessoa
String nome; // atributo nome
int idade; // atributo idade
}
Pessoa p = new Pessoa(); // cria um objeto do tipo Pessoa
[Link] = "João"; // atribui valor ao nome
[Link] = 20; // atribui valor à idade
[Link]([Link]); // imprime o nome
4. Média Escolar
double soma = 0; // variável para armazenar a soma das notas
for (int i = 0; i < 4; i++) { // loop que executa 4 vezes
soma += 5; // adiciona 5 à soma (simulando nota)
}
double media = soma / 4; // calcula a média dividindo por 4
[Link](media); // imprime a média
5. Jogo de Adivinhação
int numero = 10; // número que deve ser adivinhado
int tentativa = 0; // variável para armazenar tentativa
while (tentativa != numero) { // repete enquanto não acertar
tentativa++; // incrementa tentativa (simulação)
}
[Link]("Acertou!"); // mensagem final
6. Lista de Tarefas
import [Link]; // importa a classe ArrayList
ArrayList<String> lista = new ArrayList<>(); // cria lista de Strings
[Link]("Estudar"); // adiciona elemento
[Link]("Treinar"); // adiciona outro elemento
for (String item : lista) { // percorre a lista
[Link](item); // imprime cada item
}
7. Conversor de Temperatura
double c = 30; // temperatura em Celsius
double f = (c * 9/5) + 32; // fórmula de conversão para Fahrenheit
[Link](f); // imprime resultado
8. Sistema de Biblioteca
class Livro { // define classe Livro
String nome; // nome do livro
boolean emprestado; // status (true ou false)
}
Livro l = new Livro(); // cria objeto Livro
[Link] = "Java Básico"; // define nome
[Link] = false; // define como disponível
[Link]([Link]); // imprime nome
9. Caixa Eletrônico
double saldo = 1000; // saldo inicial
saldo += 200; // adiciona 200 ao saldo (depósito)
saldo -= 150; // subtrai 150 (saque)
[Link](saldo); // mostra saldo final
10. Sistema de Votação
import [Link]; // importa HashMap
HashMap<String, Integer> votos = new HashMap<>(); // cria mapa de votos
[Link]("A", 0); // candidato A com 0 votos
[Link]("B", 0); // candidato B com 0 votos
[Link]("A", [Link]("A") + 1); // incrementa voto de A
[Link]([Link]("A")); // mostra votos de A
JAVA AVANÇADO – HERANÇA, INTERFACES E BANCO DE DADOS
1. HERANÇA (Base de tudo)
Conceito
Herança permite reaproveitar código e criar especializações.
Código completo (linha por linha)
class Conta { // classe base (superclasse)
protected double saldo; // protected permite acesso nas subclasses
public void depositar(double valor) { // método para depósito
saldo += valor; // soma valor ao saldo
}
public void mostrarSaldo() { // método para exibir saldo
[Link]("Saldo: " + saldo);
}
}
Classe filha
class ContaCorrente extends Conta { // herda de Conta
public void sacar(double valor) { // método específico
saldo -= valor; // reduz saldo
}
}
O que caiu aqui (nível prova)
• extends → herança
• protected → acesso controlado
• reutilização de código
2. POLIMORFISMO (muito cobrado)
Conta conta = new ContaCorrente(); // referência do tipo pai
[Link](100); // método da classe pai
Isso é polimorfismo: variável do tipo Conta, objeto real ContaCorrente
3. INTERFACES (nível profissional)
Conceito
Interface define contrato (obriga implementação)
Código
interface Tributavel { // define contrato
double calcularImposto(); // método sem implementação
}
Classe implementando
class ContaPoupanca extends Conta implements Tributavel {
public double calcularImposto() { // implementação obrigatória
return saldo * 0.01; // 1% de imposto
}
}
Pontos importantes
• implements → usado em interface
• Classe pode implementar várias interfaces
4. ABSTRAÇÃO (nível prova)
abstract class ContaBase { // classe abstrata
abstract void sacar(double valor); // método sem corpo
}
Não pode instanciar classe abstrata
5. BANCO DE DADOS (JDBC – PRÁTICA REAL)
O que você vai aprender
• Conexão com banco
• Executar SQL
• Inserir dados
Código completo
import [Link];
import [Link];
import [Link];
public class Conexao {
public static void main(String[] args) {
try {
// conexão com banco (MySQL)
Connection conn = [Link](
"jdbc:mysql://localhost:3306/teste", // URL do banco
"root", // usuário
"1234" // senha
);
// SQL para inserir
String sql = "INSERT INTO usuario (nome) VALUES (?)";
PreparedStatement stmt = [Link](sql);
[Link](1, "João"); // substitui ?
[Link](); // executa comando
[Link]("Inserido com sucesso!");
[Link](); // fecha conexão
} catch (Exception e) {
[Link]("Erro: " + [Link]());
}
}
}
Explicação (linha por linha)
Connection conn = [Link](...)
abre conexão com banco
PreparedStatement stmt = [Link](sql);
prepara comando SQL
[Link](1, "João");
substitui o ? no SQL
[Link]();
executa comando
6. ESTRUTURA PROFISSIONAL (DAO)
Conceito
Separar lógica do banco (boa prática)
class UsuarioDAO {
public void inserir(String nome) {
try {
Connection conn = [Link](
"jdbc:mysql://localhost:3306/teste", "root", "1234"
);
String sql = "INSERT INTO usuario (nome) VALUES (?)";
PreparedStatement stmt = [Link](sql);
[Link](1, nome);
[Link]();
[Link]();
} catch (Exception e) {
[Link](e);
}
}
}
RESUMO (NÍVEL PROFISSIONAL)
Você aprendeu:
POO avançado
• Herança (extends)
• Polimorfismo
• Abstração
• Interfaces
Banco de dados
• JDBC
• SQL básico
• PreparedStatement
• DAO pattern
• SIMULADO JAVA – NÍVEL
AVANÇADO
•
• 1. (FCC) – Herança e sobrescrita
• class A {
void metodo() {
[Link]("A");
}
}
class B extends A {
void metodo() {
[Link]("B");
}
}
public class Teste {
public static void main(String[] args) {
A obj = new B();
[Link]();
}
}
• Saída?
• A) A
B) B
C) Erro
D) Null
•
• Gabarito: B
• Explicação
• Polimorfismo → método da classe real (B) é executado
•
• 2. (FGV) – Interface
• interface X {
void metodo();
}
class Y implements X {
}
• O que acontece?
• A) Compila normalmente
B) Erro de execução
C) Erro de compilação
D) Interface não pode ser usada
•
• Gabarito: C
• Explicação
• Classe que implementa interface deve implementar todos os métodos
•
• 3. (FCC) – ArrayList e remoção
• import [Link].*;
public class Teste {
public static void main(String[] args) {
ArrayList<Integer> lista = new ArrayList<>();
[Link](1);
[Link](2);
[Link](3);
for (Integer i : lista) {
if (i == 2) {
[Link](i);
}
}
}
}
• Resultado?
• A) Funciona normalmente
B) Remove o 2
C) Erro em tempo de execução
D) Não remove nada
•
• Gabarito: C
• Explicação
• ConcurrentModificationException
Não pode modificar lista dentro de for-each
•
• 4. (FGV) – String imutável
• String s = "Java";
[Link]("Java", "Python");
[Link](s);
• Saída?
•
• Gabarito: Java
• Explicação
• String é imutável → não altera valor original
•
• 5. (FCC) – HashMap
• import [Link].*;
HashMap<String, Integer> map = new HashMap<>();
[Link]("A", 1);
[Link]("B", 2);
[Link]("A", 3);
[Link]([Link]());
• Resultado?
• A) 3
B) 2
C) 1
D) Erro
•
• Gabarito: B
• Explicação
• Chave duplicada substitui valor
•
• 6. (FGV) – Exceções
• try {
int x = 10 / 0;
} catch (Exception e) {
[Link]("Erro");
}
• Saída?
•
• Gabarito: Erro
• Explicação
• Divisão por zero gera exceção capturada
•
• 7. (FCC) – JDBC
• Connection conn = [Link](...);
[Link]();
PreparedStatement stmt = [Link]("SELECT * FROM
tabela");
• O que ocorre?
• A) Funciona
B) Erro em tempo de execução
C) Erro de compilação
D) Retorna vazio
•
• Gabarito: B
• Explicação
• Conexão já está fechada → não pode usar
•
• 8. (FGV) – Polimorfismo
• class Animal {
void som() {
[Link]("Animal");
}
}
class Cachorro extends Animal {
void som() {
[Link]("Latido");
}
}
Animal a = new Cachorro();
[Link]();
• Saída?
•
• Gabarito: Latido
•
• 9. (FCC) – Loop
• int i = 0;
while (i < 5) {
[Link](i);
}
• O que ocorre?
•
• Gabarito: Loop infinito
• Explicação
• i nunca é incrementado
•
• 10. (FGV) – equals vs ==
• String a = new String("Java");
String b = new String("Java");
[Link](a == b);
[Link]([Link](b));
• Resultado?
•
• Gabarito:
• false
true