Android常用设计模式

废话不多说，直接切入正题。

工厂设计模式

工厂设计模式可以说是比较常见的设计模式了，可以使用的范围也很广。

当需要获取多个同父类或者同接口的对象时，就能够使用工厂设计模式，使用这一个设计模式后，只需要改动参数，就能够修改所需要获取的对象。

伪代码：以Fragment作为示例
public class FragmentFactory{

public static Fragment getFragment(int index){
Fragment fragment = null;
switch(index){    //根据参数选择返回的对象实例
case 0:
fragment = new ZeroFragment();
break;
case 1:
fragment = new OneFragment();
break;
deafult:
break;
}
return fragment;
}

}

单例设计模式

单例设计模式在接触Java的时候应该就有所了解，这个设计模式应用的真的很广，也很使用，当某个类在整个使用过程中只需要一个实例的时候，就可使用单例设计模式，避免重复创建实例。

需要一提的是单例设计模式还有两种，按我个人的习惯称为：

1.懒汉式

2.饿汉式

伪代码 ： 以Android的Toast为例
/*****懒汉式*****/
public class ToastUtil{
private static Toast toast = null;
private ToastUtil(){}  //构造方法私有化

public static void showToast(String text){  //需要使用时才创建实例，懒得不行
if(toast == null){
toast = Toast.makeText(Context,text,Time);
}
/**  根据Toast做的修改，一般的单例是返回实例，也就是return ...;
toast文字设置
toast时长设置
toast显示
**/

}
}
}

/*****饿汉式*****/
public class ToastUtil{
//一出现就要创建实例，饿坏了
private static Toast toast = Toast.makeText(Context,text,Time);
private ToastUtil(){}  //构造函数私有化
public static void showToast(String text){
/**  根据Toast做的修改，一般的单例是返回实例，也就是return ...;
toast文字设置
toast时长设置
toast显示
**/
}
}

代理设计模式

代理模式是啥意思，其实按字面意思理解就没错，我能办这件事，但是我不办，请个人来替我办，就是任性。具体是个什么设计方法，看代码

/**首先是要办的事**/
public Interface 要办的事{  //注意这是接口
public void 吃饭(){};
public void 睡觉(){};
public void 写代码(){};
public void lol(){};  //我就是喜欢LOL,就要加这个方法
}

/**接着是委托人，就是找人办事的**/
public class 委托人 implements 要办的事{
public void 吃饭(){
一天四顿，山珍海味
}
public void 睡觉(){
8米大床，一觉天亮
}
public void 敲代码(){
代码千行，不见bug  //对不起我就吹吹牛
}
public void lol(){
德玛在手，打团先遛
}
}

/**再之后就是代理人，帮人办事那个**/
public class 代理人 implements 要办的事{
private 委托人 程序猴 = null;
public 代理人{  //构造方法，先把委托人复制一个
程序猴 = new 委托人();
}

public void 吃饭(){
代理人的加工
程序猴.吃饭();
}

public void 睡觉(){
代理人的加工
程序猴.睡觉();
}
public void 敲代码(){
代理人的加工
程序猴.敲代码();
}
public void lol(){
代理人的加工
程序猴.lol();
}
}

/*****开始办事了*****/
代理人 程序马 = new 程序马();
程序马.吃饭();
程序马.睡觉();
程序马.敲代码();
程序马.lol();
//搞定，最后马帮猴搞定了所有事，事实上是程序马自己复制了一个程序猴，之后用这个复制人帮程序猴搞定了所有事。

如果我表达的还算清楚的话，可以看出，代理模式把真正的业务处理隐藏在一个类中，而在做方法调用的时候却不直接调用它，而是利用另一个类来做中转，实现代理。那么在设计代理的时候，在代理类中就能做很多的事情了

/*****打个比方*****/
//在代理类中
public void 吃饭(){
要杯饮料  //我就是不知道什么饮料逼格高，不装这个逼，你管我
餐具全换金的
程序猴.吃饭();
}
//经过这么一修饰，程序猴的吃饭过程又充满的装氛围

观察者模式

是观察者，只是很单纯的观察，就看看，然后说句话，当然要说，不然要观察干鸡毛。。

那么首先要分清谁是观察者，谁是被观察的，在哪里观察，这一点弄清楚了以后观察者就很容易搞定了。

/*****首先是观察者*****/
public Interface 观察者接口{
public void 观察方法1();
public void 观察方法2();
}

private 观察者接口 观察者接口对象 ;

public void 观察者(观察者接口 观察者接口对象 ){
观察者接口对象 .观察方法1();
观察者接口对象 .观察方法2();
}

/*****接着是被观察者*****/
public void 某个被观察的方法(){
.....
.....
//观察点
if(观察者接口对象 != null){
观察者接口对象.观察方法1();
观察者接口对象.观察方法2();
}

}

/*****观察者使用*****/
被观察者方法(){
public void 观察者方法1(){

}
public void 观察者方法2(){

}
}

这段代码写的太绕，连我自己都看不太下去，但是我实在想不出更好的表现方法了，原谅我功力不够深厚。

那么解释一下：

首先这个模式会有一个需要前提，就是在某个逻辑的进行过程中，某个执行点的某个对象或是变量需要被获得。在这是就设置一个观察者来对它进行观察，这也就是观察者模式的分析。

通过对接口的实现，完成获取指定位置参数的模式，我本人自定义控件的时候就爱用这个模式设计。

状态设计模式

这个模式厉害了，根据不同的状态来进行不同的逻辑操作，听起来和工厂设计模式有那么一点神似，不过这个模式是用来操作逻辑的，也是非常有特点的模式。

伪代码
/*****首先是状态接口，不管什么状态，都有自己的工作模式*****/
public Inteface 状态{
public void 工作();
}

public 懒散模式 imliements 状态{
public void 工作(){
能混一天是一天，懒散生活乐无边;
}
}

public 勤奋模式 implements 状态{
public void 工作(){
有劲就往工作使，到头苦逼一辈子;
//瞎说什么大实话(￣ε(#￣)☆╰╮(￣▽￣///)
}
}

public class 干活的程序猴{
private 状态 状态对象;
public 干活的程序猴(状态 状态对象){  //构造
this.状态对象 = 状态对象;
}
public void changeState(状态 状态对象){  //切换状态方法
this.状态对象 = 状态对象;
}
public void word(){
状态对象.工作();
}
}

状态设计模式还是很好理解的，某个功能的实现可能存在不同逻辑实现方式，并且可能多个方式都会涉及或是存在切换需求，那么就上状态设计模式，不同的逻辑块归类为不同的状态，当需要切换逻辑时，直接换个状态，一切搞定。

代码设计模式可以说是程序员进阶路上的一个非常好的知识点，程序猴我从开始的不理解到现在的渐渐接触，了解的越多越感觉设计模式的优越。当然好钢要用在刀刃上，设计模式要是到处瞎用，可能不但没有优化和提高效率，反而会缠的乱成一团。