设计模式精讲-优快云博客

单例模式
建造者模式
观察者模式
策略模式
原型模式

单例模式：动态确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

优点：

单例模式在内存中只有一个实例，减少了内存开销。对于那些耗内存的类，只实例化一次，可以大大的提高性能。
单例模式可以避免对资源的多重利用，例如写一个文件时，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
单例模式可以在系统设置全局的访问点，优化和共享资源访问。

双重检查锁：

public class Singleton {    
    private static volatile Singleton instance = null;    
    
    private Singleton(){}    
     
    public static Singleton getInstance() {    
        if (instance == null) {    
            synchronized (Singleton.class) {    
                if (instance == null) {    
                    instance = new Singleton();    
                }    
            }    
        }    
        return instance;    
    }    
}

饿汉法：


public class Singleton{
private stsatic Singleton = new Singleton();
private Singleton(){}
   public static getSingleton(){

    return singleton();
                        }
    }

单线程写法：

public class Singleton {
    private static Singleton singleton = null;
    private Singleton(){}
    public static Singleton getSingleton() {
        if(singleton == null) singleton = new Singleton();
        return singleton;
    }
}

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

Android 对话框的创建的代码实现就是用的Builder模式，如：

AlertDialog.Builder builder=new AlertDialog.Builder(this);    
AlertDialog dialog=builder.setTitle("对话框")    
        .setIcon(android.R.drawable.ic_dialog)    
        .setView(R.layout.custom_view)    
        .setPositiveButton(R.string.positive, new DialogInterface.OnClickListener() {    
            @Override    
            public void onClick(DialogInterface dialog, int which) {    
    
            }    
        })    
        .setNegativeButton(R.string.negative, new DialogInterface.OnClickListener() {    
            @Override    
            public void onClick(DialogInterface dialog, int which) {    
    
            }    
        })    
        .create();    
dialog.show();

观察者模式：定义对象间一种一对多哦的依赖关系，使得当一个对象改变状态，则所有依赖于他的对象都会得到通知并被自动更新。

使用观察者模式的Android应用有：广播、EventBus等(基于注册register和解注册unregister的基本属于)

策略模式：定义了一系列算法，并将每一个算法封装起来，而且使他们可以互相替换，策略模式让算法独立于使用的客户而独立改变。

原型模式：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。