2013年10月_CaseStatiC

原创设计技巧35：使用泛型元组存储并返回对象

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

2013-10-16 17:41:27 539

原创设计技巧34：利用另外一个类，影藏接口实现，防止向下造型

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

2013-10-16 17:40:12 662

原创设计技巧33：从方法中获取信息 Collecting Parameter:集合参数，从方法中获取信息容器比较常用

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

2013-10-16 17:38:58 531

原创设计技巧32：信使简化代码 Messenger 简单地将信息打包到一个用于传送的对象中

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

2013-10-16 17:37:10 508

原创设计技巧31：可以用接口回调，一层一层转接保护的东西

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

2013-10-16 17:36:26 494

原创设计技巧30：线程转发

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

2013-10-16 17:36:17 437

原创设计技巧29：独立后台线程顺序执行

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

2013-10-16 17:35:33 1030

原创设计技巧28：非阻塞后台线程的通知

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

2013-10-16 17:35:17 463

原创设计技巧27：代理 Proxy 为另外一个对象提供替身或者站位符以控制对对象的访问

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

2013-10-16 17:33:20 579

原创设计技巧26：状态模式 State 用类来表示一个状态

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

2013-10-16 17:33:05 637

原创设计技巧25：原型 prototype 对一个对象拷贝

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

2013-10-16 17:31:24 525

原创设计技巧24：观察 Observer 一对多通知状态的变换

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

2013-10-16 17:30:45 501

原创设计技巧23：备忘录 Memento 保存之间的状态以备以后使用

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

2013-10-16 17:29:49 504

原创设计技巧22：Mediator 中介者模式顾问，沟通所有复杂组件之间的关系

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

2013-10-16 17:29:19 461

原创设计技巧21：Facade 为一组复杂的且全面的接口对象提供一个简单且特定的接口

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

2013-10-16 17:28:14 464

原创设计技巧20：建造模式:Builder 分不同的步骤创建复杂的对象，支持可变参数

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

2013-10-15 11:43:56 489

原创设计技巧19：重叠构造器 Telescoping Constructor 对多个参数实例的构造器提供支持

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

2013-10-15 11:43:24 884

原创设计技巧18：组合模式 Composite 对容器和内容共用一个方法

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

2013-10-15 11:42:45 448

原创设计技巧17：Active Object 传递给一个线程命令，顺序执行传递的命令

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

2013-10-15 11:42:10 424

原创设计技巧16：命令模式 Command 将请求封装成对象,传递行为

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

2013-10-15 11:41:19 566

原创设计技巧15：模板方法 Template Method 在一个方法中定义一个算法的骨架，而将一些步骤延迟的子类中，实现Ioc

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

2013-10-15 11:39:20 592

原创设计技巧14：抽象工厂 Abstract Factory 组合方式创建零件，用先关零件组合生成一个产品

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

2013-10-15 11:37:50 434

原创设计技巧13：工厂方法 Factory method 基于继承具体实现交给子类来完成

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

2013-10-15 11:36:56 437

原创设计技巧12：简单工厂 SimpleFactory 把创建对象的过程隔离出来

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

2013-10-15 11:36:22 419

原创设计技巧11：静态创建方法（非设计模式中的工厂方法）利用一个静态的方法封装构建器

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

2013-10-15 11:34:34 423

原创设计技巧10：监听器回调 Listener Callback 架构去调用客户端代码，实现反调用

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

2013-10-15 11:33:54 801

原创设计技巧9：内部类利用外部类方法实现公共接口封装实现细节

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

2013-10-15 11:33:15 858

原创设计技巧8：Abstract server 在客户端和实现类之间添加一个接口，以符合OCP，DIP原则，方便扩展

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

2013-10-15 11:32:38 557

原创设计技巧7：装饰器 Decorator 动态地添加责任到对象身上，扩展类的行为比继承更灵活

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

2013-10-15 11:32:00 499

原创设计技巧6：单一的状态 MonoState （Mono 单一的）多个实例共享同一个状态

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

2013-10-15 11:30:39 508

原创设计技巧5：单例 Singleton 唯一的对象实例

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

2013-10-15 11:29:29 469

原创设计技巧4：NULL Object 创建一个空的对象，省去没必要的判断

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

2013-10-15 11:28:06 448

原创设计技巧3：享元 FlyWeight 共享相同的部分

FlyWeightFactory 享元工厂存储享元对象FlyWeight，他利用集合存储享元客户端利用享元工厂产生享元对象。 Integer.valueOf(int)或者Byte,Long Boolean, Character, Short 方法

2013-10-15 11:26:51 393

原创设计技巧2：适配器模式 Adapter 将一个类的接口通过适配器转换成客户希望的另外一个接口

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)

2013-10-15 11:25:28 759

原创设计技巧1：策略模式 Strategy 把整个算法替换掉

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

2013-10-15 11:23:48 448

Java数据结构和算法

设计模式：Java语言中的应用

重构 refator chm

Head first pattern 中文

空空如也