¿Por qué las interfaces de Java no pueden tener un constructor pero sí las clases abstractas?

Requisito previo: interfaz y clase abstracta en Java.

Un Constructor es una función miembro especial que se utiliza para inicializar el objeto recién creado. Se llama automáticamente cuando se crea un objeto de una clase.

¿Por qué las interfaces no pueden tener el constructor?

• Una interfaz es una abstracción completa de clase. Todos los miembros de datos presentes en la interfaz son públicos, estáticos y finales de forma predeterminada. Todos los campos finales estáticos deben tener valores asignados en el momento de la declaración; de lo contrario, arrojará un error de compilación que dice » variable nombre_variable no inicializado en el constructor predeterminado «.
• Los métodos dentro de la interfaz son abstractos públicos de forma predeterminada, lo que significa que la implementación del método no puede ser proporcionada por la interfaz en sí, debe ser proporcionada por la clase de implementación. Por lo tanto, no es necesario tener un constructor dentro de la interfaz.
• Se utiliza un constructor para inicializar miembros de datos no estáticos y como no hay miembros de datos no estáticos en la interfaz, no hay necesidad de constructor.
• Los métodos presentes en la interfaz solo se declaran no definidos. Como no hay implementación de métodos, no hay necesidad de crear objetos para llamar a métodos en la interfaz y, por lo tanto, no tiene sentido tener un constructor en ella.
• Si intentamos crear un constructor dentro de la interfaz, el compilador dará un error de tiempo de compilación.

// Java program that demonstrates why
// interface can not have a constructor
 
// Creating an interface
interface Subtraction {
 
    // Creating a method, by default
    // this is a abstract method
    int subtract(int a, int b);
}
 
// Creating a class that implements
// the Subtraction interface
class GFG implements Subtraction {
 
    // Defining subtract method
    public int subtract(int a, int b)
    {
        int k = a - b;
        return k;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Creating an instance of
        // GFG class
        GFG g = new GFG();
        System.out.println(g.subtract(20, 5));
    }
}

15

En el programa anterior, hemos creado una interfaz Subtraction que define un método subtract() , cuya implementación la proporciona la clase GFG . Para llamar a un método, necesitamos crear un objeto, ya que los métodos dentro de la interfaz son abstractos públicos por defecto, lo que significa que el método dentro de la interfaz no tiene el cuerpo. Por lo tanto, no hay necesidad de llamar al método en la interfaz. Dado que no podemos llamar a los métodos en la interfaz, no es necesario crear el objeto para la interfaz y no es necesario tener un constructor en él.

¿Por qué las clases abstractas tienen un constructor ? 

• El objetivo principal del constructor es inicializar el objeto recién creado. En la clase abstracta, tenemos una variable de instancia, métodos abstractos y métodos no abstractos. Necesitamos inicializar los métodos no abstractos y las variables de instancia, por lo tanto, las clases abstractas tienen un constructor.
• Además, incluso si no proporcionamos ningún constructor, el compilador agregará un constructor predeterminado en una clase abstracta.
• Una clase abstracta puede ser heredada por cualquier número de subclases, por lo que pueden usar la funcionalidad del constructor presente en la clase abstracta.
• El constructor dentro de la clase abstracta solo se puede llamar durante el enstringmiento del constructor , es decir, cuando creamos una instancia de subclases. Esta es también una de las razones por las que la clase abstracta puede tener un constructor.

// A Java program to demonstrates
// an abstract class with constructors
 
// Creating an abstract class Car
abstract class Car {
 
  // Creating a constructor in
  // the abstract class
    Car() {
      System.out.println("car is created");
    }
}
 
// A class that extends the
// abstract class Car
class Maruti extends Car {
 
  // Method defining inside
  // the Maruti class
    void run() {
      System.out.println("Maruti is running");
    }
}
 
class GFG {
 
    public static void main(String[] args)
    {
        Maruti c = new Maruti();
        c.run();
    }
}

car is created
Maruti is running