Implementos vs extensões: quando usar? Qual é a diferença?

Explique em um idioma fácil de entender ou em um link para algum artigo.

extendsé para estender uma classe.

implementsé para implementar uma interface

A diferença entre uma interface e uma classe regular é que, em uma interface, você não pode implementar nenhum dos métodos declarados. Somente a classe que "implementa" a interface pode implementar os métodos. O equivalente em C ++ de uma interface seria uma classe abstrata (não EXATAMENTE a mesma, mas praticamente).

Além disso, o java não suporta herança múltipla para classes. Isso é resolvido usando várias interfaces.

 public interface ExampleInterface {
    public void doAction();
    public String doThis(int number);
 }

 public class sub implements ExampleInterface {
     public void doAction() {
       //specify what must happen
     }

     public String doThis(int number) {
       //specfiy what must happen
     }
 }

agora estendendo uma classe

 public class SuperClass {
    public int getNb() {
         //specify what must happen
        return 1;
     }

     public int getNb2() {
         //specify what must happen
        return 2;
     }
 }

 public class SubClass extends SuperClass {
      //you can override the implementation
      @Override
      public int getNb2() {
        return 3;
     }
 }

nesse caso

  Subclass s = new SubClass();
  s.getNb(); //returns 1
  s.getNb2(); //returns 3

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

Sugiro que você faça mais pesquisas sobre ligação dinâmica, polimorfismo e, em geral, herança em programação orientada a objetos

Percebo que você tem algumas perguntas sobre C ++ no seu perfil. Se você entender o conceito de herança múltipla do C ++ (referindo-se às classes que herdam características de mais de uma outra classe), o Java não permite isso, mas possui uma palavra-chave interface, que é como uma classe virtual pura em C ++. Como mencionado por muitas pessoas, você é extenduma classe (e você só pode estender de uma) e implementuma interface - mas sua classe pode implementar quantas interfaces você desejar.

Ou seja, essas palavras-chave e as regras que regem seu uso delineiam as possibilidades de herança múltipla em Java (você pode ter apenas uma superclasse, mas implementar várias interfaces).

Geralmente implementa usado para implementar uma interface e estende usado para extensão do comportamento da classe base ou classe abstrata .

estende : Uma classe derivada pode estender uma classe base. Você pode redefinir o comportamento de uma relação estabelecida. Classe derivada " é um " tipo de classe base

implementa : Você está implementando um contrato. A classe que implementa a interface " possui um " recurso.

Com o java 8 release, a interface pode ter métodos padrão na interface, o que fornece implementação na própria interface.

Consulte esta pergunta para saber quando usar cada um deles:

Interface versus classe abstrata (OO geral)

Exemplo para entender as coisas.

public class ExtendsAndImplementsDemo{
    public static void main(String args[]){

        Dog dog = new Dog("Tiger",16);
        Cat cat = new Cat("July",20);

        System.out.println("Dog:"+dog);
        System.out.println("Cat:"+cat);

        dog.remember();
        dog.protectOwner();
        Learn dl = dog;
        dl.learn();

        cat.remember();
        cat.protectOwner();

        Climb c = cat;
        c.climb();

        Man man = new Man("Ravindra",40);
        System.out.println(man);

        Climb cm = man;
        cm.climb();
        Think t = man;
        t.think();
        Learn l = man;
        l.learn();
        Apply a = man;
        a.apply();

    }
}

abstract class Animal{
    String name;
    int lifeExpentency;
    public Animal(String name,int lifeExpentency ){
        this.name = name;
        this.lifeExpentency=lifeExpentency;
    }
    public void remember(){
        System.out.println("Define your own remember");
    }
    public void protectOwner(){
        System.out.println("Define your own protectOwner");
    }

    public String toString(){
        return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
    }
}
class Dog extends Animal implements Learn{

    public Dog(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " will protect owner");
    }
    public void learn(){
        System.out.println(this.getClass().getSimpleName()+ " can learn:");
    }
}
class Cat extends Animal implements Climb {
    public Cat(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
    }
    public void climb(){
        System.out.println(this.getClass().getSimpleName()+ " can climb");
    }
}
interface Climb{
    public void climb();
}
interface Think {
    public void think();
}

interface Learn {
    public void learn();
}
interface Apply{
    public void apply();
}

class Man implements Think,Learn,Apply,Climb{
    String name;
    int age;

