Pregunta Implementos vs extends: ¿Cuándo usar? ¿Cual es la diferencia?


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


560
2018-05-31 18:25


origen


Respuestas:


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 de C ++ de una interfaz sería una clase abstracta (no EXACTAMENTE igual pero más o menos).

También 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 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

Te sugiero que hagas más investigación sobre vinculación dinámica, polimorfismo y herencia general en la programación orientada a objetos


578
2018-05-31 18:27



Noté que tienes algunas preguntas C ++ en tu perfil. Si entiendes el concepto de herencia múltiple de C ++ (refiriéndose a las clases que heredan características de más de una clase), Java no permite esto, pero tiene palabra clave interface, que es algo así como una clase virtual pura en C ++. Como lo mencionaron muchas personas, extend una clase (y solo puedes extender desde una), y tú 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).


73
2018-05-31 18:36



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

implements es para cuando estás implementando un interfaz.

Este es un buen lugar para comenzar: Interfaces y Herencia.


34
2018-05-31 18:27



UN class solo puede "implementar" una interface. Una clase solo "extiende" una class. Del mismo modo, un interface puede extender otro interface.

UN class solo puede extenderse otro class. UN class puede implementar varios interfaces.

Si, en cambio, estás más interesado en saber cuándo usar abstract classes y interfaces, refiérase a este hilo: Interfaz vs clase abstracta (OO general)


29
2018-05-31 18:29



En general implementos utilizado para implementar una interfaz y se extiende usado para extensión del comportamiento de clase base o abstracto clase.

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

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

Con la versión java 8, la interfaz puede tener defecto métodos en la interfaz, que proporciona la implementación en la interfaz en sí.

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

Interfaz vs clase abstracta (OO general)

Ejemplo para entender 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 se extendieron remember() y protectOwner() compartiendo name,lifeExpentency de Animal
  2. El gato puede escalar () pero Dog no. Dog puede pensar () pero Cat no lo hace. 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 repasar estos ejemplos, puedes entender 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.


27
2018-01-24 14:59



Una interfaz es una descripción de las acciones que un objeto puede hacer ... por ejemplo, cuando acciona un interruptor de luz, la luz se enciende, no le importa cómo, solo eso. En la Programación Orientada a Objetos, una Interfaz es una descripción de todas las funciones que un objeto debe tener para ser una "X". Nuevamente, como ejemplo, cualquier cosa que "ACTS LIKE" tenga 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 haga cumplir 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 permite que la computadora aplique ciertas propiedades en un objeto (clase). Por ejemplo, digamos que tenemos una clase de auto 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 se inicia el "motor" para cada vehículo se deja para cada clase en particular, pero el hecho de que deben tener una acción start_engine es el dominio del interfaz.


18
2017-08-25 20:45



  • A se 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.


11
2018-05-25 07:39



Extiende : Esto se usa para obtener atributos de una clase principal en la clase base y puede contener métodos ya definidos que pueden anularse en la clase secundaria.

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

Hay una condición especial: "¿Qué pasa si quiero que una interfaz nueva sea hija de una interfaz existente?". En la condición anterior, la interfaz del niño se extiende la interfaz padre


11
2017-12-08 09:23



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

Para hacerlo más claro en términos más fáciles, una interfaz es como su sonido, 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 funcionalidades.

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, implemente una interfaz. Porque una clase puede implementar múltiples interfaces pero extender solo una clase.


9
2018-05-31 18:27



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.

La verdadera clave aquí es que mientras implementamos algo simplemente significa que estamos usando esos métodos tal como son. No hay margen para el cambio en sus valores y tipos de devolución.

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


6
2018-01-16 11:11