Android比较常用的设计模式

单例模式

饿汉式：线程安全

class Singleton {
   //1,私有构造函数
   private Singleton(){}  //这里不需要分号
   //2,创建本类对象
   private static Singleton s = new Singleton();
   //3,对外提供公共的访问方法
   public static Singleton getInstance() {
      return s;
       }
 }

懒汉式:线程不安全,需要加锁

class LazyCode {
     //私有构造函数
     private LazyCode(){}
     //声明一个本类的引用
     private static LazyCode code = null;
     //加锁,获得单例
     public static synchronized LazyCode  getInstance(){
         if (code == null){
             code = new LazyCode();
         }
         return code;
     }

}

静态内部类单例模式

提升效率，防止被多次创建，同时也是线程安全的,因为static保证了全局唯一

public class SingonClass {
 
    private SingonClass(){}

    public static SingonClass getSingonInstence(){
        return SingonInstence.instence;
    }

    private static class SingonInstence{
        private static final SingonClass instence = new SingonClass();
    }

    public void play(){
        Log.d("instence","在静态内部类单例模式 打篮球");
    }

}

 

Builder模式

定义：将一个复杂对象的构造与它的表示分离，使得同样的构造过程可以创建不同的表示。

每一部分可以灵活选择，精细化控制对象

public class PerSon {
    //建造者模式：每一部分可以灵活选择，精细化控制对象
    private String name;
    private String sex;
    private String age;
    private String nation;

    public PerSon(PerSon.Build build){
        this.name = build.name;
        this.sex = build.sex;
        this.age = build.age;
        this.nation = build.nation;
    }

    public static class Build{
        private String name;
        private String sex;
        private String age;
        private String nation = "中国";//可以给个默认值

        public Build addName(String name){
            this.name = name;
            return this;
        }

        public Build addSex(String sex){
            this.sex = sex;
            return this;
        }

        public Build addAge(String age){
            this.age = age;
            return this;
        }

        public Build addNation(String nation){
            this.nation = nation;
            return this;
        }

        public PerSon build(){
            return new PerSon(this);
        }

    }
}


//调用
PerSon perSon = new PerSon.Build()
                .addName("小明")
                .addSex("男")
                .addAge("20")
                .addNation("新加坡")
                .build();
        String personStr = perSon.toString();

工厂方法模式

定义：定义一个接口，让子类实现接口,然后自定义具体的方法,再写工厂类,工厂类相当于工具类,定义一个方法,返回不同的实例,从而使得执行的方法各不一样

//接口
public interface PrintInterface {

    void print();
}

public class AliOrder implements PrintInterface{
    @Override
    public void print() {
        System.out.println("打印 阿里 订单");
    }
}

public class EleMeOrder implements PrintInterface{
    @Override
    public void print() {
        System.out.println("打印 饿了么 订单");
    }
}

public class MeituanOrder implements PrintInterface{
    @Override
    public void print() {
        System.out.println("打印 美团 订单");
    }
}


//工厂:相当于工具类,这里做区分,每个单独的类就不用再去传构造函数的值
public class Factory {

    private Factory(){}

    public static Factory getFactory(){
        return FactoryHolder.fctory;
    }

    public PrintInterface getPrintType(String type){
        if (null == type){
            return null;
        }

        switch (type) {
            case "ali":
                return new AliOrder();
            case "meituan":
                return new MeituanOrder();
            case "eleme":
                return new EleMeOrder();
        }
        return null;
    }

    private static class FactoryHolder{
        private static final Factory fctory = new Factory();
    }
}

Android下的例子有BitmapFactory

public class BitmapFactory {
    public static Bitmap decodeFile(String pathName, Options opts) {
        Bitmap bm = null;
        ......
        return bm;
    }
}

观察者模式

定义：定义了对象之间的一对多的关系，其实就是1：n，当“1”发生变化时，“n”全部得到通知，并更新。

观察者模式比较典型的场景就是发布消息通知订阅者。没错Android下的广播就是观察者模式，在FrameWork层，状态发生变化后（比如WIFI状态），会遍历全部的register。

迭代器模式

定义：提供一种方法顺序访问一个容器对象中的各个元素，而不需要暴露该对象的内部表示。

这个迭代器再好理解不过了，我们天天用的Iterator正是这种迭代器模式。

在Android中SQLiteDatabase的query也是迭代器模式

cursor = database.query(...);
while(cursor.moveToNext()){
    cursor.get...;
}

装饰模式

定义：动态的给一个对象添加额外的功能。就增加功能来说，装饰模式比子类集成的方式更灵活。

public class ContextWrapper extends Context {
    Context mBase;
    // 由构造函数传入一个content
    public ContextWrapper(Context base) {
        mBase = base;
    }
}

参考链接:https://www.jianshu.com/p/906701e988d1