Implementa vs extiende: ¿Cuándo usarlo? ¿Cual es la diferencia?

Por favor explique en un lenguaje fácil de entender o un enlace a algún artículo.

extendses para extender una clase.

implementses para implementar una interfaz

La diferencia entre una interfaz y una clase regular es que en una interfaz no puede implementar ninguno de los métodos declarados. Solo la clase que "implementa" la interfaz puede implementar los métodos. El equivalente en C ++ de una interfaz sería una clase abstracta (no EXACTAMENTE igual pero sí más o menos).

Además, Java no admite la herencia múltiple para las clases. Esto se resuelve mediante el uso de múltiples 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
     }
 }

ahora extendiendo una clase

 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;
     }
 }

en este 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

Le sugiero que investigue un poco más sobre el enlace dinámico, el polimorfismo y, en general, la herencia en la programación orientada a objetos.

Noté que tienes algunas preguntas de C ++ en tu perfil. Si comprende el concepto de herencia múltiple de C ++ (refiriéndose a clases que heredan características de más de una clase), Java no lo permite, pero tiene una palabra clave interface, que es como una clase virtual pura en C ++. Como lo mencionan muchas personas, usted es extenduna clase (y solo puede extenderse desde una), y usted implementuna interfaz, pero su clase puede implementar tantas interfaces como desee.

Es decir, estas palabras clave y las reglas que rigen su uso delinean las posibilidades de herencia múltiple en Java (solo puede tener una superclase, pero puede implementar múltiples interfaces).

Generalmente, los implementos utilizados para implementar una interfaz y los extendidos utilizados para la extensión del comportamiento de la clase base o la clase abstracta .

extiende : una clase derivada puede extender una clase base. Puede redefinir el comportamiento de una relación establecida. La clase derivada " es un " tipo de clase base

implementa : Usted está implementando un contrato. La clase que implementa la interfaz " tiene una " capacidad.

Con el lanzamiento de Java 8, la interfaz puede tener métodos predeterminados en la interfaz, que proporciona implementación en la interfaz misma.

Consulte esta pregunta para saber cuándo usar cada uno de ellos:

Interfaz vs clase abstracta (OO general)

Ejemplo para entender las cosas.

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;
    }
}

salida:

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

Puntos importantes para entender:

1. Perro y Gato son animales y extendieron remember() y protectOwner() compartiendo name,lifeExpentencydeAnimal
2. El gato puede trepar () pero el perro no. El perro puede pensar () pero el gato no . Estas capacidades específicas se añaden a Caty Dogmediante la aplicación de esa capacidad.
3. El hombre no es un animal pero puede Think,Learn,Apply,Climb

Al seguir estos ejemplos, puede comprender que

Las clases no relacionadas pueden tener capacidades a través de la interfaz, pero las clases relacionadas anulan el comportamiento a través de la extensión de las clases base.

extendses para cuando estás heredando de una clase base (es decir, extendiendo su funcionalidad).

implementses para cuando estás implementando una interfaz .

Aquí hay un buen lugar para comenzar: Interfaces y herencia .

A classsolo puede "implementar" un interface. Una clase solo "se extiende" a class. Del mismo modo, un interfacepuede extender otro interface.

A classsolo puede extenderse entre sí class. A classpuede implementar varios interfaces.

Si, por el contrario, está más interesado en saber cuándo usar abstract classes y interfaces, consulte este hilo: Interfaz vs Clase abstracta (OO general)

Una interfaz es una descripción de las acciones que puede hacer un objeto ... por ejemplo, cuando se activa un interruptor de luz, la luz se enciende, no importa cómo, solo eso. En la programación orientada a objetos, una interfaz es una descripción de todas las funciones que debe tener un objeto para ser una "X". Nuevamente, como ejemplo, cualquier cosa que "ACTUE COMO" una luz, debe tener un método turn_on () y un método turn_off (). El propósito de las interfaces es permitir que la computadora imponga estas propiedades y saber que un objeto de TIPO T (cualquiera que sea la interfaz) debe tener funciones llamadas X, Y, Z, etc.

Una interfaz es una estructura / sintaxis de programación que le permite a la computadora imponer ciertas propiedades en un objeto (clase). Por ejemplo, supongamos que tenemos una clase de automóvil y una clase de scooter y una clase de camión. Cada una de estas tres clases debe tener una acción start_engine (). La forma en que el "motor arranca" para cada vehículo se deja a cada clase en particular, pero el hecho de que deben tener una acción start_engine es el dominio de la interfaz .

Como se muestra en la figura siguiente, una clase extiende otra clase, una interfaz extiende otra interfaz pero una clase implementa una interfaz.

Para más detalles

Se extiende : se utiliza para obtener los atributos de una clase principal en la clase base y puede contener métodos ya definidos que se pueden anular en la clase secundaria.

Implementos : Esto se usa para implementar una interfaz (clase primaria con firmas de funciones solamente pero no sus definiciones) definiéndola en la clase secundaria.

Hay una condición especial: "¿Qué sucede si quiero que una nueva interfaz sea hija de una interfaz existente?". En la condición anterior, la interfaz secundaria extiende la interfaz principal.

• A extiende B:

  A y B son ambas clases o ambas interfaces

• A implementa B

  A es una clase y B es una interfaz

• El caso restante donde A es una interfaz y B es una clase no es legal en Java.

Implements se usa para interfaces y extend se usa para extender una clase.

Para hacerlo más claro en términos más fáciles, una interfaz es como suena, una interfaz, un modelo que debe aplicar, seguir, junto con sus ideas.

Extender se usa para clases, aquí, está extendiendo algo que ya existe al agregarle más funcionalidad.

