CSC/ECE 517 Fall 2012/ch2b 2w22 sk
Requirements
The introduction to the GoF book gives three principles for writing reusable and flexible software.
- Program to an interface, not an implementation.
- Favor object composition over class inheritance.
- Consider what should be variable in your design (originally, Encapsulate the behavior that varies).
Explain these principles, and illustrate them with original examples.
Program to an interface, not an implementation
This principle is really about dependency relationships which have to be carefully managed in a large app - Erich Gamma
In this principle, the word interface is more conceptual and should not be seen from the viewpoint of a language like Java or C# which has a keyword by the same name. Interface relates to the OO principle of capabilities that the object(s)is(are) able to support. So by this definition an object can have many types or interfaces, and objects of different classes can have the same interface or type. In this context, the main idea behind this principle is how to decouple the implementation from the interface so that the code can be extended polymorphically ie., to reduce the implementation dependencies.
For example:
So this approach gives you flexibility, but it also separates the really valuable part, the design, from the implementation, which allows clients to be decoupled from the implementation.
Another lesson learned is that you should focus not only on developing version one, but to also think about the following versions. This doesn't mean designing in future extensibility, but just keeping in mind that you have to maintain what you produce and try to keep the API stable for a long time. You want to build to last.
Just by following this rule, you get two very important benefits as stated in the GOF book:
- Clients remain unaware of the specific types of objects they use, as long as the objects adhere to the interface that the clients expect.
- Clients remain unaware of the classes that implement these objects. Clients only know about the base/abstract classes or interfaces (C# interface) defining the interface.
And this greatly reduces the implementation dependencies.
Favor object composition over class inheritance
Consider what should be variable in your design
REFERENCES
<references/>
http://www.fatagnus.com/program-to-an-interface-not-an-implementation/
http://www.artima.com/lejava/articles/designprinciples.html
http://blogs.msdn.com/b/sachin/archive/2008/06/12/program-to-an-interface-not-an-implementation.aspx
http://pragmaticjava.blogspot.com/2008/08/program-to-interface-not-implementation.html
http://www.amazon.com/gp/product/0596007124?ie=UTF8&tag=fatagnus-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0596007124
http://www.amazon.com/gp/product/0201633612?ie=UTF8&tag=fatagnus-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0201633612