Dúvida Cruel - Isto não entra na minha cabeça!

Pet é uma interface, e interfaces não podem ser instanciadas.

Algo deste tipo poderia:

Pet a = new Pet(){};

Nesse caso foi criada uma classe anônima.

Como nenhum dos “new Pet()” possui as chaves indicando ser classe anônima, apenas as letras A,D e E são corretas.

Ataxexe:

Pet é uma interface, e interfaces não podem ser instanciadas.

Algo deste tipo poderia:

Pet a = new Pet(){};

Nesse caso foi criada uma classe anônima.

Como nenhum dos “new Pet()” possui as chaves indicando ser classe anônima, apenas as letras A,D e E são corretas.

A B e a C eu entendi… por que interface nao pode ser instanciada.
Mas por que a F nao pode ?

Porque Dog não extende de Beagle, mas sim o contrário, em outras palavras, nem todos os membros da classe Beagle estariam disponíveis em uma instância de Dog, por isso a referência é inválida.

Ahh sim, agora sim =D

Entao quer dizer que beagle nao pode criar nehuma instancia de um objeto que está acima dele ne (ex: Dog e pet) ??!

Muito obrigado mesmoo!!!

diegofss11:

Estou com uma duvida nesta questão da prova SCJA, alguem pode me explicar por favor ???

interface Pet{}
class Dog implements Pet{}
class Beagle extends Dog{}

a) Pet a = new Dog();

b) Pet b = new Pet();

c) Dog f = new Pet();

d) Dog d = new Beagle();

e) Pet e = new Beagle();

f) Beagle c = new Dog();

Resposta: A, D e E

Muito obrigado!

Então cara isso se trata de casting e polimorfismo, pra vc entender isso vc precisa entender sobre herança e fazer os testes É-UM.

No seu exemplo:

Dog herda(implementa) Pet, então logo Dog É-UM Pet mas Pet NAO É-UM Dog.
Beagle herda(extends) Dog, entao logo Beagle É-UM Dog e também É-UM Pet, porque Dog implementou Pet.

Entao quando vc tenta fazer os castings vc tem que verificar se um objeto passa no teste de herança(É-UM) sobre o outro.

Vamos la:

a) Pet a = new Dog(); // Nesse caso ocorre implicitamente o seguinte casting Pet a = (Pet) new Dog(). Basta á vc se perguntar um Dog é um Pet? Nesse caso SIM então é valido essa opçao.

b) Pet b = new Pet(); // Aqui um Pet É-UM Pet, porém Pet é uma interface e nao pode ser instanciada, esse codigo nem compila. Por isso opçao invalida.

c) Dog f = new Pet(); // Aqui ocorre o seguinte casting Dog f = (Dog) new Pet(), vamos nos perguntar um objeto Pet é um Dog? NAO! Como vimos anteriormente um Dog É-UM Pet porém um Pet não É-UM Dog. Esse código nao gera um ClassCastException porque Pet é uma interface e não pode ser instanciada e o compilador dar um erro de compilação.

d) Dog d = new Beagle(); // Aqui ocorre Dog d = (Dog) new Beagle(), um objeto Beagle É-UM Dog? SIM! Opçao valida.

e) Pet e = new Beagle(); // Aqui ocorre Pet e = (Pet) new Beagle(), um objeto Beagle É-UM Pet? SIM! Opçao valida.

f) Beagle c = new Dog(); // Aqui ocorre Beagle c = (Beagle) new Dog(), um objeto Dog É-UM Beagle? NÃO! Um objeto Beagle É-UM Dog não ao contrario.Entao esse codigo gera uma exceçao ClassCastException e opçao invalida

evertonsilvagomesjava:

diegofss11:

Estou com uma duvida nesta questão da prova SCJA, alguem pode me explicar por favor ???

interface Pet{}
class Dog implements Pet{}
class Beagle extends Dog{}

a) Pet a = new Dog();

b) Pet b = new Pet();

c) Dog f = new Pet();

d) Dog d = new Beagle();

e) Pet e = new Beagle();

f) Beagle c = new Dog();

Resposta: A, D e E

Muito obrigado!

Então cara isso se trata de casting e polimorfismo, pra vc entender isso vc precisa entender sobre herança e fazer os testes É-UM.

No seu exemplo:

Dog herda(implementa) Pet, então logo Dog É-UM Pet mas Pet NAO É-UM Dog.
Beagle herda(extends) Dog, entao logo Beagle É-UM Dog e também É-UM Pet, porque Dog implementou Pet.

Entao quando vc tenta fazer os castings vc tem que verificar se um objeto passa no teste de herança(É-UM) sobre o outro.

Vamos la:

a) Pet a = new Dog(); // Nesse caso ocorre implicitamente o seguinte casting Pet a = (Pet) new Dog(). Basta á vc se perguntar um Dog é um Pet? Nesse caso SIM então é valido essa opçao.

b) Pet b = new Pet(); // Aqui um Pet É-UM Pet, porém Pet é uma interface e nao pode ser instanciada, esse codigo nem compila. Por isso opçao invalida.

c) Dog f = new Pet(); // Aqui ocorre o seguinte casting Dog f = (Dog) new Pet(), vamos nos perguntar um objeto Pet é um Dog? NAO! Como vimos anteriormente um Dog É-UM Pet porém um Pet não É-UM Dog. Entao esse codigo gera uma exceçao ClassCastException.

