首先，android 设计模式的六大原则：
1.单一职责原则（一个类尽量只干一件事）
2.开放封闭原则（指的是一个类，模块对修改关闭对扩展开放，自己觉得这个是比较难以兼顾的，面对需求的变动很把模型搭建的是对修改关闭的）
3.里氏替换原则（使用父类的地方能够用子类替换，反过来，则不行）
4.依赖倒置原则（抽象不应该依赖细节，细节应该依赖抽象，即面向接口编程，而不应该面向具体的实现编程）
5.接口隔离原则（一个类对另一个类的依赖应该建立在最小的接口上）
6.迪米特法则（一个类尽量不要和其他类发生关系，即一个类尽量和另一个类的耦合少）
1.单例模式
一个类在程序运行起来后就只有一个对象，当把程序杀死后，这个对象消失，运用它的好处是它就像一个全局变量，一处修改了这个类里面的方法，那么其他的修改会在它的基础继续修改，可以保证数据的连贯性。
我自己通常写的是线程不安全：
public class Singleton {private static SingletonmSingleton =null; public static SingletongetInstance(){if(mSingleton ==null){return new Singleton(); }return mSingleton; }}
在阅读了相关的文档后发现，比较好的写法是静态了内部类的方式：
public class Singleton {private static SingletonmSingleton =null; public static SingletongetInstance(){return SingletonHolder.sInstance; }//静态内部类 private static class SingletonHolder{private final static SingletonsInstance =new Singleton(); }}
2.简单工厂模式
具体的工厂，抽象的产品，很多具体的产品，适用于处理由一个变量分散出来不同的处理结果的问题。
具体的例子如下：
public class Factory {public static final StringTAG ="Factory"; Factprocess(String factName){switch (factName){case "a":return new FactA(); case "b":return new FactB(); default:break; }return null; }}
public class FactAextends Fact{@Override void show() { Log.d(Factory.TAG,"I am fact a"); }}
public class FactBextends Fact{@Override void show() { Log.d(Factory.TAG,"I am fact b"); }}
public abstract class Fact {abstract void show();}
调用点：
new Factory().process("a").show();new Factory().process("b").show();
结果：
07-07 16:04:44.626 15656-15656/com.example.administrator.mycall D/Factory: I am fact a
07-07 16:04:44.627 15656-15656/com.example.administrator.mycall D/Factory: I am fact b
缺点：当有很多的类型的产品时，就会产生很多的具体的产品，并且工厂类的方法会出现很多if分支。
3.策略模式
抽象策略，具体的策略，策略的转换类。
例子如下：
public abstract class Stragety {abstract void talk();}
public class MeetColleagueStragetyextends Stragety {@Override void talk() { Log.d(Factory.TAG,"hello,Have you had dinner today?"); }}
public class MeetLeaderStragetyextends Stragety{@Override void talk() { Log.d(Factory.TAG,"xx leader , hello"); }}
public class StragetyProcesser { StragetymStragety; StragetyProcesser(Stragety mStragety){this.mStragety = mStragety; }public void process(){mStragety.talk(); }}
测试代码：
new StragetyProcesser(new MeetColleagueStragety()).process();new StragetyProcesser(new MeetLeaderStragety()).process();
结果输出：
07-07 16:28:37.032 28351-28351/com.example.administrator.mycall D/Factory: hello,Have you had dinner today?
07-07 16:28:37.032 28351-28351/com.example.administrator.mycall D/Factory: xx leader , hello
优点：满足开放封闭原则，可以很好的扩展。
4.观察者模式
被观察者和观察者，主要体现在观察者并不知道被观察者什么时候有动作，所以用观察的形式去监听动作的变化然后去做相应的处理
例子：
public interface TouchLinstener {void action();}
public class MainActivityextends AppCompatActivityimplements TouchLinstener {private TextVieweditText; private Buttonbutton; private View1mView1; @Override protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); editText = (TextView)findViewById(R.id.edit_number); editText.setText("131xxxx8662"); button = (Button) findViewById(R.id.button); mView1= (View1) findViewById(R.id.view1); mView1.registerTouchListener(this); }@Override protected void onResume() {super.onResume();// new Thread(new Runnable() {// @Override// public void run() {//// button.setOnClickListener(new View.OnClickListener() {//// @Override//// public void onClick(View v) {//// while (true) {// String callNumber = editText.getText().toString().trim();// Intent intent = new Intent();// intent.setAction(Intent.ACTION_CALL);// intent.setData(Uri.parse("tel:" + callNumber));// startActivity(intent);//// }//// });//// }// }// }).start(); new Factory().process("a").show(); new Factory().process("b").show(); new StragetyProcesser(new MeetColleagueStragety()).process(); new StragetyProcesser(new MeetLeaderStragety()).process(); }@Override public void action() { Log.d(Factory.TAG,"user touch view1"); }@Override protected void onDestroy() {mView1.unregisterTouchListener(); }}
结果：
在用户触摸了屏幕上紫色的区域就会打出log：
07-07 16:44:42.721 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
07-07 16:44:42.741 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
07-07 16:44:42.758 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
07-07 16:44:42.809 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
07-07 16:44:42.828 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
07-07 16:44:42.842 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
07-07 16:44:42.859 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
07-07 16:44:42.866 5748-5748/com.example.administrator.mycall D/Factory: user touch view1
5.工厂方法
6.抽象工厂模式
两者都是抽象的产品，多个具体的产品，抽象的工厂，多个具体的工厂，区别在于工厂方法中的工厂只生产唯一一种产品，而抽象工厂模式中的工厂可以生产很多产品。
工厂方法的代码示例：
public abstract class Factory {abstract Productcreate();}
public class FactoryAextends Factory{@Override Productcreate() {return new ProoduceA(); }}
public class FactoryBextends Factory {@Override Productcreate() {return new ProductB(); }}
public abstract class Product {abstract void show();}
public class ProductAextends Product{@Override void show() { Log.d(Factory.TAG,"ProductA"); }}
public class ProductBextends Product{@Override void show() { Log.d(Factory.TAG,"ProductB"); }}
测试代码：
public class Test {public static void method(){ Factory factory =null; factory =new FactoryA(); factory.create().show(); factory =new FactoryB(); factory.create().show(); }}
测试结果：
07-07 17:30:45.992 32199-32199/com.example.administrator.mycall D/Factory: ProductA
07-07 17:30:45.993 32199-32199/com.example.administrator.mycall D/Factory: ProductB
抽象工厂方法的代码示例：
有两个产品，product和product1.生产出product的有两个具体的产品productA,productB,
生产出product1的两个具体的产品product1A,product1B.抽象的工厂生产两个产品分别是product和product1
public abstract class Factory {abstract Productcreate(); abstract Product1create1();}
public class FactoryAextends Factory{@Override Productcreate() {return new ProductA(); }@Override Product1create1() {return new Product1A(); }}
public class FactoryBextends Factory {@Override Productcreate() {return new ProductB(); }@Override Product1create1() {return new Product1B(); }}
public abstract class Product {abstract void show();}
public abstract class Product1 {abstract void process();}
public class Product1Aextends Product1{@Override void process() { Log.d(Factory.TAG,"Product1A"); }}
public class Product1Bextends Product1{@Override void process() { Log.d(Factory.TAG,"Product1B"); }}
public class ProductAextends Product{@Override void show() { Log.d(Factory.TAG,"ProductA"); }}
public class ProductBextends Product{@Override void show() { Log.d(Factory.TAG,"ProductB"); }}
测试代码：
public class Test {public static void method(){ Factory factory =null; factory =new FactoryA(); factory.create().show(); factory.create1().process(); factory =new FactoryB(); factory.create().show(); factory.create1().process(); }}
测试结果：
07-07 17:38:34.447 5129-5129/com.example.administrator.mycall D/Factory: ProductA
07-07 17:38:34.448 5129-5129/com.example.administrator.mycall D/Factory: Product1A
07-07 17:38:34.449 5129-5129/com.example.administrator.mycall D/Factory: ProductB
07-07 17:38:34.450 5129-5129/com.example.administrator.mycall D/Factory: Product1B
