0.2 Basic Principle

• Basic principles:
  1. SRP(Single Responsibility Principle) make class interface are complete and minimal. That is difficult in practical programming. such as "The zen of Design patterns", A phone class should be derived from IConnetionManager and IDataTransfer. That is an extremely example, but explain some idea of how to keep interface minimal. (In my view, functions should be less than 20. )
  2. Interface Segregation Principle.
     1. Difference between Single Responsibility Principle. SRP consider from inside of a class. Interface Segregation Principle consider from the user of a class.
     2. A simple example is "Interface Segregation Principle" which I have add to my evernote. If there is robot class, You can’t inherit it from IWorker, because robot don’t need eat, Maybe you can put an empty function here. but It’s not good design.
        IWorker{ 
        work(); 
        eat() 
        }
  3. LSP( Liskov Substitution Principle) Functions That use pointers or references to base classes must be able to use objects of derived classes without knowing it.
     1. Subclass must implement all baseclass method. 1) You have to implement pure virtual function. 2) you may or maynot override virtual function. 3) you can’t override any non-virtual function.
  4. Law of Demeter
     1. Basically, class interface should be only include functions. and avoid data members in the public interface.
     2. Only talk with friends Only member. Only input or return parameter in class method are friend.
     3. An example
        void method( Teacher & t){ 
        Student s1; // here s1 isn’t friend of method. 
        t.call(s1);  // should move to Teacher class. 
        }
  5. Program to an interface, not an implementation. There are another same two principles. They share the same idea behind.
     1. DIP (Dependence Inversion Principle) High level modules should not depend upon low level modules. Both should depend upon abstraction.
     2. Open close principle (open for extension but closed for modifications.) Allow the adding of new functionality as new classes or inherate current classes, keeping as much as possible existing code unchanged.
     3. Subclass extend it’s functionality by reusing functionality in parent classes is just inheritance half story, and frankly speaking, not prefer one. Favor object composition over object inheritance
     4. Inheritance can make clients remain unaware of specific type of class or obj behind the abstract interface. Then put all change behind the abstract interface.
     5. In C++, you need to declare base class pointer( or reference) and specify a particular implementation obj when you need to change.
     6. How to understand interface? Client<->Interface<->Implement. through Interface, you keep all the change happen implement side, not affect Client at all.
  6. When you want to reuse some codes. Favor object composition over class inheritance.