d) Dog d = new Beagle(); // Aqui ocorre Dog d = (Dog) new Beagle(), um objeto Beagle É-UM Dog? SIM! Opçao valida.

e) Pet e = new Beagle(); // Aqui ocorre Pet e = (Pet) new Beagle(), um objeto Beagle É-UM Pet? SIM! Opçao valida.

f) Beagle c = new Dog(); // Aqui ocorre Beagle c = (Beagle) new Dog(), um objeto Dog É-UM Beagle? NÃO! Um objeto Beagle É-UM Dog não ao contrario.Entao esse codigo gera uma exceçao ClassCastException e opçao invalida

Perfeita a explicação mano!!!

Muito obrigado!

evertonsilvagomesjava

Muito boa a sua explicação, ficou extremamente fácil de enteder.

Boa tarde a todos.

Será que eu não percebi, ou a dúvida acima ficou sem resposta :?:

Se ficou, então lá vai.

Interfaces não podem ser instanciadas porque seus métodos são puramente abstratos (Sem implementação).

Métodos abstratos são métodos que não são definidos (implementados) dentro da Interface ou até dentro de uma classe Abstrata.

Detalhe, não confunda Interface com Classes Abstratas, a diferença entre ambas é que Interface é totalmente abstrata, ou seja, todos os seus métodos deverão ser abstratos, os seus atributos deverão ser constantes (declarados com o modificador “Final”). Já as classes Abstratas são parcialmente abastratas, ou seja, ela pode ter métodos abstratos e métodos implementados, ou até, pasmem, nenhum método abstrato :!: :!: :!:

Vamos exemplificar melhor tanto a Interface quanto a Classe Abstrata.

// Interface
  public interface ComportamentoAnimal {

    void idAnimal();

    void alimentar();

    void falar();

  }

  // Classe Abstrata
  public abstract class Animal {

    public void andar(){
         System.out.println("Estou andando");
    }

    public void olhar(){
        System.out.println("Estou olhando ");
    }

    public void ouvir(){
        System.out.println("Estou ouvindo ");
    }

  }

  // Classes herdadas
  public class Leao extends Animal implements ComportamentoAnimal {

    public void idAnimal() {
       System.out.println("Eu sou o Leão");
    }

    public void falar() {
       System.out.println("Estou rugindo");
    }

    public void alimentar() {
       System.out.println("Estou comendo carne");
    }

  }

   public class Porco extends Animal implements ComportamentoAnimal {

    public void idAnimal(){
        System.out.println("Eu sou o Porco");
    }

    public void alimentar(){
        System.out.println("Estou comendo ração");
    }

    public void falar(){
        System.out.println("Estou rosnando");
    }

  }
  
  public class Galinha extends Animal implements ComportamentoAnimal {

    public void idAnimal(){
        System.out.println("Eu sou a Galinha");
    }

    public void alimentar(){
        System.out.println("Estou comendo milho");
    }

    public void falar(){
        System.out.println("Estou piando");
    }

  }

   public class Vaca extends Animal implements ComportamentoAnimal {

    public void idAnimal(){
       System.out.println("Eu sou a Vaca");
    }

    public void alimentar(){
       System.out.println("Estou comendo capim");
    }

    public void falar(){
       System.out.println("Estou mugindo");
    }
    
  }

   public class Cachorro extends Animal implements ComportamentoAnimal {

     public void idAnimal(){
        System.out.println("Eu sou o cachorro");
     }

     public void alimentar(){
        System.out.println("Estou comendo ração");
     }

     public void falar(){
        System.out.println("Estou latindo");
     }
 
   }

Agora na classe principal, vamos executar o programa assim:

public class Main {

    public static void main(String[] args) {

        Leao leao = new Leao();
        leao.idAnimal();
        leao.andar();
        leao.olhar();
        leao.ouvir();
        leao.alimentar();
        leao.falar();

        Porco porco = new Porco();
        porco.idAnimal();
        porco.andar();
        porco.ouvir();
        porco.alimentar();
        porco.falar();

        Galinha galinha = new Galinha();
        galinha.idAnimal();
        galinha.andar();
        galinha.ouvir();
        galinha.alimentar();
        galinha.falar();

        Vaca vaca = new Vaca();
        vaca.idAnimal();
        vaca.andar();
        vaca.olhar();
        vaca.ouvir();
        vaca.alimentar();
        vaca.falar();

        Cachorro cachorro = new Cachorro();
        cachorro.idAnimal();
        cachorro.andar();
        cachorro.olhar();
        cachorro.ouvir();
        cachorro.alimentar();
        cachorro.falar();
        
      }
   }

Repare uma coisa: A Classe Abstrata não possui nenhum método abstrato, mas porque então declará-la como Abstrata :?: Simples, para impedir que a mesma seja instanciada, pois sua instanciação por si só não faria sentido, onde voce só acessaria os métodos “Olhar, Ouvir e Andar”, já os métodos do comportamento animal que não pode ser definidos na hora, definimos como regra obrigatória na Interface, pois este é o papel da Interface, obrigar uma classe a implementar os seus métodos como se fosse uma espécie de contrato.

Repare também que nas sub-classes (Leão, Porco e etc.) eu não precisei implementar os métodos da classe Abstrata Animal, isto pois esta é mais uma diferença entre Interface e Classes Abstratas, na Classe Abstrata há herança, na Interface não.

Voce pode também implementar métodos abstratos em Classes Abstratas, pois foi para isso também que elas foram criadas.