    public Man(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void think(){
        System.out.println("I can think:"+this.getClass().getSimpleName());
    }
    public void learn(){
        System.out.println("I can learn:"+this.getClass().getSimpleName());
    }
    public void apply(){
        System.out.println("I can apply:"+this.getClass().getSimpleName());
    }
    public void climb(){
        System.out.println("I can climb:"+this.getClass().getSimpleName());
    }
    public String toString(){
        return "Man :"+name+":Age:"+age;
    }
}

resultado:

Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

Pontos importantes para entender:

1. Cão e Gato são animais e estenderam remember() e protectOwner() compartilhando name,lifeExpentencydeAnimal
2. O gato pode subir (), mas o cachorro não. Cão pode pensar (), mas Gato não . Esses recursos específicos são adicionados Cate Dogimplementando esse recurso.
3. O homem não é um animal, mas ele pode Think,Learn,Apply,Climb

Analisando esses exemplos, você pode entender que

As classes não relacionadas podem ter recursos por meio da interface, mas as classes relacionadas substituem o comportamento por meio da extensão das classes base.

extendsé para quando você está herdando de uma classe base (ou seja, estendendo sua funcionalidade).

implementsé para quando você estiver implementando uma interface .

Aqui é um bom lugar para começar: Interfaces e herança .

A classpode apenas "implementar" um interface. Uma classe apenas "estende" a class. Da mesma forma, um interfacepode estender outro interface.

A classpode apenas se estender class. A classpode implementar vários interfaces.

Se, em vez disso, você estiver mais interessado em saber quando usar abstract classes e interfaces, consulte este tópico: Interface vs Classe Abstrata (OO geral)

Uma interface é uma descrição das ações que um objeto pode executar ... por exemplo, quando você liga um interruptor de luz, a luz acende, você não se importa como, apenas isso. Na Programação Orientada a Objetos, uma Interface é uma descrição de todas as funções que um objeto deve ter para ser um "X". Novamente, como exemplo, qualquer coisa que "AJA COMO" uma luz deve ter um método turn_on () e um método turn_off (). O objetivo das interfaces é permitir que o computador aplique essas propriedades e saber que um objeto do TYPE T (qualquer que seja a interface) deve ter funções chamadas X, Y, Z, etc.

Uma interface é uma estrutura / sintaxe de programação que permite ao computador impor determinadas propriedades em um objeto (classe). Por exemplo, digamos que temos uma classe de carros, uma de scooter e uma de caminhões. Cada uma dessas três classes deve ter uma ação start_engine (). Como o "motor é iniciado" para cada veículo é deixado para cada classe específica, mas o fato de que eles devem ter uma ação start_engine é o domínio da interface .

Como mostra a figura abaixo, uma classe estende outra classe, uma interface estende outra interface, mas uma classe implementa uma interface.

Para mais detalhes

Estende : É usado para obter atributos de uma classe pai na classe base e pode conter métodos já definidos que podem ser substituídos na classe filho.

Implementações : É usada para implementar uma interface (classe pai apenas com assinaturas de funções, mas não com suas definições), definindo-a na classe filho.

Há uma condição especial: "E se eu quiser que uma nova interface seja filha de uma interface existente?". Na condição acima, a interface filho estende a interface pai.

• A estende B:

  A e B são duas classes ou duas interfaces

• A implementa B

