Diferencia entre clase abstracta e interfaz en Java

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, qué funciona (mostrar), cómo funciona (ocultar). Tanto la clase abstracta como la interfaz se utilizan para la abstracción; en adelante, la interfaz y la clase abstracta son requisitos previos obligatorios.

Clase abstracta vs Interfaz 

• Tipo de métodos: la interfaz solo puede tener métodos abstractos. Una clase abstracta puede tener métodos abstractos y no abstractos. Desde Java 8, también puede tener métodos predeterminados y estáticos.
• Variables finales: las variables declaradas en una interfaz Java son, por defecto, finales. 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 frente a abstracción: se puede implementar una interfaz Java con la palabra clave «implementos» y una clase abstracta se puede ampliar con la palabra clave «extiende».
• Múltiples implementaciones: una interfaz puede extender una o más interfaces de Java, una clase abstracta puede extender otra clase de Java e implementar múltiples interfaces de Java.
• Accesibilidad de los miembros de datos: los miembros de una interfaz Java son públicos de forma predeterminada. Una clase abstracta de Java puede tener miembros de clase como privados, protegidos, etc.

Ejemplo 1-A:

// 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é sucede si no tenemos ningún código común entre el rectángulo y el círculo? Vaya con la interfaz. 

Ejemplo 1-B:

// 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 declaraciones 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, a través de un método, pueda acceder y modificar el estado del objeto al que pertenecen.
• Puede esperar que las clases que amplían una clase abstracta tengan muchos métodos o campos comunes, o requieran modificadores de acceso que no sean públicos (como protegido y privado).

Considere usar interfaces si alguna de estas declaraciones se aplica a su situación:  

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

También puede optar por Quiz sobre este tema.

Este artículo es una contribución de Nitsdheerendra . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.