设计模式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>。不管以后要计算什么边形的面积只要实现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。
