Tanto la clase abstracta como la interfaz se utilizan para definir contratos en la programación orientada a objetos, pero existen algunas diferencias clave entre ellas.

Diferencia entre clase abstracta e interfaz: -

Definición: Una clase abstracta es una clase de la que no se pueden crear instancias y puede contener métodos tanto abstractos como no abstractos. Una interfaz, por otro lado, es un contrato que especifica un conjunto de métodos que una clase debe implementar.

Implementación de métodos: en una clase abstracta, algunos métodos se pueden implementar, mientras que otros se dejan abstractos, lo que significa que no tienen implementación y deben ser anulados por subclases concretas. Por el contrario, todos los métodos en una interfaz son abstractos por defecto y deben ser implementados por cualquier clase que implemente la interfaz.

Herencia: una clase puede heredar solo de una clase abstracta, pero puede implementar múltiples interfaces. Esto se debe a que una clase abstracta representa un tipo de objeto, mientras que una interfaz representa un conjunto de comportamientos.

Modificadores de acceso: las clases abstractas pueden tener modificadores de acceso como público, protegido y privado para sus métodos y propiedades, mientras que las interfaces solo pueden tener acceso público.

agregar en matriz java

Variables: una clase abstracta puede tener variables miembro, mientras que una interfaz no.

En resumen, las clases abstractas se utilizan para proporcionar una clase base de la que heredan subclases concretas, mientras que las interfaces se utilizan para definir un conjunto de métodos que una clase debe implementar. Las clases abstractas pueden tener métodos implementados y abstractos, mientras que las interfaces solo pueden tener métodos abstractos. Las clases pueden heredar de una sola clase abstracta, pero pueden implementar múltiples interfaces.

Como sabemos, la abstracción se refiere a ocultar la implementación interna de la función y solo mostrar la funcionalidad a los usuarios. es decir, mostrar solo las funciones requeridas y ocultar cómo se implementan esas funciones detrás de escena. Mientras que una interfaz es otra forma de lograr la abstracción en Java. Ambos clase abstracta y interfaz se utilizan para la abstracción; de ahora en adelante, la interfaz y la clase abstracta son requisitos previos requeridos.

Clase abstracta vs interfaz

• Tipo de métodos: La interfaz sólo puede tener métodos abstractos. Mientras que una clase abstracta puede tener métodos abstractos y métodos concretos. Desde Java 8, también puede tener métodos estáticos y predeterminados. A partir de Java 9, también puede tener métodos concretos privados.

• Nota: Los métodos concretos son aquellos métodos que tienen su definición completa pero que también pueden anularse en la clase heredada. Sin embargo, si hacemos el método concreto como FINAL no se puede anular en la clase heredada porque declarar un método como medio final – su implementación está completa .

• Variables finales: Las variables declaradas en una interfaz Java son finales por defecto. Una clase abstracta puede contener variables no finales.
• Tipo de variables: La clase abstracta puede tener variables finales, no finales, estáticas y no estáticas. La interfaz solo tiene variables estáticas y finales.
• Implementación: La clase abstracta puede proporcionar la implementación de la interfaz. La interfaz no puede proporcionar la implementación de una clase abstracta.
• Herencia versus abstracción: Se puede implementar una interfaz Java usando la palabra clave implementos y una clase abstracta se puede ampliar usando la palabra clave se extiende .
• Múltiples implementaciones: Una interfaz puede ampliar una o más interfaces Java; una clase abstracta puede extender otra clase Java e implementar múltiples interfaces Java.
• Herencia múltiple: La herencia múltiple se puede lograr parcialmente mediante el uso de interfaces, mientras que no se puede hacer lo mismo mediante el uso de clases abstractas. Porque en Java, una clase puede implementar múltiples interfaces, pero una clase no puede extenderse desde otras múltiples clases porque eso simplemente no es posible en Java, ya que conduciría al problema del diamante.
• Accesibilidad de los datos de los miembros: Los miembros (variables) de una interfaz Java son finales de forma predeterminada. Una clase abstracta de Java puede tener miembros de clase como privados, protegidos, etc.

Características de la clase abstracta: -

Una clase abstracta es un tipo especial de clase en la programación orientada a objetos de la que no se puede crear una instancia directamente. En cambio, sirve como modelo o plantilla para derivar otras clases. Una clase abstracta:

1. No se puede crear una instancia : No se pueden crear instancias de clases abstractas directamente, lo que significa que no se pueden crear objetos de una clase abstracta.
2. Contiene al menos una función virtual pura. : Las clases abstractas deben contener al menos una función virtual pura, lo que significa que la función no tiene implementación y debe ser implementada por cualquier clase derivada.
3. Puede contener métodos tanto abstractos como no abstractos. : Las clases abstractas pueden tener métodos tanto abstractos como no abstractos. Los métodos no abstractos tienen una implementación completa y se pueden llamar directamente.
4. Puede tener constructores y destructores. : Las clases abstractas pueden tener constructores y destructores como cualquier otra clase.
5. Puede tener variables miembro : Las clases abstractas pueden tener variables miembro, que son variables que pertenecen a un objeto de la clase.
6. Se puede utilizar como clase base. : Las clases abstractas se pueden utilizar como clase base para otras clases, lo que significa que otras clases pueden heredarlas.

En general, las clases abstractas se utilizan para definir una interfaz o comportamiento común que pueden compartir varias clases relacionadas, pero con implementaciones específicas en cada clase derivada.

