Can an abstract class have a constructor?

Abstract class constructors:

• Allowed. An abstract class can have zero, one, or many constructors, including parameterized ones.
• Not directly instantiated. new AbstractAccount() does not compile. You instantiate a concrete subclass.
• Called via super(). When you write new SavingsAccount(...), the SavingsAccount constructor calls super(...) which runs the abstract class constructor.
• Purpose. Initialize common fields (accountId, holderName) that all subclasses share.

How does it work?

public abstract class Account {
    private final String accountId;
    private final String holderName;

    // Abstract class constructor – called via super() from subclasses
    protected Account(String accountId, String holderName) {
        this.accountId = accountId;
        this.holderName = holderName;
        System.out.println("Account initialized: " + accountId);
    }

    public abstract BigDecimal calculateInterest();

    public String getAccountId() { return accountId; }
}

public class SavingsAccount extends Account {
    private double rate;

    public SavingsAccount(String accountId, String holderName, double rate) {
        super(accountId, holderName);  // calls abstract class constructor
        this.rate = rate;
    }

    @Override
    public BigDecimal calculateInterest() {
        return new BigDecimal(rate / 100);
    }
}

// new Account("SAV2001", "Rajesh");  // COMPILE ERROR: Account is abstract
SavingsAccount sa = new SavingsAccount("SAV2001", "Rajesh", 4.0);  // OK
// Output: Account initialized: SAV2001

Why would an abstract class need a constructor?

• Initialize common fields. accountId, holderName, createdAt – shared by all account types.
• Validate inputs. Ensure accountId is not null, holderName is not empty.
• Enforce invariants. Every account must have a valid ID, regardless of the subclass type.

protected Account(String accountId, String holderName) {
    this.accountId = Objects.requireNonNull(accountId, "accountId must not be null");
    if (holderName == null || holderName.isBlank()) {
        throw new IllegalArgumentException("holderName must not be blank");
    }
    this.holderName = holderName;
}

No subclass can bypass this validation because they all must call super().

What about interfaces?

Interfaces cannot have constructors. Only abstract classes can.

| Feature | Abstract class | Interface |
|---|---|---|
| Constructor | Yes | No |
| Instance fields | Yes | No (only static final constants) |
| Instantiate directly | No | No |
| Multiple inheritance | No (single extends) | Yes (multiple implements) |

What are common mistakes?

• Trying to instantiate an abstract class. new Account(...) does not compile.
• Making the constructor public. Use protected since only subclasses should call it.
• Forgetting super() in the subclass. If the abstract class has no no-arg constructor, the subclass must explicitly call super(args).

What should a senior engineer know?

• Template method pattern uses abstract class constructors: the abstract class defines the skeleton (including field initialization in the constructor), and subclasses fill in the abstract methods.
• Abstract class with all-concrete methods is legal. It just prevents direct instantiation. Use this when you want to force subclassing.
• Sealed abstract classes (Java 17+) restrict which classes can extend them: public sealed abstract class Account permits SavingsAccount, CurrentAccount {}.