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

Solución:

extends es para extensión una clase.

implements es 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 lo mismo pero bastante).

Además, java no es compatible herencia múltiple para 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 ampliando 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

Además, tenga en cuenta que un @Override La etiqueta no es necesaria para implementar una interfaz, ya que no hay nada en los métodos de interfaz originales. ser anulado

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

Noto 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 permite esto, pero tiene palabra clave interface, que es como una clase virtual pura en C ++. Como lo ha mencionado mucha gente, extend una clase (y solo puede extenderse desde una), y implement una 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 implementos utilizado para implementar un interfaz y se extiende usado para extensión del comportamiento de la clase base o abstracto clase.

se extiende: Una clase derivada puede ampliar una clase base. Puede redefinir el comportamiento de una relación establecida. Clase derivada “es un“tipo de clase base

implementos: Está implementando un contrato. La clase que implementa la interfaz “tiene un“capacidad.

Con la versión de Java 8, la interfaz puede tener defecto métodos en la interfaz, que proporciona la implementación en la propia interfaz.

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

producción:

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 se extendieron remember() y protectOwner() compartiendo name,lifeExpentency desde Animal
2. El gato puede trepar () pero el perro no. El perro puede pensar () pero el gato no. Estas capacidades específicas se agregan a Cat y Dog implementando esa capacidad.
3. El hombre no es un animal pero puede Think,Learn,Apply,Climb

Al revisar 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 mediante la extensión de las clases base.

---

---

Utiliza Nuestro Buscador