Ejemplo 1: (para clase abstracta)

abstract class sunstar {    abstract void printInfo(); } class employee extends sunstar {  void printInfo()  {  String name = 'avinash';  int age = 21;  float salary = 222.2F;  System.out.println(name);  System.out.println(age);  System.out.println(salary);  } } class base {  public static void main(String args[])  {  sunstar s = new employee();  s.printInfo();  } }>

avinash 21 222.2>

Ejemplo 2: (para clase abstracta)

// Java Program to Illustrate Concept of // Abstract Class // Importing required classes import java.io.*; // Class 1 // Helper abstract class abstract class Shape {  // Declare fields  String objectName = ' ';  // Constructor of this class  Shape(String name) { this.objectName = name; }  // Method  // Non-abstract methods  // Having as default implementation  public void moveTo(int x, int y)  {  System.out.println(this.objectName + ' '  + 'has been moved to'  + ' x = ' + x + ' and y = ' + y);  }  // Method 2  // Abstract methods which will be  // implemented by its subclass(es)  abstract public double area();  abstract public void draw(); } // Class 2 // Helper class extending Class 1 class Rectangle extends Shape {  // Attributes of rectangle  int length, width;  // Constructor  Rectangle(int length, int width, String name)  {  // Super keyword refers to current instance itself  super(name);  // this keyword refers to current instance itself  this.length = length;  this.width = width;  }  // Method 1  // To draw rectangle  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  // Method 2  // To compute rectangle area  @Override public double area()  {  // Length * Breadth  return (double)(length * width);  } } // Class 3 // Helper class extending Class 1 class Circle extends Shape {  // Attributes of a Circle  double pi = 3.14;  int radius;  // Constructor  Circle(int radius, String name)  {  // Super keyword refers to parent class  super(name);  // This keyword refers to current instance itself  this.radius = radius;  }  // Method 1  // To draw circle  @Override public void draw()  {  // Print statement  System.out.println('Circle has been drawn ');  }  // Method 2  // To compute circle area  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 4 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape class reference.  Shape rect = new Rectangle(2, 3, 'Rectangle');  System.out.println('Area of rectangle: '  + rect.area());  rect.moveTo(1, 2);  System.out.println(' ');  // Creating the Objects of circle class  Shape circle = new Circle(2, 'Circle');  System.out.println('Area of circle: '  + circle.area());  circle.moveTo(2, 4);  } }>

Area of rectangle: 6.0 Rectangle has been moved to x = 1 and y = 2 Area of circle: 12.56 Circle has been moved to x = 2 and y = 4>

¿Qué pasa si no tenemos ningún código común entre el rectángulo y el círculo? Entonces opte por la interfaz.

Interfaz:

Características de la interfaz:

Una interfaz:

1. Define un conjunto de métodos y propiedades: Una interfaz define un conjunto de métodos y propiedades que deben ser implementados por cualquier clase o estructura que implemente la interfaz.
2. Proporciona un protocolo común: Las interfaces proporcionan un protocolo común que permite que diferentes componentes de software se comuniquen entre sí.
3. Soporta polimorfismo: Se puede utilizar una interfaz para lograr polimorfismo, lo que significa que los objetos de diferentes clases pueden tratarse como si pertenecieran al mismo tipo, siempre que implementen la misma interfaz.
4. Permite la separación de preocupaciones: Las interfaces permiten la separación de preocupaciones, lo que significa que diferentes partes de un sistema de software se pueden desarrollar independientemente unas de otras, siempre que cumplan con las especificaciones de la interfaz.
5. Mejora la reutilización del código: Las interfaces mejoran la reutilización del código al permitir que diferentes componentes de software reutilicen la misma base de código, siempre que implementen la misma interfaz.
6. Hace cumplir los patrones de diseño: Las interfaces se pueden utilizar para aplicar patrones de diseño, como el patrón Adaptador, al exigir que las clases de implementación implementen ciertos métodos o propiedades.
7. Facilita las pruebas: Las interfaces facilitan las pruebas al permitir que los componentes de software se prueben de forma independiente entre sí, utilizando objetos simulados que implementan la interfaz.

Ejemplo 1: para interfaz

¿Cuál es el tamaño de la pantalla de mi computadora?

// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

Ejemplo 2: para interfaz

// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

¿Cuándo usar qué?

Considere usar clases abstractas si alguna de estas afirmaciones se aplica a su situación:

• En la aplicación Java, hay algunas clases relacionadas que necesitan compartir algunas líneas de código, luego puede colocar estas líneas de código dentro de la clase abstracta y esta clase abstracta debe ampliarse con todas estas clases relacionadas.
• Puede definir los campos no estáticos o no finales en la clase abstracta para que mediante un método pueda acceder y modificar el estado del objeto al que pertenecen.
• Puede esperar que las clases que extienden una clase abstracta tengan muchos métodos o campos comunes, o requieran modificadores de acceso distintos de los públicos (como protegidos y privados).

Considere el uso de interfaces si alguna de estas afirmaciones se aplica a su situación:

• Es una abstracción total, todos los métodos declarados dentro de una interfaz deben ser implementados por la(s) clase(s) que implementan esta interfaz.
• Una clase puede implementar más de una interfaz. Se llama herencia múltiple.
• Quiere especificar el comportamiento de un tipo de datos particular pero no le preocupa quién implementa su comportamiento.