If a method is defined in a super class, how to change outcome depending on the object calling it

Question

I have a class called BankAccount (which is defined abstract) which is my super class and two children classes called SavingsAccount and CheckingAccount.

They both use the withdraw method defined in BankAccount however CheckingAccount can be overdrawn where-as SavingsAccount cannot.

My question is that if in the BankAccount constructor we have included the following:

public BankAccount(double balanceIn, double withdrawIn)
    {
        balance = balanceIn;
        withdraw = withdrawIn;
    }  

Which can be called from SavingsAccount class by:

public SavingsAccount(double balanceIn, double withdrawIn)
    {
    // initialise instance variables
    super (balanceIn, withdrawIn);

    }

is there a way of changing how the method responds depending on whether the constructor is called from the CheckingAccount or the SavingsAccount class

e.g (this is just to articulate and not real code, however a method defined in the BankAccount class which essentially does this)

public void setWithdraw(double withdrawIn)
{
    withdraw = withdrawIn;


    if (withdrawIn is called from savingsAccount && balance < withdrawIn)
    {
        System.out.print("You have insufficient funds");
    }
    else 
    {
        balance = balance - withdrawIn;
        System.out.print("Funds Withdrawn"); 
    }
}

I'm asking this because after some research I found out you cannot override the parameters from the super class in the child classes so it left me wondering how this was done. The SavingsAccount class would have its own attributes etc, I have left those out for clarity reasons (in-case you're wondering).

I know it would be a lot simpler to just put a withdraw method in CheckingAccount and another in SavingsAccount but since they both withdraw funds I wanted to see if it was possible to have it in the super class.

Answer 1

You can use override of a method:

public class BankAccount {
  public BankAccount(double balanceIn, double withdrawIn) {
    balance = balanceIn;
    setWithdrawn(withdrawIn);
  }

  protected void setWithdrawn(double withdrawIn) {
    // do the base stuff like withdraw = withdrawIn;
  }
}

And the second class:

public class SavingsAccount extends BankAccount {
  public BankAccount(double balanceIn, double withdrawIn) {
    super(balanceIn, withdrawIn);
  }

  // overwrite setWithdrawn
  @Override
  protected void setWithdrawn(double withdrawIn) {
    // do the specific stuff like the code of setWithdrawn in your post 
  }
}

Answer 2

Yes, but it's kind of hacky. And you shouldn't anyway. Like PM 77 said in his comment, "Your parent class should not know anything about its children." You'd be better off with a true ODD solution.

All behavior unique to a subclass should go in that subclass. All behavior shared among subclasses (if any), should go in the superclass. If no behavior (other than method signatures) is shared among subclasses, then the superclass should be an interface or abstract.

What you need is one of the following:

1. Declare the method in the superclass, but define it in the subclass. You can do this by making the superclass an interface or abstract (or even just making that one method abstract), then override the method in the subclass in order to define it. This approach has the benefit of ensuring that each subclass has the method (this is the OOD contract for your architecture), but that the behavior is unique to the subclass. This approach is appropriate if the superclass will never be instantiated directly (only subclasses will be).
2. Put shared behavior in the superclass and distinct behavior in each subclass. Have the subclass' method call the superclass' method to get the shared behavior, then execute the distinct behavior afterwards directly in the subclass' method. Use super to access superclass methods (with similar syntax to this). This approach has the benefit of modularizing shared functionality, but still enabling each subclass to add unique behavior to a method. This approach is best for constructors, but can be used with any method.
3. Override the method in the subclass. In other words, define a method with the exact same signature in the subclass, but with different behavior. The subclass' method will thus "override" the superclass' method, allowing you to specify unique behavior for each subclass. This approach has the benefit of allowing the superclass' to still be directly instantiated and have its methods invoked, while also enabling each subclass to have unique behavior. This approach is appropriate for non-constructor methods.