Posts do Blog

O objetivo aqui é saber quando e como usar a classe Optional<T>, introduzida no Java 8 para evitar NullPointerException de forma mais elegante e segura.

☑️ O que é Optional<T>?

Optional é um container que pode ou não conter um valor não-nulo. Ele te obriga a lidar explicitamente com a ausência de valor, evitando acessos inseguros a referências nulas.

🔧 Criação de Optional

Optional<String> opt1 = Optional.of("valor");         
// Não pode ser null

Optional<String> opt2 = Optional.ofNullable("valor"); 
// Pode ser null

Optional<String> opt3 = Optional.empty();             
// Representa ausência de valor

📌 Principais métodos

📘 Exemplos

Optional<String> nome = Optional.of("Carlos");

// get()
System.out.println(nome.get()); 
// Carlos

// ifPresent
nome.ifPresent(n -> System.out.println(n.toUpperCase())); 
// CARLOS

// orElse
System.out.println(nome.orElse("Desconhecido")); 
// Carlos

// orElse com vazio
Optional<String> vazio = Optional.empty();
System.out.println(vazio.orElse("Nada aqui")); 
// Nada aqui

// map
Optional<Integer> tamanho = nome.map(String::length);
System.out.println(tamanho.get()); 
// 6

😈 Pegadinhas e cuidados na prova:

1. Nunca use .get() sem checar .isPresent() antes!
2. Optional.of(null) → lança NullPointerException
3. orElse() executa sempre o argumento (cuidado com código pesado)
4. Prefira orElseGet() para lógica preguiçosa (lazy)
5. flatMap() é usado quando a função retorna um Optional<T>

🧠 Exemplo com filter:

Optional<String> nome = Optional.of("Ana");
nome = nome.filter(n -> n.startsWith("A"));
System.out.println(nome.isPresent()); 
// true

nome = nome.filter(n -> n.length() > 10);
System.out.println(nome.isPresent()); 
// false

📌 Exemplo flatMap

Optional<String> nome = Optional.of("Java");
Optional<Optional<Integer>> comprimento = 
nome.map(n -> Optional.of(n.length()));
System.out.println(comprimento); 
// Optional[Optional[4]]

Optional<Integer> correto = 
nome.flatMap(n -> Optional.of(n.length()));
System.out.println(correto); 
// Optional[4]

✅ Questão 1

Qual das seguintes chamadas lança uma exceção?

A) Optional.of("java")
B) Optional.empty()
C) Optional.ofNullable(null)
D) Optional.of(null)

✅ Questão 2

Dado:

Optional<String> nome = Optional.of("Carlos");
System.out.println(nome.orElse("Desconhecido"));

O que é impresso?

A) Desconhecido
B) Carlos
C) Optional[Carlos]
D) null

✅ Questão 3

Qual a saída do código?

Optional<String> nome = Optional.of("Java");
System.out.println(nome.map(String::length).get());

A) 4
B) Optional[4]
C) Java
D) Erro de compilação

✅ Questão 4

Dado:

Optional<String> nome = Optional.empty();
System.out.println(nome.orElseGet(() -> "Fallback"));

O que será impresso?

A) Fallback
B) null
C) Optional[Fallback]
D) Exceção

✅ Questão 5

Qual afirmação é verdadeira?

A) Optional.get() é seguro em qualquer situação
B) Optional.ofNullable(null) lança exceção
C) Optional.of(null) é seguro
D) Optional.orElseGet() é preferido para valores computados

✅ Questão 6

Qual das seguintes opções transforma corretamente um Optional<String> em Optional<Integer> representando seu tamanho?

A) opt.flatMap(s -> s.length())
B) opt.map(s -> s.length())
C) opt.map(s -> Optional.of(s.length()))
D) opt.map(s -> s.toString())

✅ Questão 7

Considere:

Optional<String> nome = Optional.of("Ana");
System.out.println(nome.filter(n -> n.startsWith("B")).isPresent());

A) true
B) false
C) Ana
D) Exception

✅ Questão 8

O que retorna este código?

Optional<String> opt = Optional.empty();
opt.get();

A) null
B) "Optional"
C) Optional.empty
D) NoSuchElementException

✅ Questão 9

Assinale a alternativa que melhor representa a utilidade de flatMap em Optional.

A) Evita exceções ao chamar get()
B) Retorna Optional<Optional<T>>
C) Aplica uma função que retorna um Optional<T> e achata o resultado
D) Converte qualquer Optional em Optional<String>

✅ Questão 10

