oop7大设计原则（Oop7 big design principle）.docVIP

oop7大设计原则（Oop7 big design principle） Object oriented seven design principles I. The principle of single responsibility As far as a class is concerned, there should be only one reason for its change. Much of what the software design really does is to discover responsibilities and separate those responsibilities. Test driven development practices often force us to separate responsibilities before the design stinks. Two, open and close principle is: a software entity should be extended to open, closed to modify. The rule says that when designing a module, the module should be extended without being modified. From another point of view, it is called the encapsulation principle of variability. The variability encapsulation principle means two points: 1., a variability should not be scattered in many corners of the code, but should be encapsulated into an object. Different representations of the same variability imply the specific subclass of the same inheritance hierarchy. 2., a variation should not be mixed with another variation. That is, the inheritance structure of class diagrams should generally not exceed two layers. It is not an easy thing to do the open and close principle, but there are many rules to follow. These laws are also the design principles. They are the tools to realize the open and close principle. Three, the Richter scale substitution principle: If every object of type T1 O1, have the object of type T2 O2, P T1 makes all the procedures defined in all objects of O1 are replaced by O2, the program did not change the behavior of the P, then the T2 type is a subtype of T1. That is, if a software entity uses the base class, it must also apply to subclasses. But the reverse substitution does not hold water. If there is a relationship between two specific types of A and B in violation of the Liskov Substitution Principle, can be in the following two kinds of reconstruction scheme selection of a: 1. create a new abstract class C, as a specific class of super