一.单例模式
1. 常用的写法:双重检查,synchronized同步,volatile修饰单例。
代码:
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;
}
}
2.静态内部类模式:
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
- 对于内部类SingletonHolder,它是一个饿汉式的单例实现,在SingletonHolder初始化的时候会由ClassLoader来保证同步,使INSTANCE是一个真·单例。
- 同时,由于SingletonHolder是一个内部类,只在外部类的Singleton的getInstance()中被使用,所以它被加载的时机也就是在getInstance()方法第一次被调用的时候。
- ——它利用了ClassLoader来保证了同步,同时又能让开发者控制类加载的时机。从内部看是一个饿汉式的单例,但是从外部看来,又的确是懒汉式的实现。
二.建造者模式:Builder
- 定义一个静态内部类Builder,内部的成员变量和外部类一样
- Builder类通过一系列的方法用于成员变量的赋值,并返回当前对象本身(this)
- Builder类提供一个build方法或者create方法用于创建对应的外部类,该方法内部调用了外部类的一个私有构造函数,该构造函数的参数就是内部类Builder
- 外部类提供一个私有构造函数供内部类调用,在该构造函数中完成成员变量的赋值,取值为Builder对象中对应的值
三.观察者模式 Observer(观察者),Observable(被观察者)
1.被观察者:Observable
public class Observable<T> {
List<Observer<T>> mObservers = new ArrayList<Observer<T>>();
public void register(Observer<T> observer) {
if (observer == null) {
throw new NullPointerException("observer == null");
}
synchronized (this) {
if (!mObservers.contains(observer))
mObservers.add(observer);
}
}
public synchronized void unregister(Observer<T> observer) {
mObservers.remove(observer);
}
public void notifyObservers(T data) {
for (Observer<T> observer : mObservers) {
observer.onUpdate(this, data);
}
}
}
2.观察者:Observer
public interface Observer<T> {
void onUpdate(Observable<T> observable,T data);
}
3.调用
public static void main(String[] args) {
Observable<Weather> observable = new Observable<Weather>();
Observer<Weather> observer1 = new Observer<Weather>() {
@Override
public void onUpdate(Observable<Weather> observable, Weather data) {
System.out.println("观察者1:" + data.toString());
}
};
Observer<Weather> observer2 = new Observer<Weather>() {
@Override
public void onUpdate(Observable<Weather> observable, Weather data) {
System.out.println("观察者2:" + data.toString());
}
};
observable.register(observer1);
observable.register(observer2);
Weather weather = new Weather("晴转多云");
observable.notifyObservers(weather);
Weather weather1 = new Weather("多云转阴");
observable.notifyObservers(weather1);
observable.unregister(observer1);
Weather weather2 = new Weather("台风");
observable.notifyObservers(weather2);
}
Android中的广播也是观察者模式。
四.工厂者模式:Factory
1.创建抽象产品类,定义公共接口:
public interface Product {
void show();
}
2.创建具体产品类,实现Product接口:
public class ProductA implements Product {
@Override
public void show() {
System.out.println("product A");
}
}
public class ProductB implements Product {
@Override
public void show() {
System.out.println("product B");
}
}
3.创建工厂类,创建具体的产品
public class Factory {
public static Product create(String productName) {
Product product = null;
//通过switch语句控制生产哪种商品
switch (productName) {
case "A":
product = new ProductA();
break;
case "B":
product = new ProductB();
break;
}
return product;
}
}
第3步也可以通过反射得到具体的产品类:
public Product create(Class<? extends Product> clazz) {
Product product = null;
try {
product = clazz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return product;
}
测试:
Factory.create("A").show();//生产ProductA
Factory.create(ProductB.class).show();//生产ProductB
未完待续.....,有问题欢迎指出,谢啦