Qual das chamadas abaixo sempre executa seu argumento, mesmo que o Optional tenha valor?

A) orElse("valor")
B) orElseGet(() -> "valor")
C) map(String::length)
D) filter(s -> s != null)

📘 Gabarito Comentado

1. ✅ D – Optional.of(null) lança NullPointerException.
2. ✅ B – O valor é "Carlos" e orElse não é usado.
3. ✅ A – map transforma em Optional<Integer> e get() retorna 4.
4. ✅ A – O valor está ausente, então orElseGet é chamado, retornando "Fallback".
5. ✅ D – orElseGet() é preferido para evitar execução desnecessária.
6. ✅ B – map aplica a função s -> s.length() corretamente.
7. ✅ B – "Ana" não começa com "B", logo o Optional fica vazio.
8. ✅ D – get() em Optional.empty() lança NoSuchElementException.
9. ✅ C – flatMap é usado para “achatar” resultados de funções que já retornam Optional.
10. ✅ A – orElse("valor") sempre avalia o argumento, mesmo se não for usado.

🎯 Objetivo do Tópico

Aprender:

• Diferença entre coleções tradicionais e streams
• Como utilizar Stream, filter, map, collect e outros métodos
• Vantagens do uso funcional
• Erros comuns
• Dicas para a prova
• Exemplos práticos
• Quiz com 10 questões comentadas

🧱 Diferença entre Collections e Stream API

🔍 Estrutura básica de uma Stream

List<String> nomes = Arrays.asList("João", "Ana", "Carlos", "Amanda");

List<String> resultado = nomes.stream()
  .filter(nome -> nome.startsWith("A"))
  .map(String::toUpperCase)
  .collect(Collectors.toList());

Saída: ["ANA", "AMANDA"]

🔧 Principais métodos de Stream

1. filter(Predicate)

Filtra os elementos com base numa condição.

.stream().filter(e -> e > 10)

2. map(Function)

Transforma cada elemento.

.stream().map(String::toUpperCase)

3. collect(Collectors.toList())

Agrupa os elementos finais em uma List, Set, Map, etc.

4. forEach(Consumer)

Executa uma ação para cada elemento.

.forEach(System.out::println)

5. count(), min(), max(), sorted()

long quantidade = lista.stream().filter(e -> e > 5).count();

.stream().sorted(Comparator.naturalOrder())

6. anyMatch, allMatch, noneMatch

Verificam condições.

.stream().anyMatch(e -> e > 100) 
// retorna true se algum for > 100

7. limit(n), skip(n)

Controla quantos elementos são usados.

8. distinct()

Remove elementos duplicados.

🧪 Exemplo completo

List<Integer> numeros = 
Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> paresDobro = numeros.stream()
  .filter(n -> n % 2 == 0)
  .map(n -> n * 2)
  .collect(Collectors.toList());

System.out.println(paresDobro);

Saída: [4, 8, 12, 16, 20]

❌ Pegadinhas e erros comuns

1. Tentar reusar uma Stream após collect() — ela já foi consumida!
2. Confundir map() (transformar) com flatMap() (desdobrar listas)
3. Não usar collect() — resulta em Stream “pendurada”
4. Achar que filter() altera os dados — ele só filtra
5. Tentar modificar elementos diretamente no map() (imutabilidade!)

✅ Dicas para a prova

• Saiba a diferença entre filter, map, collect, reduce
• Streams são lazy: não executam nada até o terminal (collect, forEach, etc.)
• collect(Collectors.toSet()) cria um Set
• filter().map().collect() é uma sequência muito cobrada
• Streams não modificam a lista original

🧪 Simulado

1. Qual método é terminal?

a) filter()
b) map()
c) collect()
d) sorted()

2. O que filter() retorna?

a) boolean
b) nova lista
c) nova Stream
d) coleção modificada

3. Dado:

List<String> nomes = Arrays.asList("Ana", "João", "Alice");
nomes.stream()
  .filter(n -> n.startsWith("A"))
  .forEach(System.out::println);

O que é impresso?

a) Nada
b) Ana Alice
c) Alice
d) João Ana

4. map() é usado para:

a) Remover elementos
b) Filtrar elementos
c) Transformar elementos
d) Contar elementos

5. O que faz collect(Collectors.toSet())?

a) Cria uma nova lista
b) Cria um Set (sem repetição)
c) Conta os elementos
d) Ordena os dados

6. Dado:

Stream.of(1, 2, 3).filter(i -> i > 2);

