观察者模式
定义
- 观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。
- Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
- ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
- Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
- ConcrereObserver：具体观察者，是实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。
实例:图书订阅
- 定义抽象观察者ObserVer
public interface IObserver {
//更新的方法,图书更新通知订阅者
void update(String message);
}- 创建观察者读者
/**
* 创建观察者北京的读者,实现更新方法
* Created by shiqiang on 2017/3/15.
*/
public class BookUserBeijing implements IObserver{
private String name;
public BookUser(String name ) {
this.name = name ;
}
@Override
public void update(String message) {
System.out.println("读者:" + name + ",接收到了图书更新:" + message);
}
}
/**
* 天津的读者订阅
* Created by shiqiang on 2017/3/15.
*/
public class BookUserTianjin implements IObserver {
private String name ;
public BookUserTianjin(String name) {
this.name = name ;
}
@Override
public void update(String message) {
System.out.println("读者:" + name + ",接收到了图书更新:" + message);
}
}
- 创建被观察者接口,用于订阅,接触订阅,发布消息更新
public interface Subject {
/**
* 增加订阅者
*/
void attach(IObserver observer);
/**
* 移除订阅者
*/
void detach(IObserver observer);
/**
* 通知订阅者更新消息
*/
void notice(String message);
}
- 具体被观察者
/**
* 用于用户的订阅,发布更新等
* Created by shiqiang on 2017/3/15.
*/
public class SubscriptionSubject implements Subject {
//存储用户信息的集合
private List<IObserver> list = new ArrayList<>();
@Override
public void attach(IObserver observer) {
list.add(observer);
}
@Override
public void detach(IObserver observer) {
list.remove(observer);
}
@Override
public void notice(String message) {
for(IObserver observer : list){
observer.update(message);
}
}
}- 测试功能
SubscriptionSubject sub = new SubscriptionSubject();
BookUserBeijing beijing1 = new BookUserBeijing("貂蝉");
BookUserBeijing beijing2 = new BookUserBeijing("吕布");
BookUserTianjin tianjin = new BookUserTianjin("董卓");
sub.attach(beijing1);
sub.attach(beijing2);
sub.attach(tianjin);
sub.notice("我们分布了所有人的版本");
//将天津的用户移除,只对北京用户发布
sub.detach(tianjin);
sub.notice("咱两玩儿,不带他~哈哈");
System.out: 读者:貂蝉,接收到了图书更新:我们分布了所有人的版本
System.out: 读者:吕布,接收到了图书更新:我们分布了所有人的版本
System.out: 读者:董卓,接收到了图书更新:我们分布了所有人的版本
System.out: 读者:貂蝉,接收到了图书更新:咱两玩儿,不带他~哈哈
System.out: 读者:吕布,接收到了图书更新:咱两玩儿,不带他~哈哈建造者模式
定义
- 建造者模式（builder），将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
- 建造者模式（builder）是创建一个复杂对象的创建型模式，将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示分离开来。
实例:组装一台电脑
- 创建电脑的javabean,需要cpu ,主板,内存卡
public class Computer {
private String mCpu;
private String mMainboard;
private String mRam;
public String getmCpu() {
return mCpu;
}
public void setmCpu(String mCpu) {
this.mCpu = mCpu;
}
public String getmMainboard() {
return mMainboard;
}
public void setmMainboard(String mMainboard) {
this.mMainboard = mMainboard;
}
public String getmRam() {
return mRam;
}
public void setmRam(String mRam) {
this.mRam = mRam;
}
@Override
public String toString() {
return "Computer{" +
"mCpu='" + mCpu + '\'' +
", mMainboard='" + mMainboard + '\'' +
", mRam='" + mRam + '\'' +
'}';
}
}
- 创建Builder类规范产品的组建,是一个接口或者抽象类,定义规范用的
public abstract class Builder {
//建造cpu,主板,跟内存
public abstract void buildCpu(String cpu);
public abstract void buildMainboard(String mainboard);
public abstract void buildRam(String ram);
//创建电脑
public abstract Computer create();
}
- 创建Bulid的实现类,具体功能是构建电脑
public class ComputerBuilder extends Builder {
private Computer com = new Computer();
@Override
public void buildCpu(String cpu) {
com.setmCpu(cpu);
}
@Override
public void buildMainboard(String mainboard) {
com.setmMainboard(mainboard);
}
@Override
public void buildRam(String ram) {
com.setmRam(ram);
}
@Override
public Computer create() {
return com;
}
}
- 用Dirextor指挥者类来统一组装过程
商家的指挥者类用来规范组装电脑的流程规范，先安装主板，再安装CPU，最后安装内存并组装成电脑：
public class Direcror {
private Builder builder;
public Direcror(Builder builder) {
this.builder = builder;
}
public Computer createComputer(String cpu , String main , String ram){
builder.buildCpu(cpu);
builder.buildMainboard(main);
builder.buildRam(ram);
return builder.create() ;
}
}
- 调用程序组装
//创建构建者
Builder builder = new ComputerBuilder();
Direcror direcror = new Direcror(builder);
//组装
Computer computer = direcror.createComputer("小米", "Inter", "闪迪");
System.out.println(computer.toString());
//打印结果
System.out: Computer{mCpu='小米', mMainboard='Inter', mRam='闪迪'}构建者模式第二类（javaBean）
定义一个静态内部类Builder，内部成员变量跟外部一样
Builder通过一系列方法给成员变量赋值，并返回当前对象（this）
Builder类内部提供一个build方法方法或者create方法用于创建对应的外部类，该方法内部调用了外部类的一个私有化构造方法，该构造方法的参数就是内部类Builder
外部类提供一个私有化的构造方法供内部类调用，在该构造函数中完成成员变量的赋值
具体示例（登出的时候讲SP中的值置为初始值null）
创建javaBean类
public class OutLogin { private boolean loginState ; private String userId ; private String userName ; private String storeName ; private String pis ; }在里面定义一个内部类
public static class Build{ private boolean loginState ; private String userId ; private String userName ; private String storeName ; private String pis ; public Build loginState(boolean loginState){ this.loginState = loginState ; return this ; } public Build userId(String userId){ this.userId = userId; return this ; } public Build userName(String userName){ this.userName = userName; return this ; } public Build storeName(String storeName){ this.storeName = storeName; return this ; } public Build pis(String pis){ this.pis = pis; return this ; } public OutLogin build(){ return new OutLogin(this); }在外部类中创建一个私有的引用
private OutLogin(Build build) { this.loginState = build.loginState; this.userId = build.userId; this.userName = build.userName; this.storeName = build.storeName; this.pis = build.pis; }在类中设置一个方法操作数据
“`public void setSp(){
SpUtils.setBoolean(App.getApplication(), “loginState”, loginState);
SpUtils.setString(App.getApplication(), “userId”, userId);
SpUtils.setString(App.getApplication(), “userName”, userName);
SpUtils.setString(App.getApplication(), “storeName”, storeName);
SpUtils.setString(App.getApplication(), “pis”, pis);
}
5. 外部调用的代码
OutLogin outLogin = new OutLogin.Build() .loginState(false) .userId("") .userName("") .storeName("") .pis("") .build(); outLogin.setSp(); ```