设计模式SOLID五大原则

设计模式SOLID五大原则

SOLID每一个字母都代表这一种编程原则,其中

  1. S代表着单一职责原则
  2. O代表着开闭原则
  3. L代表着里氏替换原则
  4. I代表着接口隔离原则
  5. D代表着依赖倒置原则

单一职责原则

单一职责原则就是造成一个类改变的原因一个只有一个。再比如手机的电池是一个类,电池只为手机提供电源的职责。

在Android开发中,adapter类职责只负责视图的显示,这时候你会说adapter里面还有很多方法比如创建视图,显示视图,提供视图数量等。但是根据Martin的话来说变化的指针只在变化真正发生时起作用,如果没有任何征兆,应用单一职责原则或者其他原则是不明智的。就是说adapter创建和显示视图是这个类的职责,而不应该包括视图显示内容的计算逻辑,我只要知道结果就行了。下面看例子:

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
//UserOrder.java
public class UserOrder {
private double createTime;

public double getCreateTime() {
return createTime;
}

public void setCreateTime(double createTime) {
this.createTime = createTime;
}

}
//UserOrderAdapter.java
public class UserOrderAdapter extends RecyclerView.Adapter<UserOrderAdapter.UserOrderHolder> {
List<UserOrder> mList;
public UserOrderAdapter(List<UserOrder> list) {
this.mList = list;
}

@Override
public UserOrderHolder onCreateViewHolder(ViewGroup parent, int viewType) {

View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.user_order_rv_item, parent, false);
return new UserOrderHolder(view);
}

@Override
public void onBindViewHolder(final UserOrderHolder holder, int position) {

holder.mPayBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
UserOrder userOrder=mList.get(position);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
holder.mCreatetime.setText(sdf.format(userOrder.getCreateTime()));
}
});

}
@Override
public int getItemCount() {
return mList.size();
}

public class UserOrderHolder extends RecyclerView.ViewHolder {

TextView mCreatetime;

public UserOrderHolder(View itemView) {
super(itemView);
mCreatetime = (TextView) itemView.findViewById(R.id.user_order_createtime);

}
}
}

↑这里的onBindViewHolder处理了视图的逻辑,应该把时间格式化的操作放在UserOrder类中。如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//UserOrder.java
public class UserOrder {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private double createTime;
public String getCreateTime() {
return sdf.format(createTime);
}
public void setCreateTime(double createTime) {
this.createTime = createTime;
}
}
//UserOrderAdapter.java
@Override
public void onBindViewHolder(final UserOrderHolder holder, int position) {

holder.mPayBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
UserOrder userOrder=mList.get(position);
holder.mCreatetime.setText(userOrder.getCreateTime());//格式化时间的逻辑放在UserOrder类中
}
});

}

总结:一个类只包含一个职责,其他的逻辑放在对应的类上处理。

开闭原则

开闭原则就是在每次有新需求都不能在原来的代码中做修改。你可以一开始的时候就用多态和接口来实现架构,让你的代码更容易扩展,而不是修改。

比如你要计算一个三角形的面积

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//Triangle.java
public class Triangle{
private double width;
private double height;
private double getArea(){
return width*height/2;
}
//setter&getter
}

//AreaManager
public class AreaManager{
private double calculateArea(ArrayList<Triangle> triangles){
double area=0;
for(Triangle triangle:triagnles)
area+=triangle.getArea();
return area;
}

}

一开始代码是这样子设计的,但是后续要继续加上圆形,矩形的面积,就要在AreaManager类里面加上计算圆形,矩形的面积方法,不符合我们的开闭原则。所以要写一个shape接口,让三角形矩形都实现这个接口,在calculateArea方法里面传入ArrayList。不管以后要计算什么边形的面积只要实现shape接口即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public interface Shape{
double getArea();
}

public class Circle implements Shape{
public static final double pi=3.14;
double radius;
public double getArea(){
return radius*radius*pi;
}
//setter&getter
}

