专栏首页ppjun专栏Android十八章:设计模式SOLID五大原则

Android十八章:设计模式SOLID五大原则

设计模式SOLID五大原则

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

  1. S代表着单一职责原则
  2. O代表着开闭原则
  3. L代表着里氏替换原则
  4. I代表着接口隔离原则
  5. 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>。不管以后要计算什么边形的面积只要实现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需要加上一个点击事件,

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。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Android十八章:多进程基础

    这一章主要讲述多进程的作用,序列化和反序列化,Serializable和Parcelable

    ppjun
  • Dex热修复原理

    市场上热修复有两种一种是基于multidex的更新修复(比如tinker),另外一种是native hook(比如dexposed),tinker这种是反射获取...

    ppjun
  • lateinit var 和var 区别

    如果说 lateinit var 和普通的var 有什么区别的话,可以看这篇文章 定义了 aa 是 lateinit String ,而 bb 是 Strin...

    ppjun
  • 使用iText5来处理PDF

    项目要求,通过pdf模板,把用户提交的数据保存到一个PDF文件中。其中有文字内容,也有图片。之前选了aspose.pdf,因为抠门,不能花钱买,就从网上找的的开...

    徐大嘴
  • 第80节:Java中的MVC设计模式

    事务,设置自动连接提交关闭. setAutoCommit(false); conn.commit(); conn.rollBack

    达达前端
  • Android十八章:多进程基础

    这一章主要讲述多进程的作用,序列化和反序列化,Serializable和Parcelable

    ppjun
  • day39_Spring学习笔记_07_CRM_03

      /day36_06_Spring_crm/WebRoot/WEB-INF/pages/coursetype/listCourse.jsp

    黑泽君
  • 2. Android_Jetpack组件---Lifecycles源码解析

    版权声明:本文为博主原创文章,转载请标明出处。 https://blog.csdn.net/lyh...

    Hankkin
  • Java并发之Executor(返回结果处理)运行多个任务并处理第一个结果运行多个任务并处理所有结果

    并发编程常见的问题,就是当采用多个并发任务来解决一个问题,我们往往只对第一个返回的结果有兴趣。比如,对一个数组有多种排序算法,可以并发启动所有算法,但是对于一个...

    desperate633
  • list集合示例代码

    葆宁

扫码关注云+社区

领取腾讯云代金券