安卓设计模式的理解

一：工厂模式：
1.依赖注入的方式：
新建一个抽象类，里边有创建具体类的抽象方法，还有个方法，类的行为直接使用
public abstract class DataManage {
protected abstract SaveDataApi createSaveType();

public void ToSave(String data) {
    createSaveType().save(data);
}

}

新建类，继承它，实现创建的方法

———————————–例子——————————————————–
抽象的工厂方法：
public abstract class BaseDataManage {
protected abstract SaveDataApi createSaveType();

public SaveDataApi api;

public void ToSave(String data) {
    createSaveType().save(data);
}

}

---

二：面向对象的理解：
1.一个对象把可变化的和不可变化的区分开来，不可变化的可以写具体的实现方法，可变化的行为抽取未接口，哪些具体可变化的去实现这个接口，有多少种可变化的行为都实现这个接口
2.这个对象命名为抽象的类，接口作为变量，可变化的也写出方法，用接口实现它的行为，子类必须实现的行为也作为一个抽象方法，这样可变化和不可变化的行为都有了
3.当实现一个具体的对象时，就继承哪个抽象的对象的类，在它的超类里new 出可变化的具体行为，但是变量是接口，变量会赋值给它的父类的
4.用法：new 出具体的对象，变量是接口，然后点出具体的行为

---

三.桥接模式:
例子：
发消息的方式：Email 手机短消息 站内短消息
发消息的类型:普通消息 加急消息 特急消息

组成了两个维度，横坐标纵坐标自由组合

桥接模式：
1.定义消息的接口:
public interface MessageImplementor {
public void send(String message,String toUser);

}

2.定义抽象部分的接口：
public abstract class AbstractMessage {
protected MessageImplementor impl;//持有一个实现部分的对象
public AbstractMessage(MessageImplementor impl){//构造方法
this.impl = impl;
}
public void sendMessage(String message,String toUser){//发送消息，转调实现部分的方法
this.impl.send(message, toUser);
}

}

实现具体的实现：发消息的方式：Email 手机短消息 站内短消息

1.以站内短消息的方式发送消息：
public class MessageSMS implements MessageImplementor{
public void send(String message, String toUser) {
System.out.println(“使用站内短消息的方式，发送消息’”+message+”’给”+toUser);
}

}

2.Email方式的实现：
public class MessageEmail implements MessageImplementor{
public void send(String message, String toUser) {
System.out.println(“使用Email的方式，发送消息’”+message+”’给”+toUser);
}
}
3.手机方式的实现：
public class MessageMobile implements MessageImplementor{
public void send(String message, String toUser) {
System.out.println(“使用手机短消息的方式，发送消息’”
+message+”’给”+toUser);
}

}

扩展抽象的消息接口，普通消息 加急消息 特急消息

普通消息:
public class CommonMessage extends AbstractMessage{//普通消息
public CommonMessage(MessageImplementor impl) {
super(impl);
}
public void sendMessage(String message, String toUser) {
//对于普通消息，什么都不干，直接调父类的方法，把消息发送出去就可以了
super.sendMessage(message, toUser);
}
}

---

加急消息:
public class UrgencyMessage extends AbstractMessage{
public UrgencyMessage(MessageImplementor impl) {
super(impl);
}
public void sendMessage(String message, String toUser) {
message = “加急：”+message;
super.sendMessage(message, toUser);
}
//扩展自己的新功能：监控某消息的处理过程
// messageId 被监控的消息的编号
//包含监控到的数据对象，这里示意一下，所以用了Object
public Object watch(String messageId) {
//获取相应的数据，组织成监控的数据对象，然后返回
return null;
}

}

特急消息：
public class SpecialUrgencyMessage extends AbstractMessage{
public SpecialUrgencyMessage(MessageImplementor impl) {
super(impl);
}
public void hurry(String messageId) {//添加功能，催促
//执行催促的业务，发出催促的信息
}
public void sendMessage(String message, String toUser) {
message = “特急：”+message;
super.sendMessage(message, toUser);
//还需要增加一条待催促的信息
}
}
—————————————————–用法———————
//创建具体的实现对象
MessageImplementor impl = new MessageSMS();
//创建一个普通消息对象
AbstractMessage m = new CommonMessage(impl);
m.sendMessage(“请喝一杯茶”, “小李”);
//创建一个紧急消息对象
m = new UrgencyMessage(impl);
m.sendMessage(“请喝一杯茶”, “小李”);
http://chjavach.javaeye.com 1.17 研磨设计模式之桥接模式-2
第 108 / 127 页
//创建一个特急消息对象
m = new SpecialUrgencyMessage(impl);
m.sendMessage(“请喝一杯茶”, “小李”);
//把实现方式切换成手机短消息，然后再实现一遍
impl = new MessageMobile();
m = new CommonMessage(impl);
m.sendMessage(“请喝一杯茶”, “小李”);
m = new UrgencyMessage(impl);
m.sendMessage(“请喝一杯茶”, “小李”);
m = new SpecialUrgencyMessage(impl);
m.sendMessage(“请喝一杯茶”, “小李”);

---

四.生成器模式：
生成器模式理解：实现同样的构建过程，创建不同的表现。
思路：
1.指导者：先把构建过程独立出来，在生成模式中把它称为指导者，由它指导装配过程，但是不负责每步具体的实现
2.生成器：能具体实现每步的对象，生成器是可以被切换的具体提现

例子：
输出数据，格式是xml和txt，都是有文件头，数据内容,文件尾的格式
1.定义接口：
public interface Builder{
//文件头的部分
public void buildHeader(ExportHeaderMode ehm);
//构建输出文件的数据的内容
public void buildBody(Map

认识这点很重要，因为在生成器模式中，强调的是固定整体构建的算法，而灵活开展和切换部件的具体构造和产品装配的方式，所以要严格区分这两部分

使用生成器模式构建复杂对象，先不考虑带约束

例子：
public class InsuranceConteract{
private String contractId;
private String personName;
InsuranceConteract(ConcreteBuilder builder){
this.contractId=builder.getContractId();
this.personNam=builder.getPersonName();
}
//保险合同的某些操作
puublic void someOperation(){
//这里写逻辑操作
}
}

---

构造保险合同对象的构造器
public class ConcreteBuilder{
private String contractId;
priavte String personName;
//构造方法，传入必须要有的参数
public ConcreteBuilder(String contractId){
this.contractId=contractId;
}
//选填数据，被保险人员的名称
public ConcreteBuilder setPersonName(String personName){
this.personName=personName;
return this;
}
//构建真正的对象并返回
public InsuranceContract build(){
return new InsuranceContract(this);
}

//提供getter方法供外部访问，请注意是没有提供setter方法的
pubilc String getContrtactId(){
return contractId;
}

pubilc String getPersonName(){
return personName;
}
}

//——————–使用方法———————————
ConcreteBuilder builder=new ConcreteBuilder(“001”);
//设置需要的数据，然后构建保险合同对象
InsuranceContract contract=new builder.setPersonName(“张三”).build();
//操作保险合同对象的方法
contract.someOperation();

五.外观模式:
有多个模块，每个模块都负责各自的功能，客户端不需要知道每个模块的实现细节，把需要用的模块组合封装在Facade里就可以了，通常结合单例模式，客户端需要使用时，直接调用
Facade里的方法即可