u012447768的专栏

1.急切初始化(eagerly)public class Singleton{private static Singleton instance = new Singleton(); private Singleton(){}; public static Singleton getInstance(){return instance;}} 2延迟初始化 public class Singleto

public class Memento{//备忘对象public int fruits;//需要回复的fieldpublic int score;//需要回复的field} public class Gamer{public int fruits;public int score; public memento creatMemento(){//产生备忘Memento m = new memen

1.普通实现 public interface subject{//被观察的对象 void registerObserver(Observer o)//添加观察者 void removeObserver(Observer o)//删除观察者 void notifyObservers();//状态有变换通知观察者} public interface Observer{//观察者void update

1.利用回调接口实现 2.利用ThreadPoolExecutor，复写beforeExecute和afterExecute方法 3. Guava's listenable future API

1.利用android handler ,所有的handler和唯一的looper绑定，实现执行在looper相关的线程中执行操作 2.利用线程池SingleThreadedExecutor

public class Point{//信使 messenger 用于打包信息点（x,y)public int x,y;//信息点 public Point(int x,int y){this.x= x;this.y= y;} public class Line{//调用信使，省去信息点x,y的使用public Point startPoint,endPoint;public Line(Poin

public class CollectParaT{ public void fill(CollectionParameter p){//收集器当参数传入方法p.add("fill");//方法在收集器里面添加信息} public void fil(CollectionParameter p){p.add("fil");} public static void testP(){CollectPar

public interface A{//公共接口 f()} class ConcretA implements A{//具体实现，包访问public f(){System.out.pint("ff");} public class HiddenA{ public static A getA{ return new ConcretA ();//获取实现方法}

RMI：Remote Method Invocation 一般对象的调用是在同一个虚拟机的堆上，如果要在不同的虚拟机上调用对象就要利用RMI技术 Client (RMI Stub) (RMI Skeleton) Service对象 public interface MyRemote enxtends Remote{//继承自Remote接口，定义远程调用的方法 String sayHell

public class My{public interface myInterface{//外部接口void my()}} public class You implements My.myInterface{public intreface youInterface{//转接接口void you()} public void my(){//实现调用了外部接口的实现you();}public c

Tuple 元组笛卡尔积（两个集合X和Y的乘积）中每一个元素（d1，d2，…，dn）叫作一个n元组（n-tuple）元组是关系数据库中的基本概念，关系是一张表，表中的每行(即数据库中的每条记录)就是一个元组，每列就是一个属性。 在二维表里，元组也称为记录。 public class TwoTuple{//利用泛型传入不同类型参数 public final A first;//final 防止修改

Object的clone()方法是protected 所有要让一个对象可以在包外复制必须重写clone方法同时把他的访问权限设置为publicObject的clone()方法的作用：clone()方法便可建立起正确数量的存储空间，并对那个类型进行正确的按位复制。Object的clone()方法是一个本地方法，所有重写clone的类里面的clone方法必须先调用super.clone，实际的clon

1.利用handler在线程发送消息，然后接受消息再例外一个线程里执行操作

当有一个以上对象去处理消息的时候，使用责任链模式来实现每一个对象在处理的时候，如果自己处理了则不往下传送，不能处理则传送给链上的下一个对象去处理。好处：方便对处理的各个对象进行管理以及维护，解耦各个对象public abstrac class Support{//超类 Support mNext;void setNext(Support next){//添加下一

类层次功能分为两个功能：1.添加新的功能2.添加新的实现；分离类层次这两个功能，利用委托来桥接两个类的层次public class Display{  //功能超类private DisplayImpl mDisplayImpl;public Display(DisplayImpl displayImpl){ //委托桥接mDisplayImpl = d

提供了外部访问集合的方法，而又不暴漏元素内部细节Interface Iterator{//迭代器接口object next();boolean remove();boolean hasNext();}public class Collection{//被迭代和观察的集合IteratorClas[]  obs;get Iterator(){retu

1.普通状态机public class StateMachine{ private final int STATE1 = 1;//以Int表示不同的状态 private final int STATE2 = 2; private int state = STATE1;//当前所处的状态 public void insertCoin(){if(state == STATE1){......state

访问者模式将数据和行为分开来public class Visitor{//访问着visit(Acceptor acceptor);//访问者访问Acceptor，同时操作Acceptor}public interface Acceptor{//接受者accept(Visitor v);//接受访问者的访问，把自己的数据传递给访问者 }每当有新的行

public class Mediator{//中介者 Button button;//被调停的对象TextView textView//被调停的对象public Mediator(Button button,TextView textView){this.button = button;this.textView = textView;button.setOnClickListener{onCl

为子系统提供高层接口，使子系统更容易访问。 最少知识原则，使得客户更容易访问接口 DB类使得App不必要了解SQL的细节就可以实现对数据库的访问和操作

提供一个只有必要参数的构造器，第二个构造器有一个可选参数，第三个构造器有两个可选参数，以此类推，最后一个构造器包含所有的可选参数。参数少的构造器调用参数多的构造器创建。 public class NutritionFacts { private final int servingSize; //(ml) required private final int s

public class MonoState{ private static int itsX =0; public void setX(int x){itsX = x;} public int getX(){return itsX;}} 利用静态的field，使得多个实例共享一个类的变量

共有的超类，修改装饰方法 public interface Decorator{ String decorate()} public class ChildA implements Decorator{public decorate(){return "childA";} public class ChildB impements Decorator{private Decorator decor

public class Client{//客户 publis static void usedServer(Server server ){server .serve();} public static void testMethod (){Server server = new ConcrectClass();usedServer(server);  public interface Serv

1.利用继承来实现适配 B继承了A的方法同时适配C接口 类适配器interface C{methodC ();}class A{methodA(){}} class B extends A implements C{methodC(){methodA()}} 2.委托适配： 对象适配器A类利用传入的B类对象从而实现方法Arrays.asList(T ... arr)

public interface A{ methodA();  public static final A NULL= new A(){methodA(){// null 实现}；} 利用静态的方式在接口中创建一个NULL的iterface的实现

public interface OutInterface{//外部接口void interfaceMehtod()} public class outerClass{//外部类privte OutIntrface outInterface = new OutInterfaceImpl(); public OutInterface getOutInterface(){// 获取外部接口实现ret

public class Pizza{ //产品抽象类 void method()}}} public class aPizza extends Pizza{//具体的产品void method(){System.out.println("aPizza");} public class bPizza extends Pizza{void method(){System.out.println("b

public class PizzaStore{public abstract Pizza createPizza(String type)//抽象的工厂方法 public void orderPizza(){Pizza pizza = createPizza();pizza.method();}} abstract class Pizza{//抽象的产品method();} public cla

public abstract class AbstractFactory{//抽象工厂abstract creatSuger //抽象零件创建方法creatMilk  public abstract class Pizza{//抽象产品Milk milk;/Suger suger;someMethod{suger.name+milk.name}public abstract class Mil

public interface Command{//命令接口public void execute();//行为} public class ConcreteCommand implements Command{//具体命令public void execute(){System.out.println("concreteCommand");} public static void test(

public class ActiveObjectEngine{List list//存储Commandpublic void addCommand(Command command){list.add(command);} public void run(){//顺序执行while(!list.isEmpty()){//一直去判断，不会停止Command c = list.getFirst();

public abstract Entry{//超类public void add(Entry entry){//默认的add方法为不支持throw new UnsupportedOperationException();} public abstract void printList(String str);//容器和内容的公共方法  public class File extends Entr

public class Pizza {//需要创建的对象 private int size; private boolean cheese; private boolean pepperoni; private boolean bacon;  public static class Builder { //required private final int size; 

Context 构造方法传入抽象的Strategy，利用组合，把算法委托给Strategy,具体的ConcreteStrategy实现算法，根据需求切换Strategy Array.sort(Comparator)

public interface CallBack{//回调接口 Listener call()} public class Model{ private CallBack callBack; public void setCallBack(CallBack callBack){//设置回调实现 addListenerthis.callBack = callBack} public do()

public static Boolean valueOf(boolean b){ reuturn b?Boolean.True:Boolean.False;} 1.有不同于构建器的名字；2.不必每次调用都创建一个对象，有的时候根据判断返回以创建的对象；3.可以返回任何子类；4.可以简洁。 详见EJ 1

1.抽象超类定义一套算法，算法每个步骤用抽象方法来表示，具体子类实现抽象方法public abstract superClass{//抽象超类public final void method(){//定义一套算法 final 防止子类重写method1();method2();} abstract void method1();//算法步骤abstract void method2();//算法步

你不必严格遵守这些原则，违背它们也不会被处以宗教刑罚。但你应当把这些原则看成警铃，若违背了其中的一条，那么警铃就会响起 。   ----- Arthur J.Riel 　　(1)所有数据都应该隐藏在所在的类的内部。 　　(2)类的使用者必须依赖类的共有接口，但类不能依赖它的使用者。 　　(3)尽量减少类的协议中的消息。 　　(4)实现所有类都理解的最