Does this design need interfacing?

Question

I am doing a small application for a neighbour and quite confused about the design at the moment. It looked pretty simple to start with, yet now I am stuck. I understand the inheritance and thus,

• All gifts must be wrapped.
• Gift is an abstract class.
• Wrapping Style is an abstract class.
• Birthday gift inherits from Gift.
• Origami Style inherits from Wrapping Style.

Scenario: User gives a gift to the shop with its identity (e.g. bday for family, bday for colleague). So there's a birthday gift that is for a colleague, which is different from a gift for a family. User specifies which wrapping style they like to use. (e.g. Origami, Western) In this case, let's say birthday gift for colleague must be wrapped using a birthday style under Origami.

But how can I connect gift with wrapping? At first wrapping looks like an interface to me. So a gift implements it. But the fact that wrapping each main wrapping styles has sub wrapping styles makes it complicated. How can the gift object birthday for colleague knows which interface to implement? It seems like birthday, wedding supposed to be abstract classes too, since only 3rd generation of gift class is a concrete class.

How can I get this design to make sense yet easy to code now and have room for modifications/improvements later?

Answer 1

In order to associate each gift with wrapping, you do not want to implement wrapping. That will not work. Instead, include the wrapping as a variable in Gift.

You seem to have method would be to use abstract classes (which are essentially partial implementations):

public abstract class Gift
{
    public IWrappingStyle wrapping { get; private set; }

    public Gift(IWrappingStyle wrapping)
    {
        this.wrapping = wrapping;
    }

    public void Unwrap()
    {
        // code common to all gifts for unwrapping
        // ...
    }
}

public interface IWrappingStyle
{

}

Then you could continue representing the second level of types as interfaces for Wrapping Style and abstract classes for gifts, and classes as the lowest level for rest of your needed types. Adding a new one would be as simple as adding a new class.

Then to use, you could do:

Gift g = new GraduationSchoolGift(new OrigamiBirthdayWrapping());

Don't forget to use folders!

---

However, unless you have some specific different behaviors for different wrapping and such, I would argue that you could use a much simpler layout:

public class Gift
{
    public String GiftType { get; private set; }
    public String WrappingStyle { get; private set; }

    public Gift(String giftType, String wrappingStyle)
    {
        this.GiftType = giftType;
        this.WrappingStyle = wrappingStyle;
    }
}

Then, if you (again) organize your files in folders like so:

Here are the respective files (the namespace is important):

Gift types:

namespace GiftWrapping.GiftTypes
{
    public class Birthday
    {
        public static const String FIFTH_BIRTHDAY = "Birthday Fifth";
        public static const String TENTH_BIRTHDAY = "Birthday Tenth";
    }
}

namespace GiftWrapping.GiftTypes
{
    public class Wedding
    {
        public static const String FAMILY = "Wedding Family";
        public static const String FRIENDS = "Wedding Friends";
    }
}

Wrapping Styles:

namespace GiftWrapping.WrappingStyles
{
    public class Origami
    {
        public static const String BIRTHDAY = "Origami Birthday";
        public static const String WEDDING = "Origami Wedding";
    }
}

namespace GiftWrapping.WrappingStyles
{
    public class Western
    {
        public static const String SCHOOL = "Western School";
        public static const String WEDDING = "Western Wedding";
        public static const String UNIVERSITY = "Western University";
    }
}

Now usage becomes:

Gift g = new Gift(GiftTypes.Wedding.FAMILY,
                  WrappingStyles.Origami.BIRTHDAY);

Answer 2

Actually write an interface is a good practice. They can really help you when you writing a unit test and is basis for SOLID. So you can try somthing like:

  public interface IGift
    {
        public void Wrap(IWrappingStyle wrappingStyle)
        {

        }
    }

    public interface IWrappingStyle
    {

    }

With such kind of object dependency you can use somthing like Strategy pattern to procces wrapping style based on type of the class.

Answer 3

Gift and wrapping are separate entities, use dependance injection.

Class wrapping{
    protected $gift;

    public __construct( $gift ){
        $this->gift = $gift
    }

    public getGift(){
       return $this->gift;
    }

}

Class gift{


}


$g = new gift()

$w = new wrapper($g);

This way you don't need to change wrapping for each new gift, or gift for each new wrapping. Whether you Interface gift,or make it abstract depends on the functionality. Same goes for wrapping. Don't mix them at the "code" level even your diagram above shows they are separate objects.

Personally I would either interface gift, or make an base abstract class for it. Then you can rely on future gifts having the code you need inside of wrapping.

Ha just realized this was C, how did I do that. Anyway the idea is the same even if it's not PHP.

Cheers.