Talk:ExtendingInterfaces

/**
 * The top-level functional declaration. All bank accounts share
 * these functional behaviors.
 */
public interface BankAccountFunctions
{
    /**
     * Get the current account balance.
     *
     * @return The current account balance.
     */
    public abstract long getBalance();
 
    /**
     * Set the current account balance.
     *
     * @param theBalance    The new account balance.
     *
     * @return The previous account balance.
     */
    public abstract long setBalance(long theBalance);
}
 
/**
 * Common implementation of all sub-types.
 */
public abstract class BankAccountFunctionsAbstract
implements BankAccountFunctions
{
    /**
     * The current account balance.
     */
    private long balance;
 
    /**
     * {@inheritDoc}
     */
    @Override
    public long getBalance()
    {
        return balance;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public long setBalance(long theBalance)
    {
        long result;
 
        result = balance;
        balance = theBalance;
        return result;
    }
}
 
/**
 * An enumeration of all types of bank accounts. Add new
 * types at the end of the definition to maintain the
 * ordinals of the prior types.
 */
public enum BankAccountEnum
{
    CHECKING_ACCOUNT,
    SAVINGS_ACCOUNT; // add new sub-types after the last
}
 
/**
 * The top-level polymorphic API. The client can use this
 * type anywhere in the application. The double dispatch
 * helper class can translate this reference type into the
 * actual subtype reference without using "instanceof".
 */
public interface BankAccount
extends BankAccountFunctions
{
    /**
     * Get the factory instance that created this instance.
     *
     * @return The factory instance that created this instance.
     */
    public abstract BankAccountFactory getBankAccountFactory();
 
    /**
     * Get the BankAccountEnum for the actual implementation.
     *
     * @return The BankAccountEnum for the actual implementation.
     */
    public abstract BankAccountEnum getBankAccountEnum();
 
    /**
     * This method is the double dispatch interface.
     *
     * @param theDoBankAccount    The DoBankAccount reference.
     */
    public abstract invoke(DoBankAccount theDoBankAccount);
}
 
/**
 * The factory API for BankAccount.
 */
public interface BankAccountFactory
{
    /**
     * Create a new instance of BankAccount.
     *
     * @return A new instance of BankAccount.
     */
    public abstract BankAccount createBankAccount();
}
 
 
// The first sub-type is CheckingAccount.
 
/**
 * The functions specific to a checking account.
 */
public interface CheckingAccountFunctions
extends BankAccountFunctions
{
    /**
     * Determine whether this account has overdraft protection.
     *
     * @return {@code true} This account has overdraft protection.
     */
    public abstract boolean hasOverdraft();
 
    /**
     * Set whether this account has overdraft protection.
     *
     * @param theOverdraft  The overdraft protection value.
     *
     * @return The previous overdraft value.
     */
    public abstract boolean setOverdraft(boolean theOverdraft);
}
 
/**
 * The implementation of the checking account functions.
 */
public abstract class CheckingAccountFunctionsAbstract
extends BankAccountFunctionsAbstract
implements CheckingAccountFunctions
{
    /**
     * The overdraft setting.
     */
    private boolean overdraft;
 
    /**
     * {@inheritDoc}
     */
    @Override
    public boolean hasOverdraft()
    {
        return overdraft;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public boolean setOverdraft(boolean theOverdraft)
    {
        boolean result;
 
        result = overdraft;
        overdraft = theOverdraft;
        return result;
    }
}
 
/**
 * The API sub-type for checking account.
 */
public interface CheckingAccount
extends BankAccount,
        CheckingAccountFunctions
{
    /**
     * Get the factory instance that created this instance.
     *
     * @return The factory instance that created this instance.
     */
    public abstract CheckingAccountFactory getCheckingAccountFactory();
}
 
/**
 * The factory API for CheckingAccount.
 */
public interface CheckingAccountFactory
extends BankAccountFactory
{
    /**
     * Create a new instance of CheckingAccount.
     *
     * @return A new instance of CheckingAccount.
     */
    public abstract CheckingAccount createCheckingAccount();
}
 
/**
 * The basic implementation of the CheckingAccountFactory.
 */
public abstract class CheckingAccountFactoryAbstract
implements CheckingAccountFactory
{
    /**
     * {@inheritDoc}
     */
    @Override
    public BankAccount createBankAccount()
    {
        return createCheckingAccount();
    }
}
 
/**
 * The basic implementation of the API for the checking account.
 */
public abstract class CheckingAccountAbstract
extends CheckingAccountFunctionsAbstract
implements CheckingAccount
{
    /**
     * {@inheritDoc}
     */
    @Override
    public final BankAccountFactory getBankAccountFactory()
    {
        return getCheckingAccountFactory();
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final BankAccountEnum getBankAccountEnum()
    {
        return BankAccountEnum.CHECKING_ACCOUNT;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final invoke(DoBankAccount theDoBankAccount)
    {
        theDoBankAccount.doBankAccount(this);
    }
}
 
/**
 * The standard implementation of the API for the checking account.
 */
public class CheckingAccountStandard
extends CheckingAccountAbstract
{
    /**
     * The CheckingAccountFactory that created this instance.
     */
    private final CheckingAccountFactory checkingAccountFactory;
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final CheckingAccountFactory getCheckingAccountFactory()
    {
        return checkingAccountFactory;
    }
 
    /**
     * Construct an instance.
     *
     * @param theCheckingAccountFactory	The CheckingAccountFactory instance.
     */
    public CheckingAccountStandard(CheckingAccountFactory theCheckingAccountFactory)
    {
        super();
 
        checkingAccountFactory = theCheckingAccountFactory;
    }
}
 
/**
 * The standard implementation of the CheckingAccountFactory.
 */
public class CheckingAccountFactoryStandard
extends CheckingAccountFactoryAbstract
{
    /**
     * {@inheritDoc}
     */
    @Override
    public CheckingAccount createCheckingAccount()
    {
        return new CheckingAccountStandard(this);
    }
}
 
 
// The second sub-type is SavingsAccount.
 
/**
 * The functions specific to a savings account.
 */
public interface SavingsAccountFunctions
extends BankAccountFunctions
{
    /**
     * Get the annual interest rate applied to this account.
     *
     * @return the annual interest rate applied to this account.
     */
    public abstract int getInterestRate();
 
    /**
     * Get the annual interest rate applied to this account.
     *
     * @param theInterestRate  The interest rate in basis points.
     *
     * @return The previous interest rate value.
     */
    public abstract int setInterestRate(int theInterestRate);
}
 
/**
 * The implementation of the savings account functions.
 */
public abstract class SavingsAccountFunctionsAbstract
extends BankAccountFunctionsAbstract
implements SavingsAccountFunctions
{
    /**
     * The interest rate in basis points.
     */
    private int interestRate;
 
    /**
     * {@inheritDoc}
     */
    @Override
    public int getInterestRate()
    {
        return interestRate;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public int setInterestRate(int theInterestRate)
    {
        int result;
 
        result = interestRate;
        interestRate = theInterestRate;
        return result;
    }
}
 
/**
 * The API sub-type for savings account.
 */
public interface SavingsAccount
extends BankAccount,
        SavingsAccountFunctions
{
    /**
     * Get the factory instance that created this instance.
     *
     * @return The factory instance that created this instance.
     */
    public abstract SavingsAccountFactory getSavingsAccountFactory();
}
 
/**
 * The factory API for SavingsAccount.
 */
public interface SavingsAccountFactory
extends BankAccountFactory
{
    /**
     * Create a new instance of SavingsAccount.
     *
     * @return A new instance of SavingsAccount.
     */
    public abstract SavingsAccount createSavingsAccount();
}
 
/**
 * The basic implementation of the SavingsAccountFactory.
 */
public abstract class SavingsAccountFactoryAbstract
implements SavingsAccountFactory
{
    /**
     * {@inheritDoc}
     */
    @Override
    public BankAccount createBankAccount()
    {
        return createSavingsAccount();
    }
}
 
/**
 * The basic implementation of the API for the savings account.
 */
public abstract class SavingsAccountAbstract
extends SavingsAccountFunctionsAbstract
implements SavingsAccount
{
    /**
     * {@inheritDoc}
     */
    @Override
    public final BankAccountFactory getBankAccountFactory()
    {
        return getSavingsAccountFactory();
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final BankAccountEnum getBankAccountEnum()
    {
        return BankAccountEnum.SAVINGS_ACCOUNT;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final invoke(DoBankAccount theDoBankAccount)
    {
        theDoBankAccount.doBankAccount(this);
    }
}
 
/**
 * The standard implementation of the API for the savings account.
 */
public class SavingsAccountStandard
extends SavingsAccountAbstract
{
    /**
     * The SavingsAccountFactory that created this instance.
     */
    private final SavingsAccountFactory savingsAccountFactory;
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final SavingsAccountFactory getSavingsAccountFactory()
    {
        return savingsAccountFactory;
    }
 
    /**
     * Construct an instance.
     *
     * @param theSavingsAccountFactory	The SavingsAccountFactory instance.
     */
    public SavingsAccountStandard(SavingsAccountFactory theSavingsAccountFactory)
    {
        super();
 
        savingsAccountFactory = theSavingsAccountFactory;
    }
}
 
/**
 * The standard implementation of the SavingsAccountFactory.
 */
public class SavingsAccountFactoryStandard
extends SavingsAccountFactoryAbstract
{
    /**
     * {@inheritDoc}
     */
    @Override
    public SavingsAccount createSavingsAccount()
    {
        return new SavingsAccountStandard(this);
    }
}
 
/**
 * A wrapper Factories API for obtaining a factory instance.
 */
public interface BankAccountFactories
{
    /**
     * Get the BankAccountFactory for the specified type.
     *
     * @param theBankAccountEnum    The BankAccountEnum for the type.
     *
     * @return The BankAccountFactory for the specified type.
     */
    public abstract BankAccountFactory getBankAccountFactory(BankAccountEnum theBankAccountEnum);
 
    /**
     * A convenience method to create an account of the specified type.
     *
     * @param theBankAccountEnum    The BankAccountEnum for the type.
     *
     * @return A new instance of BankAccount of the specified type.
     */
    public abstract BankAccount createBankAccount(BankAccountEnum theBankAccountEnum);
}
 
/**
 * The base implementation for the Factories API. The concrete
 * implementation is stored elsewhere in the application. The
 * factory instances are singletons stored in an array that is
 * indexed by the BankAccountEnum.
 */
public abstract class BankAccountFactoriesAbstract
implements BankAccountFactories
{
    /**
     * {@inheritDoc}
     */
    @Override
    public BankAccount createBankAccount(BankAccountEnum theBankAccountEnum)
    {
        BankAccount result;
        BankAccountFactory factory;
 
        factory = getBankAccountFactory(theBankAccountEnum);
        result = factory.createBankAccount();
        return result;
    }
}

/**
 * The double dispatch API for BankAccount.
 */
public interface DoBankAccount
{
    /**
     * Process the specified BankAccount according to its true type.
     *
     * @param theBankAccount    The BankAccount reference.
     */
    public abstract void process(BankAccount theBankAccount);
 
    /**
     * Process the CheckingAccount.
     *
     * @param theCheckingAccount    The CheckingAccount reference.
     */
    public abstract void doBankAccount(CheckingAccount theCheckingAccount);
 
    /**
     * Process the SavingsAccount.
     *
     * @param theSavingsAccount    The SavingsAccount reference.
     */
    public abstract void doBankAccount(SavingsAccount theSavingsAccount);
}
 
/**
 * The base implementation for the double dispatch API.
 */
public abstract class DoBankAccountAbstract
implements DoBankAccount
{
    /**
     * {@inheritDoc}
     */
    @Override
    public void process(BankAccount theBankAccount)
    {
        theBankAccount.invoke(this); // double dispatch to sub-type
    }
}
 
/**
 * The adapter implementation to provide empty methods for
 * unneeded sub-types. This is used for isolating special
 * case handling of a sub-type.
 */
public class DoBankAccountAdapter
extends DoBankAccountAbstract
{
    /**
     * {@inheritDoc}
     */
    @Override
    public void doBankAccount(CheckingAccount theCheckingAccount)
    {
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public void doBankAccount(SavingsAccount theSavingsAccount)
    {
    }
}

public class Client
{
    /**
     * Implementation to add interest payment to an account.
     */
    // If AddInterest needs access to Client instance data, then remove
    // the "static" qualifier.
    private static class AddInterest
    extends DoBankAccountAdapter
    {
        /**
         * {@inheritDoc}
         */
        @Override
        public void doBankAccount(SavingsAccount theSavingsAccount)
        {
            int interestRate;
            long interestPaid;
            long balance;
 
            balance = theSavingsAccount.getBalance();
            interestRate = theSavingsAccount.getInterestRate();
 
            interestPaid = interestRate * balance / 10000L;
            balance += interestPaid;
 
            theSavingsAccount.setBalance(balance);
        }
    }
 
    /**
     * My handler for AddInterest.
     */
    // If AddInterest needs access to Client instance data, then
    // remove the "static" qualifier.
    private static final DoBankAccount addInterest = new AddInterest();
 
    /**
     * Implementation to set interest rate for an account. This is a parameterized closure.
     */
    // If SetInterestRate needs access to Client instance data, then remove
    // the "static" qualifier.
    private static class SetInterestRate
    extends DoBankAccountAdapter
    {
        /**
         * My interest rate parameter.
         */
        private final int interestRate;
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void doBankAccount(SavingsAccount theSavingsAccount)
        {
            theSavingsAccount.setInterestRate(interestRate);
        }
 
        /**
         * Construct an instance.
         *
         * @param theInterestRate   The interest rate parameter.
         */
        private SetInterestRate(int theInterestRate)
        {
            super();
 
            interestRate = theInterestRate;
        }
    }
 
    /**
     * Implementation to set overdraft protection. This is a parameterized closure.
     */
    // If SetOverdraft needs access to Client instance data, then
    // remove the "static" qualifier.
    private static class SetOverdraft
    extends DoBankAccountAdapter
    {
        /**
         * My overdraft parameter.
         */
        private final boolean overdraft;
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void doBankAccount(CheckingAccount theCheckingAccount)
        {
            theCheckingAccount.setOverdraft(overdraft);
        }
 
        /**
         * Construct an instance.
         *
         * @param theOverdraft    The overdraft parameter.
         */
        private SetOverdraft(boolean theOverdraft)
        {
            super();
 
            overdraft = theOverdraft;
        }
    }
 
    /**
     * My closure to enable overdraft protection.
     */
    // If SetOverdraft needs access to Client instance data, then
    // remove the "static" qualifier.
    private static final DoBankAccount overdraftEnable = new SetOverdraft(true);
 
    /**
     * My closure to disable overdraft protection.
     */
    // If SetOverdraft needs access to Client instance data, then
    // remove the "static" qualifier.
    private static final DoBankAccount overdraftDisable = new SetOverdraft(false);
 
    /**
     * Add up the account balances.
     *
     * @param theAccounts    The array of accounts to sum.
     *
     * @return The sum of the account balances.
     */
    public long sum(BankAccount[] theAccounts)
    {
        long result;
        int kk;
 
        result = 0L;
        kk = theAccounts.length;
        while(0 < kk--)
        {
            result += theAccounts[kk].getBalance();
        }
 
        return result;
    }
 
    /**
     * Add interest payment to the account balance.
     *
     * @param theAccount    The account reference.
     */
    public void addInterest(BankAccount theBankAccount)
    {
        addInterest.process(theBankAccount); // ignores non-savings account
    }    
 
    /**
     * Set overdraft protection on the specified account.
     *
     * @param theAccount    The account reference.
     * @param theOverdraft  The overdraft parameter.
     */
    public void setOverdraft(BankAccount theBankAccount, boolean theOverdraft)
    {
        DoBankAccount closure;
 
        closure = theOverdraft ? overdraftEnable : overdraftDisable;
        closure.process(theBankAccount); // ignores non-checking account
    }    
 
    /**
     * Set the interest rate on the specified account.
     *
     * @param theAccount        The account reference.
     * @param theInterestRate   The interest rate parameter.
     */
    public void setInterestRate(BankAccount theBankAccount, int theInterestRate)
    {
        DoBankAccount closure;
 
        closure = new SetInterestRate(theInterestRate);
        closure.process(theBankAccount); // ignores non-savings account
    }    
}