Constructor de clases abstractas en Java

Un constructor se usa para inicializar un objeto llamado por su nombre, y el nombre del constructor es el mismo que el nombre de la clase.

La clase abstracta se declara con una palabra clave abstracta, las clases abstractas también tienen un constructor, y si no definimos ningún constructor en la clase abstracta, JVM nos dará uno predeterminado.

Este tutorial demuestra cómo crear un constructor en una clase abstracta en Java.

Constructor de clases abstractas en Java

Cuando indicamos que una clase es abstracta, no se puede instanciar, pero eso no significa que no pueda tener el constructor. La clase abstracta puede tener un constructor en dos condiciones.

1. Cuando queremos realizar la inicialización de los campos de una clase abstracta antes de realizar la instanciación de una subclase.
2. Cuando hemos definido campos finales en la clase abstracta, pero no están inicializados en la declaración, se puede usar el constructor para inicializar estos campos.

Si no definimos un constructor, la JVM definirá uno predeterminado para nosotros. Antes de definir un constructor, debemos considerar los siguientes puntos.

1. Los constructores de la subclase pueden llamar a un constructor de la clase abstracta, y tendrán que llamarlo si no hay ningún constructor de argumentos en la clase abstracta.
2. Todos los constructores deben definirse como protegidos en la clase abstracta porque definirlos como públicos no tiene ningún beneficio.
3. También podemos definir más de un constructor con diferentes argumentos.

Veamos un ejemplo para el constructor de clases abstractas que calculará el salario bruto, los impuestos y el salario neto al extender la clase abstracta con el constructor.

Ejemplo de código:

package delftstack;

abstract class SalaryCal {
  double salary;
  protected SalaryCal() {
    salary = 0;
  }
  protected SalaryCal(double a) {
    salary = a;
  }
  // Calculate is now an abstract method
  abstract double Calculate();
}

class Salary extends SalaryCal {
  Salary(double a) {
    super(a);
  }
  // override calculate for Salary
  double Calculate() {
    System.out.println("Inside the Calculate method for Salary.");
    double allowance = salary * 0.1; // 10 Percent other allowances
    return salary + allowance;
  }
}

class Tax extends SalaryCal {
  Tax(double a) {
    super(a);
  }
  // override calculate for Tax
  double Calculate() {
    System.out.println("Inside the Calculate method for Tax.");
    return salary * 0.2; // 20 percent tax
  }
}

public class Abstract_Constructor {
  public static void main(String args[]) {
    // SalaryCal Demo = new SalaryCal(1000); // illegal now because we can not instantiate an object
    double Salary = 1000;
    Salary S = new Salary(Salary);
    Tax T = new Tax(Salary);

    SalaryCal Salary_Calculation; // this is OK, no object is created

    // Gross Salary Calculation
    Salary_Calculation = S;
    double gross_salary = Salary_Calculation.Calculate();
    System.out.println("The Gross Salary is " + gross_salary);

    // Tax Calculation
    Salary_Calculation = T;
    double salary_tax = Salary_Calculation.Calculate();
    System.out.println("The total Tax on Salary is " + salary_tax);

    // Net Salary
    double net_salary = gross_salary - salary_tax;
    System.out.println("The Net Salary is " + net_salary);
  }
}

La superclase SalaryCal se declara abstracta y tiene dos constructores, uno sin argumentos que es el predeterminado, y otro con argumentos. Las dos clases concretas, Salario e Impuesto, calculan el salario bruto y el impuesto.

Los constructores abstractos se utilizan con frecuencia para el cálculo de salarios. El método principal también demuestra que no podemos instanciar la clase Abstract.

Podemos usar la clase abstracta para obtener los valores de clases concretas.

Producción :

Inside the Calculate method for Salary.
The Gross Salary is 1100.0
Inside the Calculate method for Tax.
The total Tax on Salary is 200.0
The Net Salary is 900.0