O que acontece?

a) Executa e imprime 3
b) Filtra mas não executa
c) Nada acontece sem terminal
d) Gera exceção

7. Qual desses métodos consome a stream?

a) filter()
b) map()
c) forEach()
d) sorted()

8. Como obter a quantidade de strings com mais de 3 letras?

a) .map(s -> s.length() > 3).count()
b) .filter(s -> s.length() > 3).count()
c) .forEach(s -> s.length() > 3).count()
d) .collect(s -> s.length() > 3)

9. Streams funcionam em:

a) Arrays
b) Collections
c) Sets
d) Todas as anteriores

10. O que faz distinct()?

a) Ordena a stream
b) Remove duplicatas
c) Filtra com base em ==
d) Conta elementos únicos

✅ Gabarito com Comentários

1. c – collect() é terminal; os outros são intermediários
2. c – filter() retorna uma nova Stream
3. b – Apenas nomes com “A”: Ana e Alice
4. c – map() transforma, como uppercase ou dobrar valor
5. b – Set remove duplicatas
6. c – Nada acontece sem método terminal
7. c – forEach() consome a stream
8. b – filter reduz os elementos, count conta
9. d – Você pode criar stream de array, list, set
10. b – distinct() elimina repetidos

📌 Resumo

• Stream processa coleções de forma funcional
• Métodos comuns: filter, map, collect, forEach, sorted
• Streams são imutáveis, lazy, e reutilizáveis apenas se recriadas
• collect() converte stream em estrutura de dados (List, Set, etc.)
• Muito usado com lambda

🧠 Objetivo do Tópico

Aprender:

• Como ordenar objetos personalizados com Comparable e Comparator
• Diferenças entre ambos
• Boas práticas, formas corretas e incorretas
• Sintaxe com classes anônimas, expressões lambda e métodos estáticos de comparação
• Dicas de prova + 10 questões com respostas comentadas

🔍 1. Interface Comparable<T>

Você implementa essa interface na própria classe para definir ordem natural.

Exemplo: ordenando por nome (ordem alfabética)

public class Pessoa implements Comparable<Pessoa> {
  private String nome;
  private int idade;

  public Pessoa(String nome, int idade) {
    this.nome = nome;
    this.idade = idade;
  }

  @Override
  public int compareTo(Pessoa outra) {
    return this.nome.compareTo(outra.nome);
  }

  @Override
  public String toString() {
    return nome + " (" + idade + ")";
  }
}

List<Pessoa> lista = new ArrayList<>();
lista.add(new Pessoa("João", 30));
lista.add(new Pessoa("Ana", 25));
lista.add(new Pessoa("Carlos", 20));

Collections.sort(lista);
System.out.println(lista);

Saída: [Ana (25), Carlos (20), João (30)]
→ Ordem natural foi definida pelo compareTo().

🔀 2. Interface Comparator<T>

Você cria um comparador externo, útil quando:

• Quer várias formas de ordenação
• Não pode/quer modificar a classe original

Exemplo: ordenando por idade

Comparator<Pessoa> porIdade = new Comparator<>() {
  @Override
  public int compare(Pessoa p1, Pessoa p2) {
    return Integer.compare(p1.idade, p2.idade);
  }
};

Collections.sort(lista, porIdade);

Ou usando lambda:

lista.sort((p1, p2) -> Integer.compare(p1.idade, p2.idade));

Ou com método de comparação:

lista.sort(Comparator.comparing(p -> p.idade));

❌ Erros comuns (pegadinhas)

• Usar compareTo retornando boolean — precisa retornar int
• Esquecer de sobrescrever compareTo() se usa Comparable
• Confundir Comparator com Comparable em provas
• Esquecer que Comparator permite múltiplos critérios (ex: .thenComparing())
• Usar == para comparar Strings ao invés de compareTo ou equals

✅ Boas práticas

• Use Comparable para ordem natural (ex: nomes, números)
• Use Comparator para outras ordenações (ex: por data, idade, tamanho)
• Use Comparator.comparing() com lambdas para código limpo
• Use thenComparing() para empates

📘 Exemplo com thenComparing

Comparator porIdadeENome = Comparator
.comparing(Pessoa::getIdade)
.thenComparing(Pessoa::getNome);

⌛Simulado

a) equals
b) hashCode
c) compare
d) compareTo

a) Que o objeto use Comparator
b) Que a lista seja de Strings
c) Que os elementos implementem Comparable
d) Que a lista esteja ordenada

