En este artículo hablaremos de diferencia entre la clase abstracta y la interfaz en Java con ejemplos. He cubierto la clase abstracta y la interfaz en tutoriales separados de conceptos de programación orientada a objetos, por lo que recomiendo leerlos primero, antes de analizar las diferencias.
1. Clase abstracta en Java
2. Interfaz Java

Clase abstracta Interfaz
1 Una clase abstracta solo puede extender una clase o una clase abstracta a la vez Una interfaz puede ampliar cualquier número de interfaces a la vez
2 Una clase abstracta puede extender otra clase concreta (regular) o una clase abstracta Una interfaz solo puede extender otra interfaz
3 Una clase abstracta puede tener métodos tanto abstractos como concretos Una interfaz solo puede tener métodos abstractos
4 En la clase abstracta, se requiere la palabra clave “resumen” para declarar un método como abstracto. En una interfaz, la palabra clave “resumen” es opcional para declarar un método como resumen.
5 Una clase abstracta puede tener métodos abstractos públicos y protegidos Una interfaz solo puede tener métodos abstractos públicos
6 Una clase abstracta puede tener una variable final estática, final o estática con cualquier especificador de acceso la interfaz solo puede tener una variable estática pública final (constante)

Cada uno de los puntos mencionados anteriormente se explica con un ejemplo a continuación:

Clase abstracta vs interfaz en Java

Diferencia n. 1: la clase abstracta solo puede extender una clase o clase abstracta a la vez

class Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
abstract class Example2{
   public void display2(){
      System.out.println("display2 method");
   }
}
abstract class Example3 extends Example1{
   abstract void display3();
}
class Example4 extends Example3{
   public void display3(){
      System.out.println("display3 method");
   }
}
class Demo{
   public static void main(String args[]){
       Example4 obj=new Example4();
       obj.display3();
   }
}

Producción:

display3 method

La interfaz puede ampliar cualquier número de interfaces a la vez

//first interface
interface Example1{
    public void display1();
}
//second interface
interface Example2 {
    public void display2();
}
//This interface is extending both the above interfaces
interface Example3 extends Example1,Example2{
}
class Example4 implements Example3{
    public void display1(){
        System.out.println("display2 method");
    }
    public void display2(){
        System.out.println("display3 method");
    }
}
class Demo{
    public static void main(String args[]){
        Example4 obj=new Example4();
        obj.display1();
    }
}

Producción:

display2 method

Diferencia n. 2: la clase abstracta puede ser extendida (heredada) por una clase abstracta o una clase

class Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
abstract class Example2{
   public void display2(){
       System.out.println("display2 method");
   }
}
abstract class Example3 extends Example2{
   abstract void display3();
}
class Example4 extends Example3{
   public void display2(){
       System.out.println("Example4-display2 method");
   }
   public void display3(){
       System.out.println("display3 method");
   }
}
class Demo{
   public static void main(String args[]){
       Example4 obj=new Example4();
       obj.display2();
   }
}

Producción:

Example4-display2 method

Las interfaces solo pueden ampliarse mediante interfaces. Las clases deben implementarlas en lugar de ampliarlas.

interface Example1{
    public void display1();
}
interface Example2 extends Example1{
}
class Example3 implements Example2{
   public void display1(){
      System.out.println("display1 method");
   }
}
class Demo{
   public static void main(String args[]){
      Example3 obj=new Example3();
      obj.display1();
   }
}

Producción:

display1 method

Diferencia n. 3: la clase abstracta puede tener métodos tanto abstractos como concretos

abstract class Example1 {
   abstract void display1();
   public void display2(){
     System.out.println("display2 method");
   }
}
class Example2 extends Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
class Demo{
   public static void main(String args[]){
     Example2 obj=new Example2();
     obj.display1();
   }
}

La interfaz solo puede tener métodos abstractos, no pueden tener métodos concretos

interface Example1{
   public abstract void display1();
}
class Example2 implements Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2();
      obj.display1();
   }
}

Producción:

display1 method

Diferencia n. ° 4: en la clase abstracta, se requiere la palabra clave ‘resumen’ para declarar un método como abstracto

abstract class Example1{
   public abstract void display1();
}

class Example2 extends Example1{
   public void display1(){
      System.out.println("display1 method");
   }
   public void display2(){
      System.out.println("display2 method");
   }
}
class Demo{
   public static void main(String args[]){ 
       Example2 obj=new Example2(); 
       obj.display1();
   }
}

En las interfaces, la palabra clave “abstracto” es opcional para declarar un método como abstracto porque todos los métodos son abstractos por defecto.

interface Example1{
    public void display1();
}
class Example2 implements Example1{
    public void display1(){
        System.out.println("display1 method");
    }
    public void display2(){
        System.out.println("display2 method");
    } 
}
class Demo{
   public static void main(String args[]){
       Example2 obj=new Example2();
       obj.display1();
   }
}

Diferencia n. 5: la clase abstracta puede tener métodos abstractos protegidos y públicos

abstract class Example1{
   protected abstract void display1();
   public abstract void display2();
   public abstract void display3();
}
class Example2 extends Example1{
   public void display1(){
       System.out.println("display1 method");
   }
   public void display2(){
      System.out.println("display2 method");
   }
   public void display3(){
      System.out.println("display3 method");
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2();
      obj.display1();
   }
}

La interfaz solo puede tener métodos abstractos públicos

interface Example1{
   void display1();
}
class Example2 implements Example1{
   public void display1(){
      System.out.println("display1 method");
   }
   public void display2(){ 
      System.out.println("display2 method");
   }
}
class Demo{
   public static void main(String args[]){
       Example2 obj=new Example2();
       obj.display1();
   }
}

Diferencia n. 6: La clase abstracta puede tener variables finales estáticas, finales o estáticas con cualquier especificador de acceso

abstract class Example1{
   private int numOne=10;
   protected final int numTwo=20;
   public static final int numThree=500;
   public void display1(){
      System.out.println("Num1="+numOne);
   }
}
class Example2 extends Example1{
   public void display2(){
      System.out.println("Num2="+numTwo);
      System.out.println("Num2="+numThree);
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2(); 
      obj.display1();
      obj.display2();
   }
}

La interfaz solo puede tener una variable estática pública final (constante)

interface Example1{
   int numOne=10;
}
class Example2 implements Example1{
   public void display1(){
      System.out.println("Num1="+numOne);
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2();
      obj.display1();
   }
}
leer  Herencia jerárquica en java con programa de ejemplo

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *