设计模式SOLID五大原则

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

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

单一职责原则

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

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

//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类中。如下

//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类中
            }
        });

    }

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

开闭原则

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

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

//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接口即可。

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类型。

//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的变量作为返回值。

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);
}

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

public interface onClickListener{
  void onClick(View v);
  void onLongClick(View v);
  void onTouch(View v,MotionEvent ev);
}

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

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的具体实例子，不符合我们的依赖倒置原则。如下：

//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(){}

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


//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。