单例模式
观察者模式
命令模式
建造者模式
单例模式(Singleton)
确保某个类只有一个实例,并且自行实例化并向整个系统提供这个实例。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class RecognDataManager {
private static final String TAG = "RecognDataManager";
private volatile static RecognDataManager singleton;
private RecognDataManager() {
}
public static RecognDataManager getInstance() {
if (singleton == null) {
synchronized (RecognDataManager.class) {
if (singleton == null) {
singleton = new RecognDataManager();
}
}
}
return singleton;
}
}
|
观察者模式(Observer)
观察者模式
定义对象间的一种一个对多的依赖关系，当一个对象的状态发送改变时，所以依赖于它的对象都得到通知并被自动更新。
1
2
3
4
5
6
7
8
9
10
| public interface Observer {//抽象观察者
public void update(String message);//更新方法
}
public interface Observable {//抽象被观察者
void add(Observer observer);//添加观察者
void remove(Observer observer);//删除观察者
void notify(String message);//通知观察者
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| public class Boy implements Observer {
private String name;//名字
public Boy(String name) {
this.name = name;
}
@Override
public void update(String message) {//男孩的具体反应
System.out.println(name + ",收到了信息:" + message+"屁颠颠的去取快递.");
}
}
public class Girl implements Observer {
private String name;//名字
public Girl(String name) {
this.name = name;
}
@Override
public void update(String message) {//女孩的具体反应
System.out.println(name + ",收到了信息:" + message+"让男朋友去取快递~");
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| public class Postman implements Observable{//快递员
private List<Observer> personList = new ArrayList<Observer>();//保存收件人（观察者）的信息
@Override
public void add(Observer observer) {//添加收件人
personList.add(observer);
}
@Override
public void remove(Observer observer) {//移除收件人
personList.remove(observer);
}
@Override
public void notify(String message) {//逐一通知收件人（观察者）
for (Observer observer : personList) {
observer.update(message);
}
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
| public void test(){
Observable postman=new Postman();
Observer boy1=new Boy("路飞");
Observer boy2=new Boy("乔巴");
Observer girl1=new Girl("娜美");
postman.add(boy1);
postman.add(boy2);
postman.add(girl1);
postman.notify("快递到了,请下楼领取.");
}
|
命令模式(Command)
命令模式
将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录日志，可以提供命令的撤销和恢复功能。
1
2
3
4
| //创建一个命令接口
public interface Command {
void execute();
}
|
1
2
3
4
5
6
7
8
9
10
11
12
| //创建一个请求类/执行操作
public class Stock {
private String name = "ABC";
private int quantity = 10;
public void buy(){
System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] bought");
}
public void sell(){
System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sold");
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| public class BuyCommand implements Command {
private Stock abcStock;
public BuyCommand(Stock abcStock){
this.abcStock = abcStock;
}
@Override
public void execute() {
abcStock.buy();
}
}
public class SellCommand implements Command {
private Stock abcStock;
public SellCommand(Stock abcStock){
this.abcStock = abcStock;
}
@Override
public void execute() {
abcStock.sell();
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| //创建命令调用类
public class Invoker {
private List<Command> orderList = new ArrayList<Command>();
public void takeOrder(Command order){
orderList.add(order);
}
public void placeOrders(){
for (Command order : orderList) {
order.execute();
}
orderList.clear();
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
| //测试
public static void main(String[] args) {
Stock abcStock = new Stock();
BuyCommand buyStockOrder = new BuyCommand(abcStock);
SellCommand sellStockOrder = new SellCommand(abcStock);
Invoker invoker = new Invoker();
invoker.takeOrder(buyStockOrder);
invoker.takeOrder(sellStockOrder);
invoker.placeOrders();
}
|
建造者模式（Builder）
建造者模式
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
Android中的AlertDialog.Builder就是使用了Builder模式来构建AlertDialog的。
1
2
3
4
5
6
7
8
9
10
11
12
| AlertDialog.Builder builder = new AlertDialog.Builder(activity);//创建一个Builder对象
builder.setIcon(R.drawable.icon);
builder.setTitle("标题");
builder.setMessage("信息");
builder.setPositiveButton("确定",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
}
});
AlertDialog alertDialog = builder.create();//创建AlertDialog对象
alertDialog.show();
|
装饰器模式（Decorator）
装饰器模式
动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。