Design Patterns - Interface Segregation Principle seven principles of (E)

Definition of the interface segregation principle of

　　Interface Segregation Principle (Interface Segregation Principle, ISP) require the programmer to try to split the bloated interface into smaller and more specific interface that allows interface methods contain only interested customers.

　　2002 · C Robert Martin definition of "Interface Segregation Principle" is: The client should not be forced to rely on methods that do not use (Clients should not be forced to depend on methods they do not use). This principle has another definition: a class dependent on another class should be based on the smallest interface (The dependency of one class to another one should depend on the smallest possible interface).

　　Two meanings defined above are: To establish a dedicated interface they need for each class, rather than trying to build a very large interface for all classes that depend on it to call.

　　Interface segregation principle and single responsibility is to improve the cohesion and the like, to reduce the coupling between them, embodies the idea of the package, but they are different:

- Single responsibility principle focus is duty, and the interface segregation principle focus is to isolate the interface dependent.
- Single Responsibility Principle is the main constraint class, which is aimed at program implementation and details; Interface Segregation Principle The main constraint interfaces, the main building for the abstract and the overall framework of the program.

Isolation principle advantage of the interface

　　Interface segregation principle in order to constrain the interface, reducing the dependence on the class interface, the interface follow the segregation principle has the following five advantages.

1. The bloated interface divided into multiple small size interface, it can prevent the spread of exotic change, improve flexibility, and maintainability.
2. Interface Isolation improved cohesion of the system, reducing the external interaction, reducing the coupling system.
3. If the particle size defined interfaces reasonable, to ensure the stability of the system; however, if the definition is too small, it will cause excessive number of interfaces, complicating the design; If the definition is too large, reduce flexibility, unable to provide customized services, to overall project with unpredictable risks.
4. Using multiple specialized interface also can reflect the level of objects, because it can through inheritance interfaces, to achieve the overall definition of the interface.
5. You can reduce code redundancy project engineering. Interface oversized large number of methods which are usually placed not in use, when the implementation of this interface, forced to design redundant code.

Implementation of the Interface Segregation Principle

　　When Interface Segregation Principle specific application, should be judged according to the following rules.

- Interface as small as possible, but there's a limit. An interface dedicated to a single submodule or business logic.
- Customized services to dependent interface. Only the caller needs to provide a method of shielding unwanted method.
- Understanding of the environment, refused to follow blindly. Each project or product has selected environmental factors, different environments, different split of a standard interface to understand the business logic.
- Improve cohesion and reduce the external interaction. The interfaces with the least method to accomplish most things.

Below student performance management program as an example application interface introduce the principle of isolation.

[Example 1] student achievement management program.

　　Analysis: Student performance management program typically includes insertion results, delete results, modify the results to calculate the total score, calculated average print performance information, query performance information and other functions, if all of these functions into one interface obviously not reasonable , the correct way is to place three modules respectively input module, a statistics module and a print module, which is shown in Figure 1 class.

Class Diagram student achievement management program

　　　　　　　　　　　　　　　　　　　　　　Class Diagram 1 student achievement management procedures Figure

Code is as follows:

package principle;
public class ISPtest{
public static void main(String[] args) {
InputModule input =StuScoreList.getInputModule();
CountModule count =StuScoreList.getCountModule();
PrintModule print =StuScoreList.getPrintModule();
input.insert();
count.countTotalScore();
print.printStuInfo();
//print.delete();
}
}
// input module interface
interface InputModule{
　　 void insert();
　　 void delete();
　　 void modify();
}
// Statistics module interface
interface CountModule{
void countTotalScore();
void countAverage();
}
// print module interface
interface PrintModule{
void printStuInfo();
void queryStuInfo();
}
// implementation class
class StuScoreList implements InputModule,CountModule,PrintModule{
private StuScoreList(){}
public static InputModule getInputModule()
{
return (InputModule)new StuScoreList();
}
public static CountModule getCountModule()
{
return (CountModule)new StuScoreList();
}
public static PrintModule getPrintModule()
{
return (PrintModule)new StuScoreList();
}
public void insert()
{
The System .out . The println ( "input module insert () method is called!" );
}
public void delete()
{
System the .out . Println ( "input module delete () method is called!" );
}
public void modify()
{
The System .out . The println ( "input module Modify () method is called!" );
}
public void countTotalScore()
{
System the .out . Println ( "statistics module countTotalScore () method is called!" );
}
public void countAverage()
{
System the .out . Println ( "statistics module countAverage () method is called!" );
}
public void printStuInfo()
{
System the .out . Println ( "print module printStuInfo () method is called!" );
}
public void queryStuInfo()
{
System the .out . Println ( "print module queryStuInfo () method is called!" );
}
}

　　Operating results of the program are as follows:

Enter insert module () method is called! 
CountTotalScore statistics module () method is called! 
Print printStuInfo module () method is called!