a) Substituir equals
b) Definir ordem de objetos sem modificar a classe original
c) Comparar objetos usando hashCode
d) Ser usado apenas com mapas

class Produto {
  String nome;
  double preco;
}

Qual opção ordena por preço usando lambda?

a) lista.sort((a, b) -> a.preco - b.preco);
b) lista.sort((a, b) -> Double.compare(a.preco, b.preco));
c) lista.sort((a, b) -> a.preco > b.preco);
d) Collections.sort(lista, Produto);

a) true se objetos forem iguais
b) um número negativo, zero ou positivo
c) o menor número
d) uma String

a) Não
b) Sim, passando no construtor
c) Sim, desde que a classe seja abstract
d) Apenas se a classe implementar Comparable

a) combine()
b) compareWith()
c) thenComparing()
d) alsoCompare()

a) Comparator.comparingInt(p -> p.idade);
b) Comparator.compare((a, b) -> a.idade);
c) Comparator.comparing(p -> p.nome);
d) Comparator.comparing(Pessoa::getIdade);

a) Idênticos fisicamente
b) Considerados iguais na ordenação
c) Diferentes
d) Necessariamente null

a) Ambos são armazenados
b) Apenas um é armazenado
c) Gera exceção
d) Ordenação é ignorada

✅ Gabarito com Comentários

1. d – compareTo é o método da interface Comparable.
2. c – Comparable define a ordem natural.
3. b – Comparator pode ordenar sem modificar a classe.
4. b – Double.compare é a maneira correta.
5. b – compareTo() retorna int, e deve indicar a ordem.
6. b – TreeSet aceita um Comparator no construtor.
7. c – thenComparing encadeia comparações.
8. b – Comparator.compare() não existe, é compare(a, b) via instância.
9. b – compareTo() == 0 indica “iguais na ordenação”, não equals().
10. b – TreeSet descarta duplicatas baseadas na ordenação.

🧾 Resumo

• Comparable: implementado na própria classe, define a ordem natural.
• Comparator: externo, pode ter múltiplas ordens e ser combinado.
• Métodos importantes:
  • compareTo(T o) → Comparable
  • compare(T o1, T o2) → Comparator
  • Comparator.comparing, thenComparing, reversed()
• Saber usar ambos é essencial para ordenações com Collections.sort, TreeSet, TreeMap, etc.

🧠 Objetivo do tópico

Entender como, quando e por que utilizar a palavra-chave final em variáveis, métodos e classes. Identificar usos válidos, usos inválidos e pegadinhas comuns.

🔸 O que é final em Java?

A palavra-chave final indica que algo não pode ser modificado depois de ser definido.

Pode ser aplicada a:

• Variáveis
• Métodos
• Classes

🔹 final com variáveis

✔️ Forma correta:

final int x = 10;

• Você não pode mais alterar o valor de x depois de atribuído.

❌ Forma incorreta:

final int y;
y = 5;
y = 10; // ERRO! Não pode reatribuir

Obs: Você pode inicializar uma variável final depois da declaração, desde que seja feita apenas uma vez.

final int z;
z = 100; // OK
// z = 200; // ERRO!

Final com variáveis de referência:

final StringBuilder sb = new StringBuilder("Olá");
sb.append(" Mundo"); // OK!

❗Cuidado! Você pode alterar o conteúdo, mas não pode apontar para outro objeto:

sb = new StringBuilder(); // ERRO!

🔹 final com métodos

Quando um método é marcado como final, ele não pode ser sobrescrito por subclasses.

✔️ Exemplo:

class Animal {
    public final void fazerSom() {
        System.out.println("Som genérico");
    }
}

class Cachorro extends Animal {
    // public void fazerSom() {} 
    // ERRO: método final não pode ser sobrescrito
}

🔹 final com classes

Uma classe final não pode ser estendida.

✔️ Exemplo:

final class Pessoa {
    public void falar() {
        System.out.println("Olá");
    }
}

// class Aluno extends Pessoa {} 
// ERRO: não é possível herdar de classe final

❗Classes final não podem ser herdadas, mas podem herdar outras classes, ex:

class A {}
final class B extends A {} // OK

🔹 final com parâmetros de método

public void calcular(final int numero) {
    // numero++; // ERRO: não pode alterar parâmetro final
}

🔹 final com variáveis locais (em métodos ou blocos)

São úteis quando passadas para classes anônimas ou expressões lambda.

void teste() {
    final int valor = 10;

    Runnable r = new Runnable() {
        public void run() {
            System.out.println(valor);
        }
    };
}