public class AreaManager{
public double calculateArea(ArrayList<Shape> shapes){
double area=0;
for(Shape shape:shapes){
area+=shape.getArea();

}
return area;
}

}

总结:在写计算方法时,考虑到以后有多个方案要怎么设计。通常是多个方案都实现了一个接口,接口方法就是该方案的逻辑。然后在方法被调用时传入接口类作为参数,调用接口方法。

里氏替换原则

里氏替换原则就是用接口类或者父类来替代子类,而不改变程序的正确性。

举个例子,下面adapter的构造函数就用了List类型的参数来替换ArrayList类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
//MainActivity.java
List<String> mList=new ArrayList<>();
mList.add("str");
UserOrderAdapter adapter=new UserOrderAdapter(mList);

//UserOrderAdapter.java
public class UserOrderAapter extends RecyclerView.Adapter<UserorderHolder>{
List<String> list;
public UserOrderAdapter(List<String> list){
this.list=list;
}

}

下面例子用了一个Arraylist的变量作为返回值。

1
2
3
4
5
6
public List<String> getList(String[] str){
ArrayList<String> list=new ArrayList<>();
for(String s:str)
list.add(s);
return list;
}

总结,这个原则相当简单你应该相当熟悉或者你每天都在用了。

接口隔离原则

接口隔离原则有点像单一职责原则,不过目标是接口类应该只有一种职责。

比如自定义一个View需要加上一个点击事件,

1
2
3
public interface onClickListener{
void onClick(View v);
}

然后,你又有需求要加上一个长按事件和一个触摸事件,

1
2
3
4
5
public interface onClickListener{
void onClick(View v);
void onLongClick(View v);
void onTouch(View v,MotionEvent ev);
}

在设置监听这个接口时:你必须重写这三个方法,可能你用不着后面两个方法。

1
2
3
4
5
6
7
8
9
10
11
new CustomeView.setOnClick(new OnClickListener{
public void onClick(View v){

}
public void onLongClick(View v){

}
public void onTouch(View v,MotionEvent ev){

}
});

这个违背了接口隔离原则,一个实现接口的类应该依赖他最小的接口。

所以我们的onClickListener只要写一个onClick方法就行了。其他的方法另外创建接口来写。比如OnTouchListener。

总结:我们写一个接口类里面的方法应该是同一个职责的,不同职责的接口方法创建新的接口类来实现。

依赖倒置原则

依赖倒置就是依赖抽象,而不依赖具体的实例。

就是在项目中我们的架构分为三层,安卓ui→业务逻辑→数据层,业务逻辑具体是判断写入或者获取数据是否符合条件

比如我们现在要做网络可用时将一个字符串写入数据库的操作,这样子activity就持有netmanager和dbmanager的具体实例子,不符合我们的依赖倒置原则。如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//MainActivity.java
protected void onCreate(bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
NetWorkManager netManager=//...
DbManager dbManager
if(netManager.isNetWorkConnected){

dbManager.insert();
}
}

//NetWorkManager.java
public boolean isNetWorkConnected(){

}
//DbManager.java
public void insert(){}

所以我们要做出如下修改:

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

//MainActivity.java
IDbManager IdbManager;


protected void onCreate(bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
IdbManager=new DBManager(this);//实例化BDmanager
IdbManager.insert();

}

//IDbManager.java
public interface IDbManager{
public void insert();
}
//DbManager.java
public class DbManager{
INetManager netManager;
public void setNetManager(INetManager netManager){
this.netManager=netManager;
}
public void insert(){
if(netManager.isNetworkConnected()){
//do
}
}

}

//INetManager.java
public interface INetManager{
boolean isNetworkConnected();
}
//NetManager.java
public class NetManager{
public boolean isNetworkConnected(){
//do
}
}

这样子就可以让activity直接依赖IDbManager的抽象类。

总结:通常我们为了更简单实例化抽象类,我们推荐使用dagger2。