Android开发常用的设计模式

一、工厂方法：定义：一个用于创造对象的接口，让其子类实例化哪个类。范围：当一个类不知道他所要创建的对象类的时候； 当一个类希望油他的子类来指定要创建的对象的时候；具体对象： 1.Product: 定义工厂方法所创建的对象接口； public interface Work { void doWork(); } 2.ConcreteProduct: 实现Product接口； public class AWork implements Work( public void doWork(){ log.d(" ============A"); } ) public class BWork implements Work( public void doWork(){ log.d(" ============B"); } ) 3.Creator: 声明工厂方法，给方法返回一个Product类型的对象； public interface IWorkFactory { Work getWork(); } 4.ConcreteCreator: 重定义工厂方法以返回一个 ConcreteProduct实例 public class AWorkFactory implements IWorkFactory { public Work getWork() { retrun new AWork(); } } public class BWorkFactory implements IWorkFactory { public Work getWork() { retrun newBWork(); } }Test:public class Test { public static void main() { IWorkFactory aWorkFactory = new AWorkFactory(); aWorkFactory.getWork().doWork(); IWorkFactory bWorkFactory = new BWorkFactory(); bWorkFactory.getWork().doWork();}}二、建造者模式： 定义： 将一个复杂对象的构建与他的表示分离，使用同样的构建过程可以创建不同的表示。 范围： 当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时； 当构建过程必须允许被构造的对象有不同的表示时； 具体对象： 1.Builder: 为创建一个Product对象的各个部件指定接口。 public interface PersonBuilder { void buildHead(); void buildBody(); void buildFoot();Person buildPerson(); } 2. ConcreteBuilder: 实现Builder的接口以构造和装配该产品的各个部件； 定义并明确他所创建的表示时提供一个检索产品的接口。 public class ManBuilder implements PersonBuildeer { Person person; public ManBuilder() { person = new Man(); } public void buildHead(){ person.setBody("建造头"); } public void buildBody(){ person.setBody("建造身体"); } public void buildFoot(){ person.setBody("建造脚"); } public Person buildPerson(){ return person; } } 3. Director: 构造一个使用Builder接口的对象 public class PersonDirector { public Person constructPerson(PersonBuilder pb) { pb.buildHead(); pb.buildBody(); pb.buildFoot(); return pb.buildPerson(); } } 4. Product: 5.表示被构造的复杂对象，ConcreteBuilder创建该产品的内部表示并定义他的装配过程 包含定义组成部件的类，包括这些部件装配最终产品的接口。 public class Person { private String head; private String body: private String foot; public String getHead() { retrun head; } public String getBody() { retrun body; } public String getFoot() { retrun foot; } public String getBody() { return body; } public void setHead(String hea*) { this.head = head; } public void setBody(String body) { this.body = body; } public void setFoot(String foot) { this.foot = foot; } } public class Man extends Person { Test: publ*c class Test{public static void main(String[] arns) { PersonDirector pd = new PersonDirector(); Person person = pd.constructPerson(new ManBuilder()); System*out.println(person.getBody()); System.out.println(person.getFoot()); System.out.println(person.getHead()); } } 三、单例模式： 定义：保证一个类仅有一个实例，仅仅提供一个访问他的全局访问点。 范围：当类只能有一个实例而且客户可以从一个众所周知的访问点访问它； 当这个唯一实例应该是通过子类化扩展的，并且客户应该无需更改代码 使用一个扩展的实例。 具体对象： Singleton: 定义一个Instance操作，允许客户访问他的唯一实例，Instance是一个类操作。 public class Singleton { private satic Singleton sing; private Singleton() { } public static Singleton getInstance() { if(sing == null) { sing = new Singleton();} return sing; } } Test : public class Test { public static void*ain(*tring[] args) { Singleton sing = Singleton.getInstance(); Singleton si*g2 = Singleton.getI*stance(); System.out.println(sing); System.out.pr*ntln(sing2); } }四、原型模式： 定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 范围：当一个系统应该独立于它的产品创建，构成和表示时； 当要实例化的类是在运行时刻指定时，例如：通过动态装载； 为了避免创建一个与产品类层次平行的工厂模式层次时； 当一个类的实例只能有几个不同状态组合中的一个钟时。 具体对象： 1. Prototype 声明一个克隆自身的接口。 public class Prototype implements Cloneable { private String name; public void setName(String name) { thie.name = name;} public void getName(String name) { return name;} public Object clone() { try{ retrun super.clone(); } catch(Exception e) { e.printStackTrace();retrun null; } } } 2.ConcretePrototype 实现一个克隆自身的操作。 public class ConcretePrototype extends Prototype { public ConcretePrototype(String name) { setName(name); } } 3. Client 让一个原型克隆自身从而创建一个新的对象。 public class Test { public static void main(String[] args) { Prototype pro = new ConcretePrototype("prototype"); Prototype pro2 = (Prototype)pro.clone(); System.out.println(pro.getName()); System.out.println(pro2.getName()); } }五、适配器模式： 定义：将一个类的接口转换成客户希望的另外一个接口，Adapter模式使用原本由于接口 不兼容而不能一起工作的那些类可以一起工作 范围：你想使用一个已经存在的类，而他的接口不符合你的需求； 你想创建一个可以复用的类，该类可以与其他不相关的类或者不可预见的类协 作； （仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都 行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。 具体对象： 1.Target: 定义Client使用的与特定领域相关的接口 public interface Target { void adapteeMethod(); void adapterMethod(); } 2.Adaptee: 定义一个已经存在的接口，这个接口需要适配 public class Adaptee { public void adapteeMethod() { System..... } } 3.Adapter: 对Adaptee的接口与Target接口进行适配 public class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee){ this.adaptee = adaptee; } public void adapteeMethod(){ adpatee.adapteeMethod(); } public void adapterMethod(){ System.....; }} 4.Client: 与符合Target接口的对象协同 public class Test { public static void main(String[] args){ Target target = new Adapter(new Adaptee()); target.adapteeMethod(); target.adapterMethod(); }}六、装饰模式： 定义：动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比 生成子类更为灵活。 范围：在不影响其他对象的情况下，以动态，透明的方式给单个对象添加职责； 处理那些可以撤销的职责； 当不能采用生成子类的方法进行扩充时。 具体对象： 1.Component： 定义一个对象接口，可以给这些对象动态的添加职责 public interface Person { void eat(); } 2.ConcreteComponent： 定义一个对象，可以给这个对象添加职责 public class Man implements Person { public void eat(){ System... } } 3.Decorator： 维持一个指向Component对象的指针，并定义一个与Component接口一致的接口 public abstrace class Decorator implements Person { protected Person person; public void setPerson(Person person){ this.person = perso; } public void eat(){ person.eat(); } } 4.ConcreteDecorator： 向组件添加职责 public class ManDecoratorA extends Decorator{ public void eat(){ super.eat(); reEat(); System...... } public void reEat(){ System...... } } public class ManDecoratorB extends Decorator{ public void eat(){ super.eat(); System...... System...... } } Test: public class Test{ public static void main(String[] args){ Man man = new Man(); ManDecoratorA md1 = new ManDecoratorA(); ManDecoratorB md2 = new ManDecoratorB(); md1.setPerson(man); md2.setPerson(md1); md2.eat(); } }七、迭代器模式： 定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个接收器使用 该表示来解释语言中的句子。 范围：访问一个聚合对象的内容而无需暴露他的内部表示； 支持对聚合对象的多种遍历； 为遍历不同的聚合结构提供一个统一的接口 具体对象： 1.Iterator 迭代器定义访问和遍历元素的接口。 public interface { Object next(); void first(); void last(); boolean hasNext(); } 2.ConcreteIterator 具体迭代器实现迭代器接口。 对该聚合遍历时跟踪当前位置。 public class IteratorImpl implements Iterator { private List list; private int index; public IteratorImpl(List list){ index = 0; this.list = list;} public void first() { index = 0; } publ*c void last() { index = list.getSize(); } public Object next() { Object obj = list.get(index); index++; ret*rn obj; } public boolean hasNext() { return index < list.getSize(); } } 3.Aggregate 聚合定义创建相应迭代器*象的接口。 p*blic interface List { Iterator iterator();Object get(int index);int *etSize();void add(Object ob*); } 4.ConcreteAggregate 具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的例 public class ListImpl implements List { private Object[] list;private int index;private int size;public ListImpl() { index = 0; size = 0; list = new Object[100]; }public Iterator iterator() { return new IteratorImpl(this); }public O*ject get(int index) { return list[index]; }public int getSize() { return this.size; }public void add(Object obj) { list[index++] = obj; size++; } } Testpublic class Test { public stati* void main(String[] arg*) { List list = new ListImpl(); list.add("a"); list.add("b"); list.add("c"); //第一种迭代方式 Iterator it = list.iterator(); while (*t.ha*Next()) { S*stem.out.println(it.next()); }Syst*m.out.println("====="); //第二种迭代方式 for (int i = 0; i < list.getSize(); i++) { System.out.println(list.get(i)); } } }八、观察者模式： 定义：对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于 他的对象都得到通知并被自动更新。 范围：当一个抽象模型有两个方面,其中一个方面依赖于另一方面， 将这二者封装相对独立的对象中以使它们可以各自独立地改变和复用； 当对一个对象的改变需要同时改变其它对象,而不知道具体*多少对象有待改变； 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。 具体对象： 1.Subject 目标知道它的观察者。可以有任意多个观察者观察同一个目标。 提供注册和删除观察者对象的接口 public abstract class Citizen {List po*s; String help = "normal";public void setHelp(String help) { this.help = *elp; }public String getHelp() { return this.help; }abstract void sendMessage(String help); public void setPolicemen() { t*is.pols = new ArrayList(); }public void register(*oliceman pol) { this.pols.add(pol); } public void unRegister(Policeman pol) { this.pols.remove(pol); } }2.Observer 为那些在目标发生改变时需获得未知的对象定义一个更新接口 public interface Policeman { void action(Citizen ci); } 3.ConcreteSubject 将有关状态存入各ConcreteObserver对象。 当它的状态发生改变时,向它的各个观察者发出通知 public class Hua*gPuCitizen extends Citiz*n { public HuangPuCitizen(P*liceman pol) { setPolicemen(); register*pol); }public void sendMessage(String help) { setHelp(h*lp); for(int i = 0; i < pols.size(); i++) { Policeman pol = pols.get(i); //通知警察行动 pol.action(this); } } } public class TianHeCitizen extends Citizen { public TianHeCitizen(Policeman pol) { setPolicemen(); re*ister(pol); }public void sendM*ssage(Str*ng help) { setHelp(help); for (i*t i = 0; i < pols.size(); i++) { Policeman pol = pols.get(i); //通知警察行动 pol.action(this); } } } 4.ConcreteObserver 维护一个指向ConcreteSubject对象的引用。 存储有关状态，这些状态应与目标的状态保持一致。 实现Observer的更新接口*使自身状态与目标的状态保持一致 public clas* HuangPuPoliceman implements Pol*ceman { public void action(Citizen ci) { String help = ci.getHelp(); if (help.equals("normal")) { System.o*t.println("一切正常, 不用出动"); } if (help.*quals("unnormal")) * System.out.println("有犯罪行为, 黄埔警察出动!"); } } } public c*ass TianHePoliceman implements Policem*n { public void action(Citizen ci) { String help = *i.getHelp(); if (help.equals("*ormal")) { System.out.println("一切正常, 不用出动"); * if (help.equals("unnormal")) { System.out.println("有犯罪行为, 天河警察出动!"); } } } Test public class Test{ public st*tic void main(String[] args) { Policeman thPol = new TianHePoliceman(); Pol*ceman hpPol = new HuangPuPoliceman();Ci*izen citizen = new HuangPuCitizen(hpPol); citizen.sendMessage("unnormal"); citizen.sendMessage("normal");System.out.println("===========");citizen = new TianH*Citizen(thPol); citizen.sendMessage("normal"); citi*en.sendMessage("unnormal"); } }