{"id":33,"date":"2012-02-15T14:25:00","date_gmt":"2012-02-15T14:25:00","guid":{"rendered":"https:\/\/wdev-blog.azurewebsites.net\/index.php\/2012\/02\/15\/favor-composition-over-inheritance\/"},"modified":"2012-02-15T14:25:00","modified_gmt":"2012-02-15T14:25:00","slug":"favor-composition-over-inheritance","status":"publish","type":"post","link":"http:\/\/panahy.nl\/index.php\/2012\/02\/15\/favor-composition-over-inheritance\/","title":{"rendered":"Favor Composition over Inheritance"},"content":{"rendered":"
\n
Even though you \u201ccould\u201d<\/i> solve a problem by inheriting, see if there\u2019s another option that doesn\u2019t require you to inherit and compose your object of other helper object instead.<\/o:p><\/div>\n
The above statement sounded so sophisticated when I read it first, that I wanted to put it in my blog. Yet there is something deep in my heart that tells me: don\u2019t through away your years of experience and achievements gained by reusing objects through inheritance.<\/o:p><\/div>\n

Original Thought<\/o:p><\/h2>\n
When 2 classes, let\u2019s say Car and Vehicle implemented as follows:
    public<\/span> class<\/span> Vehicle<\/o:p><\/span><\/span><\/div>\n
    {<\/o:p><\/span><\/div>\n
        public<\/span> void<\/span> Drive() <\/o:p><\/span><\/div>\n
        { <\/o:p><\/span><\/div>\n
            Debug<\/span>.WriteLine(“Vehicle is driving.”<\/span>);<\/o:p><\/span><\/div>\n
        }<\/o:p><\/span><\/div>\n
    }<\/o:p><\/span><\/div>\n
    public<\/span> class<\/span> Car<\/span> : Vehicle<\/o:p><\/span><\/span><\/div>\n
    {<\/o:p><\/span><\/div>\n
        public<\/span> void<\/span> Drive()<\/o:p><\/span><\/div>\n
        {<\/o:p><\/span><\/div>\n
            Debug<\/span>.WriteLine(“Car is driving.”<\/span>);<\/o:p><\/span><\/div>\n
        }<\/o:p><\/span><\/div>\n
    }<\/o:p><\/span><\/div>\n
By default the new implemented Drive method in the Car class hides the implementation in vehicle for any reference of Car type. So the following instances are expected:<\/o:p><\/div>\n
    Vehicle<\/span> v = new<\/span> Vehicle<\/span>();<\/o:p><\/span><\/div>\n
    v.Drive();<\/o:p><\/span><\/div>\n
    \/\/ output : Vehicle is driving.<\/o:p><\/span><\/span><\/div>\n
<\/div>\n
    Car<\/span> c = new<\/span> Car<\/span>();<\/o:p><\/span><\/div>\n
    c.Drive();<\/o:p><\/span><\/div>\n
    \/\/ output : Car is driving.<\/o:p><\/span><\/span><\/div>\n
<\/div>\n
But the next one might cause unexpected situations when the construction occurs in a method far from calling the drive method.<\/o:p><\/div>\n
    Vehicle<\/span> x = new<\/span> Car<\/span>();<\/o:p><\/span><\/div>\n
    x.Drive();<\/o:p><\/span><\/div>\n
    \/\/ output : Vehicle is driving.<\/o:p><\/span><\/span><\/div>\n
<\/div>\n
The output for the last call (Vehicle x) changes to \u201cCar<\/span><\/b> is driving.\u201d <\/span>when the Drive<\/i> method in Vehicle<\/i> is defined as virtual <\/span>and in the Car defined as override<\/span>.<\/o:p><\/div>\n
Looks like the problem is solved.<\/o:p><\/div>\n
But sometime I have a factory class creating some instances for me and I simply declare my variables and request for an instance:<\/o:p><\/div>\n
Vehicle<\/span> x = Factory<\/span>.GetBMW();<\/span><\/o:p><\/div>\n
This means that the place I use the instance might have no knowledge of how the instance is created and might not even know how they are implementing the Drive method.<\/o:p><\/div>\n
For me, the ideal situation might be when I have a reference to a class of type Vehicle, I like it to drive as Vehicle. And when I want to have a Car that drives as a Car, I will define my reference as a Car. <\/o:p><\/div>\n
Vehicle<\/span> x = Factory<\/span>.GetBMW();
Car<\/span> y = Factory<\/span>.GetBMW();
x.Drive();
y.Drive();<\/span><\/o:p><\/div>\n
I can see that my point might not be important for BMW factory and they would rather to create a Car that drives the same way, no matter who is driving it.<\/o:p><\/div>\n

Suggested Solution<\/o:p><\/h2>\n
The Composition over inheritance suggests that Car and vehicle does not inherit from each other. To make sure that they both are sharing functionality, the BMW class needs to implement both interfaces. <\/o:p><\/div>\n
Let\u2019s say that the following code is where we like to achieve:<\/o:p><\/div>\n
    x.Drive();                  \/\/ output : Simply driving.<\/o:p><\/span><\/span><\/div>\n
    (x as<\/span> ICar<\/span>).Drive();        \/\/ output : Car driving.<\/o:p><\/span><\/span><\/div>\n
    (x as<\/span> IVehicle<\/span>).Drive();    \/\/ output : Vehicle driving.<\/o:p><\/span><\/span><\/div>\n
<\/div>\n
To get there I have introduced three interfaces as follows:<\/o:p><\/div>\n
    public<\/span> interface<\/span> IDrivable<\/o:p><\/span><\/span><\/div>\n
    {<\/o:p><\/span><\/div>\n
        void<\/span> Drive();<\/o:p><\/span><\/div>\n
    }<\/o:p><\/span><\/div>\n
    public<\/span> interface<\/span> IVehicle<\/span> : IDrivable<\/o:p><\/span><\/span><\/div>\n
    {<\/o:p><\/span><\/div>\n
        void<\/span> Drive();<\/o:p><\/span><\/div>\n
    }<\/o:p><\/span><\/div>\n
    public<\/span> interface<\/span> ICar<\/span> : IDrivable<\/o:p><\/span><\/span><\/div>\n
    {<\/o:p><\/span><\/div>\n
        void<\/span> Drive();<\/o:p><\/span><\/div>\n
    }<\/o:p><\/span><\/div>\n
<\/div>\n
The BMW needs to implement them as it suites. This implementation has nothing to do with the way they are overloaded. <\/o:p><\/div>\n
public<\/span> class<\/span> BMW<\/span> : IVehicle<\/span>, ICar<\/o:p><\/span><\/span><\/div>\n
    {<\/o:p><\/span><\/div>\n
        void<\/span> IVehicle<\/span>.Drive()<\/o:p><\/span><\/div>\n
        {<\/o:p><\/span><\/div>\n
            Debug<\/span>.WriteLine(“Vehicle is driving.”<\/span>);<\/o:p><\/span><\/div>\n
        }<\/o:p><\/span><\/div>\n
        void<\/span> ICar<\/span>.Drive()<\/o:p><\/span><\/div>\n
        {<\/o:p><\/span><\/div>\n
            Debug<\/span>.WriteLine(“Car is driving.”<\/span>);<\/o:p><\/span><\/div>\n
        }<\/o:p><\/span><\/div>\n
        void<\/span> IDrivable<\/span>.Drive()<\/o:p><\/span><\/div>\n
        {<\/o:p><\/span><\/div>\n
            Debug<\/span>.WriteLine(“Simply driving.”<\/span>);<\/o:p><\/span><\/div>\n
        }        <\/o:p><\/span><\/div>\n
    }<\/span><\/o:p><\/div>\n
<\/div>\n
Used sources: http:\/\/geekswithblogs.net\/dlussier\/archive\/2008\/01\/15\/118585.aspx<\/a><\/o:p><\/div>\n
<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

Even though you \u201ccould\u201d solve a problem by inheriting, see if there\u2019s another option that doesn\u2019t require you to inherit and compose your object of other helper object instead. The above statement sounded so sophisticated when I read it first, that I wanted to put it in my blog. Yet there is something deep in … Continue reading “Favor Composition over Inheritance”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[1],"tags":[],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false,"post-thumbnail":false},"uagb_author_info":{"display_name":"Pouya Panahy","author_link":"http:\/\/panahy.nl\/index.php\/author\/pouya\/"},"uagb_comment_info":0,"uagb_excerpt":"Even though you \u201ccould\u201d solve a problem by inheriting, see if there\u2019s another option that doesn\u2019t require you to inherit and compose your object of other helper object instead. The above statement sounded so sophisticated when I read it first, that I wanted to put it in my blog. Yet there is something deep in…","_links":{"self":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/posts\/33"}],"collection":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/comments?post=33"}],"version-history":[{"count":0,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/posts\/33\/revisions"}],"wp:attachment":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/media?parent=33"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/categories?post=33"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/tags?post=33"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}