Algunas notas más:

una interfaz puede extender otra interfaz.

Y cuando necesite elegir entre implementar una interfaz o extender una clase para un escenario particular, vaya a implementar una interfaz. Porque una clase puede implementar múltiples interfaces pero extender solo una clase.

Cuando una subclase extiende una clase, permite que la subclase herede (reutilice) y anule el código definido en el supertipo. Cuando una clase implementa una interfaz, permite que un objeto creado a partir de la clase se use en cualquier contexto que espere un valor de la interfaz.

El verdadero problema aquí es que mientras implementamos cualquier cosa, simplemente significa que estamos usando esos métodos tal como están. No hay margen para el cambio en sus valores y tipos de retorno.

Pero cuando estamos ampliando algo, se convierte en una extensión de su clase. Puede cambiarlo, usarlo, reutilizarlo y no necesariamente tiene que devolver los mismos valores que en la superclase.

Utilizamos la subclase se extiende SuperClass sólo cuando la subclase quiere usar algunas funciones (métodos o variables de instancia) que ya se declaró en el SuperClass , o si quiero modificar ligeramente la funcionalidad del SuperClass (reemplazo de métodos). Pero digamos, por ejemplo, tengo una clase Animal ( Superclase ) y una clase Perro ( Subclase ) y hay algunos métodos que he definido en la clase Animal, por ejemplo. doEat (); , doSleep (); ... y muchos más.

Ahora, mi clase Perro puede simplemente extender la clase Animal, si quiero que mi perro use cualquiera de los métodos declarados en la clase Animal, puedo invocar esos métodos simplemente creando un objeto Perro. De esta manera puedo garantizar que tengo un perro que puede comer y dormir y hacer lo que yo quiera que haga el perro.

Ahora, imagina, un día, un amante de los gatos entra en nuestro espacio de trabajo y trata de extender la clase Animal (los gatos también comen y duermen). Ella hace un objeto Cat y comienza a invocar los métodos.

Pero, digamos, alguien intenta hacer un objeto de la clase Animal. Puedes decir cómo duerme un gato, puedes decir cómo come un perro, puedes decir cómo bebe un elefante. Pero no tiene ningún sentido hacer un objeto de la clase Animal. Porque es una plantilla y no queremos ninguna forma general de comer.

Por lo tanto, preferiría hacer una clase abstracta que nadie pueda instanciar pero que pueda usarse como plantilla para otras clases.

Para concluir, Interface no es más que una clase abstracta (una clase abstracta pura) que no contiene implementaciones de métodos, sino solo las definiciones (las plantillas). Entonces, quien implemente la interfaz solo sabe que tiene las plantillas de doEat (); y doSleep (); pero tienen que definir su propio doEat (); y doSleep (); métodos según su necesidad.

Se extiende solo cuando desea reutilizar alguna parte de la Superclase (pero tenga en cuenta que siempre puede anular los métodos de su Superclase según su necesidad) e implementar cuando desee las plantillas y desee definirlas por su cuenta (según su necesidad)

Compartiré contigo un fragmento de código: lo pruebas con diferentes conjuntos de entradas y miras los 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 palabras clave se utilizan al crear su propia nueva clase en el lenguaje Java.

Diferencia: implementssignifica que está utilizando los elementos de una interfaz Java en su clase. extendssignifica que está creando una subclase de la clase base que está extendiendo. Solo puede extender una clase en su clase secundaria, pero puede implementar tantas interfaces como desee.

Consulte la página de documentación de Oracle en la interfaz para obtener más detalles.

Esto puede ayudar a aclarar qué es una interfaz y las convenciones sobre su uso.

En los términos más simples extend se usa para heredar de una clase y los implementos se usan para aplicar una interfaz en su clase

se extiende :

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
}

si aún tiene confusión, lea esto: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Las clases y las interfaces son contratos . Proporcionan métodos y propiedades en las que se basan otras partes de una aplicación.

Usted define una interfaz cuando no está interesado en los detalles de implementación de este contrato. Lo único que debe preocuparse es que el contrato (la interfaz) existe.

En este caso, lo deja a la clase que implementa la interfaz para que se preocupe por los detalles de cómo se cumple el contrato. Solo las clases pueden implementar interfaces.

Extiende se utiliza cuando desea reemplazar los detalles de un contrato existente. De esta manera, reemplaza una forma de cumplir un contrato con una forma diferente. Las clases pueden extender otras clases, y las interfaces pueden extender otras interfaces.

Extendsse usa cuando desea atributos de una clase / interfaz principal en su clase / interfaz secundaria y implementsse usa cuando desea atributos de una interfaz en su clase.

Ejemplo:

1. Extiende usando class

   padre de clase {

   }

   clase Niño extiende Padre {

   }

2. Extiende usando la interfaz

   interfaz padre {

   }

   interfaz Niño extiende Padre {

   }

3. Implementos

interfaz A {

}

la clase B implementa A {

}

Combinación de extensiones e implementos.

interface A{

}

class B

{

}

class C implements A,extends B{

}

se extiende

• la clase se extiende solo una clase
• la interfaz extiende una o más interfaces

implementos

• la clase implementa una o más interfaces
• interfaces 'no puede' implementa nada

las clases abstractas también actúan como clase, con extensiones e implementos

Esas dos palabras clave están directamente vinculadas con Herencia, es un concepto central de OOP. Cuando heredamos alguna clase a otra clase, podemos usar extensiones, pero cuando vamos a heredar algunas interfaces a nuestra clase, no podemos usar extensiones, debemos usar implementos y podemos usar palabras clave extendidas para heredar la interfaz de otra interfaz.