What is the difference between abstract class and interface?

package com.bank.core;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

// Difference 1: CONSTRUCTORS (abstract class: yes, interface: no)
public abstract class Account {
    private final String accountId;
    protected BigDecimal balance;

    protected Account(String accountId, BigDecimal initialBalance) {
        if (accountId == null) throw new IllegalArgumentException("required");
        this.accountId = accountId;
        this.balance = initialBalance;
    }
    // Interface: no constructor. Cannot initialize state on creation.
}

// Difference 2: INSTANCE FIELDS (abstract class: yes, interface: no)
// Account has: protected BigDecimal balance (mutable instance field)
// Interface has: BigDecimal MAX = new BigDecimal("10000000"); // public static final only

// Difference 3: ACCESS MODIFIERS (abstract class: any, interface: public only)
// Account can have: protected void internalValidate() { }
// Interface: all methods implicitly public (private since Java 9 for helpers)

// Difference 4: SINGLE vs MULTIPLE INHERITANCE
// class SavingsAccount extends Account implements Auditable, Notifiable, Taxable { }
// Cannot: class X extends Account, AnotherClass { } // compile error

public interface PaymentChannel {
    // Abstract method: implementor must provide body
    TransferResult transfer(String from, String to, BigDecimal amount);

    // Default method (Java 8): has body, inherited by implementors
    default boolean isAvailable() {
        return true; // implementors can override
    }

    // Static method (Java 8): utility, called via InterfaceName.method()
    static PaymentChannel defaultChannel() {
        return new NeftChannel();
    }

    // Private method (Java 9): helper for default methods
    private void logTransfer(String msg) {
        System.out.println("[PaymentChannel] " + msg);
    }

    // Constants only: no instance fields
    BigDecimal MAX_TRANSFER = new BigDecimal("10000000"); // implicitly public static final
}

public abstract class Account {
    private final String accountId;
    protected BigDecimal balance;
    private final List<String> auditLog = new ArrayList<>();

    protected Account(String accountId, BigDecimal initialBalance) {
        this.accountId = accountId;
        this.balance = initialBalance;
        auditLog.add("OPENED: Rs." + initialBalance);
    }

    public void deposit(BigDecimal amount) {
        balance = balance.add(amount);
        auditLog.add("CREDIT: Rs." + amount);
    }

    public abstract BigDecimal calculateInterest(); // subclass must implement

    // Template Method Pattern: concrete method calling abstract method
    public void processMonthEnd() {
        BigDecimal interest = calculateInterest();
        if (interest.signum() > 0) {
            deposit(interest);
        }
    }
}

// Account: abstract class (has state, constructor, template method)
public abstract class Account {
    protected BigDecimal balance;
    protected Account(BigDecimal balance) { this.balance = balance; }
    public abstract BigDecimal calculateInterest();
}

// Auditable: interface (capability, any class can have it)
public interface Auditable {
    List<String> generateAuditReport();
}

// Taxable: interface (capability, any class can have it)
public interface Taxable {
    BigDecimal calculateTax();
}

// SavingsAccount: uses both
public class SavingsAccount extends Account implements Auditable, Taxable {
    // Extends ONE abstract class (Account: shared state + template).
    // Implements MULTIPLE interfaces (Auditable + Taxable: capabilities).
}

// WRONG: wasting inheritance on a contract with no state
public abstract class Auditable {
    public abstract List<String> generateReport();
}
// Now SavingsAccount extends Account but cannot also extend Auditable.

// CORRECT: use interface for stateless contracts
public interface Auditable {
    List<String> generateReport();
}
// SavingsAccount extends Account implements Auditable. Both slots used well.