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.

extends es para extender 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).

Además, java no admite 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 

Te sugiero que hagas más investigaciones sobre la unión dinámica, el polymorphism y, en general, la herencia en la progtwigción orientada a objetos

Noté que tienes algunas preguntas C ++ en tu perfil. Si comprende el concepto de herencia múltiple de C ++ (haciendo referencia a las clases que heredan características de más de una clase), Java no permite esto, pero sí tiene una interface palabras clave, 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) e implement una interfaz, pero tu clase puede implementar tantas interfaces como desees.

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).

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

implements es para cuando está implementando una interfaz .

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

Una class solo puede “implementar” una interface . Una clase solo “extiende” una class . Del mismo modo, una interface puede ampliar otra interface .

Una class solo puede extender otra class . Una class puede implementar varias interface .

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

En general, los implementos utilizados para implementar una interfaz se extienden y se utilizan 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 : está implementando un contrato. La clase que implementa la interfaz ” tiene una ” capacidad.

Con la versión 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 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. El perro y el gato son animales y extendieron remember () y protectOwner () al compartir el name,lifeExpentency from Animal
  2. El gato puede escalar () pero Dog no. Dog puede pensar () pero Cat no . Estas capacidades específicas se agregan a Cat y Dog al implementar 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.

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 Progtwigció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 / syntax de progtwigció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 de la interfaz .

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

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

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 hija extiende la interfaz principal.

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.

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.

Ambas palabras clave se utilizan al crear su propia clase nueva en el lenguaje Java.

Diferencia: implements significa que estás usando los elementos de una interfaz Java en tu clase. extends significa que estás creando una subclase de la clase base que estás 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 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, extends se usa para heredar de una clase e implements se usa para aplicar una interfaz en su clase

extiende :

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

implementos :

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

si todavía 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

Usamos SubClass extends SuperClass solo cuando la subclase quiere usar alguna funcionalidad (métodos o variables de instancia) que ya está declarada en la SuperClass , o si quiero modificar ligeramente la funcionalidad de la SuperClass ( Overriding del método). Pero digamos, por ejemplo, tengo una clase Animal ( SuperClass ) y una clase Dog ( SubClass ) y hay pocos métodos que he definido en la clase Animal, por ejemplo. doEat (); , doSleep (); … y muchos más.

Ahora, mi clase Dog 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 Dog. De esta forma puedo garantizar que tengo un perro que puede comer y dormir y hacer todo lo que quiero que el perro haga.

Ahora, imagine, un día, un amante de los gatos entra en nuestro espacio de trabajo e intenta 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 crear instancias, pero que se puede usar como plantilla para otras clases.

Entonces, 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.

Extiende solo cuando quiere reutilizar una parte de la SuperClass (pero tenga en cuenta que siempre puede anular los métodos de su SuperClass según sus necesidades) e implementar cuando desee las plantillas y desee definirlas por su cuenta (de acuerdo a su necesidad).

Compartiré contigo un fragmento de código: lo pruebas con diferentes conjuntos de entradas y observas 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(); } 

Como se muestra en la figura que figura a continuación, una clase amplía otra clase, una interfaz amplía otra interfaz pero una clase implementa una interfaz. enter image description here

Para más detalles

Extends se usa cuando desea atributos de la clase / interfaz principal en su clase / interfaz e implements se utiliza cuando desea atributos de una interfaz en su clase.

Ejemplo:

  1. Se extiende usando clase

    clase padre {

    }

    clase Child extends Parent {

    }

  2. Se 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{ } 
    Intereting Posts