Desde o Java 8, as variáveis efetivamente finais também funcionam:

void teste() {
    int valor = 10; // efetivamente final

    Runnable r = () -> System.out.println(valor); // OK
}

📝 Simulado

🙇Clique na pergunta para ver a resposta mas tente resolver primeiro.🏋🏻‍♀️

A) O programa compila normalmente.
B) O programa lança uma exceção em tempo de execução.
C) Erro de compilação.
D) O método final é substituído silenciosamente.

final int x;
x = 5;
x = 10;
System.out.println(x);

A) 5
B) 10
C) Erro de compilação
D) Nada é impresso

A) Um objeto final não pode ser modificado.
B) Um objeto final pode ser reassociado.
C) Um objeto final pode ter seu estado alterado.
D) Um objeto final não pode ser referenciado em outro método.

A) final int x; x = 10; x = 20;
B) final int x = 10; x++;
C) final int x; x = 10;
D) final int x;

A) Uma classe final pode conter métodos abstratos.
B) Uma interface pode conter métodos final.
C) Um método final pode ser sobrescrito em uma subclasse.
D) Um método privado é implicitamente final.

A) Eles podem ser herdados e sobrescritos.
B) Eles não podem ser herdados.
C) Eles podem ser herdados mas não sobrescritos.
D) Eles são automaticamente estáticos.

class A {
    final void m() {}
}
class B extends A {
    void m() {}
}

A) Compila sem erros
B) Erro em tempo de execução
C) Erro de compilação
D) Compila e imprime “m”

A) Devem ser declaradas como final
B) Devem ser estáticas
C) Devem ser públicas
D) Podem ser efetivamente finais

A) Não
B) Sim, é usado para constantes
C) Apenas em classes abstratas
D) Apenas em interfaces

A) final int x = 10;
B) public final class Teste {}
C) interface A { final void m(); }
D) class A { final void m() {} }

🧠 RESUMÃO: Tudo sobre final em Java

🧩 Pegadinhas de prova

✅Conceito de Classes e Métodos Abstratos

• É uma classe que não pode ser instanciada.
• Pode ter métodos com ou sem corpo (abstratos).
• Pode ter construtores, atributos e métodos concretos (com implementação).
• Usada como base para outras classes que estendem e completam a lógica.

abstract class Animal {
    abstract void emitirSom(); // método abstrato
    void dormir() {
        System.out.println("Dormindo...");
    }
}

✅ O que é um método abstrato?

• É um método sem corpo, ou seja, sem implementação.
• A classe que o contém deve ser abstrata.
• As subclasses concretas devem implementar todos os métodos abstratos.

❌ Coisas que DÃO ERRO (com explicação)

❌ Tentar instanciar uma classe abstrata

Animal a = new Animal(); 
// ERRO: Animal é abstrata

❌ Declarar método abstrato em classe concreta

class Ave {
    abstract void voar(); 
// ERRO: a classe precisa ser abstrata
}

❌ Método abstrato com corpo

abstract class Peixe {
    abstract void nadar() {
        // ERRO: não pode ter corpo
        System.out.println("Nadando"); 
    }
}

❌ Classe concreta que herda método abstrato e não implementa

abstract class Animal {
    abstract void emitirSom();
}

class Gato extends Animal {
    // ERRO: método abstrato não implementado
}

⚠️ Pegadinhas de Prova

⚠️ 1. Método final não pode ser abstract

abstract class Teste {
    final abstract void algo(); 
// ERRO: final não permite sobrescrita
}

⚠️ 2. static, private e final não podem ser usados com abstract

abstract class A {
    private abstract void m(); // ERRO
    static abstract void n();  // ERRO
    final abstract void o();   // ERRO
}

⚠️ 3. Uma classe abstrata pode ter construtor

abstract class Carro {
    Carro() {
        System.out.println("Construindo carro");
    }
}

✅ Funcionamento correto de classes Abstratas

✅ 1. Classe abstrata com métodos concretos

abstract class Animal {
    abstract void emitirSom();
    void comer() {
        System.out.println("Comendo");
    }
}

✅ 2. Subclasse concreta implementa todos os métodos abstratos

class Vaca extends Animal {
    @Override
    void emitirSom() {
        System.out.println("Muuu");
    }
}

✅ 3. Subclasse pode ser abstrata também (sem implementar tudo)

abstract class Ave extends Animal {
    // ainda não implementou emitirSom
}

📝 Simulado com Respostas

