Refused Bequest - A Code Smell

Introduction

Refused Bequest is kind of a code smell. It is based on the LISKOV Substitution Principle because it violates this principle. The contract of the base class is not honored by the derived class, and that forms this code smell. Martin Fowler has mentioned about this code smell in his book Improving the Design of Existing Code by saying,

 

"Sub-classes get to inherit the methods and data of their parents. But, what if they don't want or need what they are given? They are given all these great gifts and pick just a few to play with".

 

There is a child class and it inherits from a base class, but the child class doesn't need all behavior provided by the base class. Other behaviors which are not required to child class are refused. That refused behavior is class refused bequest.

 

Let me explain with one example.

 

A base class for the Base Tax calculation.

public class Tax {

    protected double CalculateBaseTax()
    {
     }

    protected double AddTax(double tax) {

     }

    public virtual double GetTaxAmount() {
        double tax = CalculateBaseTax();
        var taxAmount =  AddTax(tax);
        return taxAmount;
    }
}

A derived class for the total Tax Calculation, 

public class Person: Tax
{

    private double CalculateTax()
    {
    }

    public override double GetTaxAmmount() {
        double tax = CalculateTax();
        var taxAmount = AddTax(tax);

       return taxAmount;
    }
}

In the above example, the base class, Tax, has virtual method "GetTaxAmount" and it is overridden by Tax class Person. But, overridden method of Person class is not giving respect to the virtual method of Tax class. Person's class virtual method has totally new implementation. It is refusing the implementation of parent class method. So, it is a kind of code smell in the form of Refused Bequest. 

 

In the case of method, Refused Bequest is similar to no-op (NOP) except there is one difference. A no-op is an overridden method in a sub-class that purposefully removes all behavior of virtual method of base class into itself, but Refused Bequest disregards only few behavior.

Ways to solve the issue of Refused Bequest

Refused bequest code smell can be solved by using two methods.

• Push down method and push down field
• Replace Inheritance with Delegation

Push Down Method and Push Down Field

It is a common way to solve the issue of Refused Bequest.  Remove the method or property from Base class and move it to that subclass where it fits.

 

Example

 

Code with Refused Bequest.

public class Vehicle
   {
       protected void Drive() { }
   }

   public class Car : Vehicle
   {
   }

   public class Plane : Vehicle
   {
   }

Code solving the problem of Refused Bequest.

public class Vehicle
{
}

public class Car : Vehicle
{
   void Drive() { }
}

public class Plane : Vehicle
{
}

Replace Inheritance with Delegation

The child class copies or exposes the API of parent class by using "Inheritance". So, the unwanted properties or methods also get copied. Delegation eliminates the copying of the whole API from Parent class. It provides a way to copy only required functionality from the parent class.

 

Example

I want to create Stack from List. It means, I want to use some features of List like add, remove, and top item by changing its behavior according to Stack. If I use inheritance, then it will inherit all other behaviors of List that is not required for Stack. Thus, it will create the issue of Refused Bequest. So, this can be solved by using Delegation.

 

Code with Delegation.

public class CustomStack
    {
        private readonly List<string> _list = new List<string>();

        public List<string> Push(string item)
        {
            _list.Insert(0, item);
            return _list;
        }

        public List<string> Pop()
        {
            if (!_list.Any()) return null;

            _list.RemoveAt(0);
            return _list;
        }

        public string Peek()
        {
            return _list.Any() ? _list[0] : null;
        }
    }

Conclusion

Refused Bequest is a kind of a design smell. It should be eliminated during the design of classes. There are two major ways -- Push down method and replace inheritance with delegation are very good approaches to refactor the code that contains Refused Bequest code smell symptom.