面向对象设计原则

单一职责原则

类或模块的职责应该唯一。

比如需要接收数据, 存储数据, 发送数据, 不应将三个功能直接放在 DataHandler 类中, 而是建立DataReceiver等三个类, 在DataHandler类中使用。

开闭原则

对扩展开放, 对代码修改封闭。

即需要添加新功能时, 不应通过修改源代码实现。 已经实现的代码不能因添加新功能修改。

抽象工厂模式为其应用。

参考资料

接口隔离原则

客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。

接口应只提供该类型用户需要的功能, 而不应包含多余的功能。

使用多个专门的接口比使用单一的总接口要好。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
interface IOrderForPortal{
String getOrder();
}
interface IOrderForOtherSys{
String insertOrder();
String getOrder();
}
interface IOrderForAdmin{
String deleteOrder();
String updateOrder();
String insertOrder();
String getOrder();
}

class Order implements IOrderForPortal,IOrderForOtherSys,IOrderForAdmin{
private Order(){
//--什么都不干,就是为了不让直接 new,防止客户端直接New,然后访问它不需要的方法.
}
//返回给Portal
public static IOrderForPortal getOrderForPortal(){
return (IOrderForPortal)new Order();
}
//返回给OtherSys
public static IOrderForOtherSys getOrderForOtherSys(){
return (IOrderForOtherSys)new Order();
}
//返回给Admin
public static IOrderForAdmin getOrderForAdmin(){
return (IOrderForAdmin)new Order();
}
//--下面是接口方法的实现.只是返回了一个String用于演示
public String getOrder(){
return "implemented getOrder";
}
public String insertOrder(){
return "implemented insertOrder";
}
public String updateOrder(){
return "implemented updateOrder";
}
public String deleteOrder(){
return "implemented deleteOrder";
}
}
public class TestCreateLimit{
public static void main(String[] args){
IOrderForPortal orderForPortal =Order.getOrderForPortal();
IOrderForOtherSys orderForOtherSys =Order.getOrderForOtherSys();
IOrderForAdmin orderForAdmin = Order.getOrderForAdmin();
System.out.println("Portal门户调用方法:"+orderForPortal.getOrder());
System.out.println("OtherSys外部系统调用方法:"+orderForOtherSys.insertOrder());
System.out.println("Admin管理后台调用方法:"+orderForAdmin.getOrder()+";"+orderForAdmin.insertOrder()+";"+orderForAdmin.updateOrder()+";"+orderForAdmin.deleteOrder());
}
}

参考资料

里氏替换原则

子类替换父类不应出现变化或其他问题。

为了遵循这一原则, 实现子类时需要一些约束。

  • 子类不得重写父类非抽象方法(可以重载)
  • 子类重载父类方法时, 参数范围不能缩小, 返回值应更严格。(前置条件宽松, 后置条件严格)

依赖倒置原则

高层次不应依赖低层次, 他们都应依赖抽象。

抽象不应依赖具体, 具体依赖与抽象。

不难发现, 以下代码实例也符合开闭原则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
public interface ICar
{
void Run();
void Turn();
void Stop();
}
public class BmwCar:ICar
{
public void Run()
{
Console.WriteLine("宝马开始启动了");
}
public void Turn()
{
Console.WriteLine("宝马开始转弯了");
}
public void Stop()
{
Console.WriteLine("宝马开始停车了");
}
}
public class FordCar:ICar
{
publicvoidRun()
{
Console.WriteLine("福特开始启动了");
}
public void Turn()
{
Console.WriteLine("福特开始转弯了");
}
public void Stop()
{
Console.WriteLine("福特开始停车了");
}
}
public class HondaCar:ICar
{
publicvoidRun()
{
Console.WriteLine("本田开始启动了");
}
public void Turn()
{
Console.WriteLine("本田开始转弯了");
}
public void Stop()
{
Console.WriteLine("本田开始停车了");
}
}
public class AutoSystem
{
private ICar icar;
public AutoSystem(ICar icar)
{
this.icar=icar;
}
private void RunCar()
{
icar.Run();
}
private void TurnCar()
{
icar.Turn();
}
private void StopCar()
{
icar.Stop();
}
}

参考资料