Composition over Inheritance(step into Design pattern)

Question

So I have started learning book called head first design pattern and in its initial chapter it has given a scenario where composition is preferred over inharitance with a duck class example.

public abstract class Duck
{
   Swim()
       { 
          //all ducks can swim same way
       }
   abstract Look();// ducks can look different
}

So above duck class inherited by different types of ducks and also by some fake rubber duck.

(Based on duck type)

      Duck obj=new IndoDuck();
         //Or
     //Duck obj =new MallardDuck();

     obj.Swim();
     obj.Look();

So till now it looks good.

Now the change come to add a Flying behaviour to the ducks.

We cant just add fly method behaviour to the abstract duck class as there are fake ducks availbe who cant fly.

So author create a IFly interface which will be implemented by Flyable class and NonFlyable class.

interface IFly
{
 Fly();
}

Flyable: IFly
{
 Fly()
{
  // can fly
}
}

NonFlyable:IFly
{
 Fly()
{
  // cant fly
}
}

So this IFly interface will not be implemented by all the different ducks class as this will be a massive change to add flyable/non flyable behaviour to these ducks. So inharitance seems not a good idea here agree.

Author suggests IFly interface will be used inside the Duck class as composition.

public abstract class Duck
{
   Swim()
       { 
          //all ducks can swim same way
       }
   abstract Look();// ducks can look different

IFly Fly();
}

So now what i can do is.

      Duck obj=new IndoDuck();
         //Or
     //Duck obj =new MallardDuck();

     obj.Swim();
     obj.Look();
obj.Fly =new Flyable();
//or
obj.Fly=new NonFlyable();

so my questionis how would i know based on type if Flyable functionality to add or NonFlyable as somewhere i have to tell my each and every duck class that either they fly or they not right?? So how does composition actually solving the problem here i cant relate or i missed something?? Please help.

Answer 1

so my questionis how would i know based on type if Flyable functionality to add or NonFlyable as somewhere i have to tell my each and every duck class that either they fly or they not

The code that makes the decision about which IFly subclass to create a duck with will usually reside in what is known as a Factory class. A straightforward and simple implementation of such a Factory class would look something like :

public class DuckFactory {
    public static Duck createDuck(DuckType type) {
         if(DuckType.FlyableMallard.equals(type)) {
              return new MallardDuck();
         } else if(DuckType.Mallard.equals(type)) {
              return new MallardDuck(new NonFlyable());
         }
    }
}

Note that the Duck sub-classes should have a constructor that takes a Flyable argument rather than setting it using obj.Fly = Flyable. To achieve this, you can add these constructors to the Duck class itself :

 public abstract class Duck {
       protected IFly flyBehavior;
       public AbstractDuck(IFly flyBehavior) {
            this.flyBehavior = flyBehavior;
       }

       public AbstractDuck() {
            //all ducks can fly by default
            this.flyBehavior = new Flyable();
       }

       protected abstract void look();
       //other methods
 }

Each of the duck sub-classes can then extend from AbstractDuck and inherit the constructors automatically. A simple main program can then create a Duck instance by simply passing the type received from the command line :

DuckType duckType = [duck type recieved as program input]
Duck duck  = DuckFactory.create(duckType);

So how does composition actually solving the problem

It should be clear from the above example that with composition, you are able to use a single class called MallardDuck and add Flyable or NonFlyable behavior without having to make the behavior mandatory for the Duck sub classes to override.