What is the purpose of coding in management information system code design?

The purpose of coding is: uniqueness, standardization, and systematization. Codes represent various objective entities with numbers or characters. The purpose of designing codes during the system development process is: uniqueness, standardization, and systematization.

Codes use numbers or characters to represent various objective entities. The purpose of designing codes during the system development process is:

1. Unique ization;

2. Standardization;

3. Systematization.

Six principles of code design

Single Responsibility Principle

Definition: one A class or an interface is best responsible for only one responsibility.

Origin of the problem: Class T is responsible for two different responsibilities P1 and P2. Because responsibility P1 needs to be changed and the T class needs to be modified, it may cause the function of responsibility P2 that was originally running normally to malfunction.

Solution: Follow the single responsibility principle. Create new classes respectively to correspond to the corresponding responsibilities; this way you can avoid modifying the class from affecting other responsibilities;

When encountering the proliferation of responsibilities, only when the logic is simple enough, Violating the Single Responsibility Principle at the code level. Only when the number of methods in the class is small enough can the Single Responsibility Principle be violated at the method level;

Advantages: The complexity of the class will be reduced and the readability will be reduced. It will be greatly improved and maintainability will also be improved.

Liskov Substitution Principle

Where the base class is used, its subclasses can be used arbitrarily, which can ensure that the subclass can perfectly replace the base class; this kind The spirit is actually the embodiment of the constraints and norms of the inheritance mechanism. In the specific implementation of parent classes and subclasses, the relationship characteristics in the inheritance hierarchy are strictly controlled to ensure that when replacing the base class with a subclass, program behavior will not cause problems and can continue normally.

For inheritance, the parent class defines a series of specifications and contracts. Although it is not mandatory for all subclasses to comply, if the subclass arbitrarily modifies these non-abstract methods, the entire inheritance system will be affected. Cause damage.

If you have to rewrite the method of the parent class, the more common method is: the original parent class and subclass both inherit a more popular base class, remove the original inheritance relationship, and use dependency , aggregation, combination and other relationships instead;

principle includes the following four levels of meaning:

* Subclasses can implement the abstract methods of the parent class, but cannot override the non-abstract methods of the parent class Methods;

* Subclasses can add their own unique methods;

* When a method of a subclass overrides a method of a parent class, the formal parameters of the method are larger than the input parameters of the parent class method. Better and looser;

* When a method of a subclass implements an abstract method of a parent class, the return value of the method is more stringent than that of the parent class;

Dependence Inversion Principle

Definition: High-level modules should not rely on low-level modules, both should rely on their abstractions; abstractions should not rely on details; details should rely on abstractions, and the core idea is to rely on abstractions;

Origin of the problem: Class A directly depends on class B. If you want to change class A to depend on class C, you must modify the code of class A; in this scenario, class A is generally a high-level module responsible for complex business Logic; Class B and Class C are low-level modules responsible for basic principle operations; if class A is modified, it will bring unnecessary risks to the program.

Solution: Modify class A to depend on interface I. Class B and class C each implement interface I. Class A indirectly contacts class B and class C through interface I, which will reduce the cost of modifying class A. Probability;

In practice, we generally need to do the following three points:

* Low-level modules must have abstract classes or interfaces, or both;

* The declared type of the variable should be an abstract class or interface as much as possible;

* Follow the Liskov substitution principle when using inheritance;

Interface Segregation Principle

Definition: The client should not rely on interfaces it does not need; the dependence of one class on another class should be based on the smallest interface, otherwise it will cause interface pollution; class A depends on class B through interface I, class C depends on class D through interface I. If interface I is not the minimum interface for class A and class B, then class B and class D must implement methods they do not need; the meaning of the

principle is: establish For a single interface, do not build a huge and bloated interface. Try to refine the interface as much as possible and have as few methods as possible in the interface. That is to say, we should establish a dedicated interface for each class instead of trying to build a huge interface for all those who rely on it. Class to call;

Note that the interface should be as small as possible, but there must be a limit. Refining the interface can improve programming flexibility, but if it is too small, the number of interfaces will be as small as possible, making Design complexity. Therefore, it must be moderate. Customize services for classes that rely on interfaces. Only expose to the calling class the methods it needs, and hide the methods it does not need;

Rule:

* An interface only serves one sub-module or business logic and serves customization;

* Compress the public methods in the interface through business logic to make the interface look more concise;

* Modify interfaces that have been polluted as much as possible. If the risk of change is too great, use the adapter mode to transform;

* According to the specific business, understand the logic in depth and use your heart to control the design ideas;

How to implement interface isolation, there are two main methods:

1. Delegation separation, by adding a new interface type to delegate the customer's request, isolating the direct dependence between the customer and the interface, please note This will also increase the system overhead;

2. Separate multiple inheritance and realize customer needs through multiple inheritance of interfaces;

Dimiter's Law

Definition: An object should keep the least knowledge about other objects. The core spirit is: don’t talk to strangers. The popular meaning is that an object should know less about the classes that need to be coupled and associated to call; this will lead to The degree of coupling between classes is reduced, and each class minimizes its dependence on other classes.

Principle of synthesis and reuse

The principle is to use synthesis/aggregation as much as possible instead of inheritance;

Opening and closing principle

Definition: A software entity such as a class, template, and function should be closed to extensions and modifications;

Solution: When the software needs to change, try to extend the behavior of the software entity. Implement changes instead of modifying existing code to implement changes;

• Single Responsibility Principle: Implementation classes must have a single responsibility;

• Richter Replacement principle: do not destroy the inheritance system;

• Dependency inversion principle: interface-oriented programming;

• Interface isolation principle: be careful when designing interfaces Simple one;

• Demit's Law: Reduce coupling;

Opening and Closing Principle: General outline, open to expansion, closed to modification;

For more related knowledge, please visit: PHP Chinese website!

The above is the detailed content of What is the purpose of coding in management information system code design?. For more information, please follow other related articles on the PHP Chinese website!