🚀 Clique nas perguntas para ver as respostas, tente resolver primeiro.🏋️‍♀️

A) Classes abstratas não podem ter métodos concretos.
B) Classes abstratas sempre devem ser herdadas.
C) Classes abstratas podem ter construtores.
D) Métodos abstratos podem ser private.

abstract class Animal {
    abstract void som();
    void dormir() {
        System.out.println("Zzz");
    }
}

class Cavalo extends Animal {}

abstract class Teste {
    abstract void m1();
    abstract void m2();
}

class Concreta extends Teste {
    void m1() {}
}

abstract class A {
    void metodo() {}
}

abstract class A {
    abstract void m();
}

class B extends A {
    void m() {}
}

abstract class A {
    abstract void m();
}

abstract class B extends A {
    // sem implementar m()
}

abstract class A {
    A() {
        System.out.println("Construtor A");
    }
}

A) Classes abstratas podem conter atributos.
B) Classes abstratas podem conter métodos concretos.
C) Classes abstratas não podem ter construtores.
D) Métodos abstratos não têm corpo.

11) Considere o seguinte código:

abstract class Animal {
    abstract void fazerSom();
}

class Gato extends Animal {
    void fazerSom() {
        System.out.println("Miau");
    }
}

A) Compila e imprime “Miau”
B) Erro em tempo de execução
C) Erro de compilação
D) Compila e não imprime nada

A) Podem estar em classes abstratas
B) Podem ser sobrescritos por subclasses
C) Podem ser private
D) Não podem ter corpo

A) Classes abstratas só podem conter métodos abstratos
B) Classes abstratas não podem conter construtores
C) Classes abstratas podem conter métodos estáticos
D) Classes abstratas precisam ser herdadas por pelo menos uma subclasse concreta

abstract class Exemplo {
    abstract void executar() {}
}

A) Compila normalmente
B) Erro de compilação: método abstrato não pode ter corpo
C) Erro de compilação: classe abstrata não pode conter métodos
D) Compila, mas gera erro em tempo de execução

16) Dado o código:

abstract class Forma {
    abstract double calcularArea();
}

abstract class Forma2D extends Forma {
    // Nenhuma implementação
}

A) Forma2D precisa implementar calcularArea()
B) Forma2D não compila
C) Forma2D pode permanecer abstrata sem erro
D) Forma2D só compila se for final

abstract class Animal {
    abstract void mover();
}

class Peixe extends Animal {
    protected void mover() {
        System.out.println("Nadando");
    }
}

A) O código compila normalmente
B) A visibilidade do método está incorreta
C) Peixe precisa ser abstrata
D) mover() não pode ser sobrescrito

19) Dado o código:

abstract class Pai {
    abstract void metodo();
}

class Filho extends Pai {
    final void metodo() {}
}

A) Compila e funciona
B) Compila, mas o método final não será executado
C) Gera erro, pois não se pode sobrescrever método abstrato como final
D) Gera erro, pois final não pode ser usado em métodos

A) Sim, mas só se for final também
B) Sim, mas ele precisa ser implementado imediatamente
C) Não, pois static e abstract são incompatíveis
D) Sim, desde que a classe também seja final

A) Erro de compilação
B) Compila, mas é considerada inválida
C) Compila normalmente
D) Só pode ser usada como interface

abstract class Base {
    abstract void executar();
}

class Sub extends Base {
    void executar(int a) {}
}

A) Sim, executar está implementado
B) Não, executar() não foi implementado corretamente
C) Sim, pois overload é suficiente
D) Não compila, pois a assinatura é diferente

Renan A. Chaparro

Meu nome é Renan e sou programador com mais de 10 anos de experiência em programação, banco de dados e web-designer, tenho experiência com Oracle, MySQL, PostgreSQL e Firebird e com linguagens de programação Java, PHP, Javascript, Jquery e atuei como consultor de banco de dados, sistema de vendas online, sistema médico, desenvolvimento de aplicativos para Android com Power Apps e Power BI e mantenho a atualização deste blog 🙂 Conheça meu portfolio acessando minha página no GITHUB.

Por que um blog sobre Oracle?

• Oracle é um excelente banco de dados e o mais utilizado no mundo.
• Atende desde pequenas empresas até grandes corporações.
• A vantagem do Oracle é sua padronização e consistência entre as várias implementações diferentes.

Público Alvo

• Profissionais da área de TI
• Iniciantes que desejam começar do zero e ir se aperfeiçoando
• Blog com foco em dicas e resumos para as certificações.