Constructors in abstract classes? [duplicate]

Answer 1

By adding a constructor to an abstract class you can force the child classes to make a call to super in order to initialize some fields. Example:

abstract class Person {
   private String name;
   public Person(String name) {
      this.name = name;
   }
}

class SoccerPlayer extends Person {
   public SoccerPlayer(String name) {
     super(name);
   }
}
Person p = new SoccerPlayer("Ronaldo");

Answer 2

Think of an abstract class like a blueprint of a derived one up to 1 or 2 methods that must be implemented in derived classes. It makes sense to implement as much as possible/sensible in the abstract class, including the constructor.

Answer 3

Constructors in baseclasses can be used to do constructor chaining, so you can init your base class fields for example. In this constructor you can put some businesslogic to validate the parameters

example contructor chainging:

public abstract class Person
{
    protected readonly string Name;

    protected Person(string name)
    {
        //Do some validations or regex on the name for example so you know all person names match your business rules
        Name = name;
    }
}

public class Employee : Person
{
    private decimal _salary;

    public Employee(string name, decimal salary)
        : base(name)
    {
         _salary = salary;
    }
}

Answer 4

Abstract class represents a more top level of objects, in some cases these top level objects need values to be set at the creation of the object by the business perspective. Missing to set this value could cause business object to fail. The constructors are supported in the abstract class to enforce setting a value when building the class (otherwise it could be forgotten). For example,

public abstract class AccountHolder 
{
}

    public abstract class Account
    {
         private AccountHolder holder;

    public Account(AccountHolder holder)
    {
    this.holder = holder;
    }
    }

    public class FixedDeposit extends Account
    {
    public FixedDeposit (AccountHolder holder)
    {
    super(holder)
    }
    }

Here we cannot imagine a account without a holder, so it's essential to the business to set the holder when creating the object. Setting it in the base level ensures it will be forced to set when adding new types of sub classes. Hence it's to ensure 'Open for extensions but closed for modification' one of the SOLID principles.

Answer 5

You still need to be able to create a sub-class which must call its parent's constructor and its parents etc.

The real question is why can you make an abstract classes constructor public. ;)

Answer 6

In some cases we need to initialize the fields in the abstract class. If it is a empty constructor this is done implicit by the constructor in the child class, otherwise we use super(parameters). A constructor with parameters forces the child class to specify some parameters (not necessarily from its own parameters).

All in all, this means that the constructor is used by the child class constructor and not from the "outside".