  A é uma classe e B é uma interface

• O caso restante em que A é uma interface e B é uma classe não é legal em Java.

Implementações é usado para interfaces e estende é usado para estender uma classe.

Para torná-lo mais claro em termos mais fáceis, uma interface é o som - uma interface - um modelo, que você precisa aplicar, seguir, juntamente com suas idéias.

Extend é usado para classes, aqui, você está estendendo algo que já existe, adicionando mais funcionalidade a ele.

Mais algumas notas:

uma interface pode estender outra interface.

E quando você precisar escolher entre implementar uma interface ou estender uma classe para um cenário específico, vá para implementar uma interface. Porque uma classe pode implementar várias interfaces, mas estender apenas uma classe.

Quando uma subclasse estende uma classe, ela permite que a subclasse herde (reutilize) e substitua o código definido no supertipo. Quando uma classe implementa uma interface, ela permite que um objeto criado a partir da classe seja usado em qualquer contexto que espere um valor da interface.

O verdadeiro problema aqui é que, enquanto implementamos qualquer coisa, simplesmente significa que estamos usando esses métodos como estão. Não há espaço para alteração em seus valores e tipos de retorno.

Mas quando estamos estendendo algo, isso se torna uma extensão da sua classe. Você pode alterá-lo, usá-lo, reutilizá-lo e não precisa necessariamente retornar os mesmos valores que na superclasse.

Usamos SubClass estende SuperClass somente quando a subclasse quer usar algumas funcionalidades (métodos ou variáveis de instância) que já está declarado no SuperClass , ou se eu quiser modificar um pouco a funcionalidade do SuperClass (método de substituição). Mas digamos, por exemplo, eu tenho uma classe Animal ( SuperClass ) e uma classe Dog ( SubClass ) e existem poucos métodos que eu defini na classe Animal, por exemplo. doEat (); , doSleep (); ... e muitos mais.

Agora, minha classe Dog pode simplesmente estender a classe Animal, se eu quiser que meu cão use qualquer um dos métodos declarados na classe Animal, eu posso invocar esses métodos simplesmente criando um objeto Dog. Dessa forma, posso garantir que tenho um cachorro que possa comer, dormir e fazer o que mais quiser.

Agora, imagine, um dia, algum amante de gatos entra em nosso espaço de trabalho e tenta estender a classe Animal (os gatos também comem e dormem). Ela cria um objeto Cat e começa a invocar os métodos.

Mas, digamos, alguém tenta fazer um objeto da classe Animal. Você pode dizer como um gato dorme, como um cachorro come, como um elefante bebe. Mas não faz sentido fazer um objeto da classe Animal. Porque é um modelo e não queremos nenhuma maneira geral de comer.

Então, em vez disso, prefiro criar uma classe abstrata que ninguém possa instanciar, mas que possa ser usada como modelo para outras classes.

Portanto, para concluir, a Interface nada mais é do que uma classe abstrata (uma classe abstrata pura) que não contém implementações de métodos, mas apenas as definições (os modelos). Portanto, quem implementa a interface sabe que possui os modelos de doEat (); e doSleep (); mas eles precisam definir seu próprio doEat (); e doSleep (); métodos de acordo com sua necessidade.

Você estende apenas quando deseja reutilizar parte da SuperClasse (mas lembre-se de que sempre pode substituir os métodos da sua SuperClasse de acordo com sua necessidade) e implementa quando deseja os modelos e deseja defini-los por conta própria (de acordo com sua necessidade).

Vou compartilhar com você um pedaço de código: você tenta com diferentes conjuntos de entradas e olha os resultados.

class AnimalClass {

public void doEat() {

    System.out.println("Animal Eating...");
}

public void sleep() {

    System.out.println("Animal Sleeping...");
}

}

public class Dog extends AnimalClass implements AnimalInterface, Herbi{

public static void main(String[] args) {

    AnimalInterface a = new Dog();
    Dog obj = new Dog();
    obj.doEat();
    a.eating();

    obj.eating();
    obj.herbiEating();
}

public void doEat() {
    System.out.println("Dog eating...");
}

@Override
public void eating() {

    System.out.println("Eating through an interface...");
    // TODO Auto-generated method stub

}

@Override
public void herbiEating() {

    System.out.println("Herbi eating through an interface...");
    // TODO Auto-generated method stub

}


}

Interfaces definidas :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

Ambas as palavras-chave são usadas ao criar sua própria nova classe na linguagem Java.

Diferença: implementssignifica que você está usando os elementos de uma interface Java em sua classe. extendssignifica que você está criando uma subclasse da classe base que está estendendo. Você só pode estender uma classe na sua classe filha, mas pode implementar quantas interfaces desejar.

Consulte a página de documentação da Oracle na interface para obter mais detalhes.

Isso pode ajudar a esclarecer o que é uma interface e as convenções sobre como usá-las.

Nos termos mais simples, o extends é usado para herdar de uma classe e os implementos são usados ​​para aplicar uma interface na sua classe

estende :

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

implementa :

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

se você ainda tiver confusão, leia isto: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Classes e interfaces são ambos contratos . Eles fornecem métodos e propriedades nas quais outras partes de um aplicativo confiam.

Você define uma interface quando não está interessado nos detalhes de implementação deste contrato. A única coisa que importa é que o contrato (a interface) exista.

Nesse caso, você deixa para a classe que implementa a interface se preocupar com os detalhes de como o contrato é cumprido. Somente classes podem implementar interfaces.

extends é usado quando você deseja substituir os detalhes de um contrato existente. Dessa forma, você substitui uma maneira de cumprir um contrato por uma maneira diferente. Classes podem estender outras classes e interfaces podem estender outras interfaces.

Extendsé usado quando você deseja atributos da classe / interface pai na sua classe / interface filho e implementsé usado quando você deseja atributos de uma interface na sua classe.

Exemplo:

1. Estende usando classe

   classe Pai {

   }

   classe Child estende Parent {

   }

2. Estende usando interface

   interface Pai {

   }

   interface Filho estende Pai {

   }

3. Implementos

interface A {

}

classe B implementa A {

}

Combinação de extensões e implementos

interface A{

}

class B

{

}

class C implements A,extends B{

}

estende

• classe estende apenas uma classe
• interface estende uma ou mais interfaces

implementa

• A classe implementa uma ou mais interfaces
• interfaces 'não pode' implementa nada

classes abstratas também agem como classe, com extensões e implementações

Essas duas palavras-chave estão diretamente anexadas à Herança, é um conceito central do OOP. Quando herdamos uma classe para outra, podemos usar extends, mas quando vamos herdar algumas interfaces para nossa classe, não podemos usar extends, devemos usar implementos e podemos usar extends keyword para herdar interface de outra interface.