为什么使用Decorator?
我们通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的.

使用Decorator的理由是:这些功能需要由用户动态决定加入的方式和时机.Decorator提供了"即插即用"的方法,在运行期间决定何时增加何种功能.

程序举例：
Display.java:
public abstract class Display {
 public abstract int getColumns(); // 取得横向的字数

 public abstract int getRows(); // 取得直向的行数

 public abstract String getRowText(int row); // 取得第row个字串

 public final void show() { // 打印所有內容
  for (int i = 0; i < getRows(); i++) {
   System.out.println(getRowText(i));
  }
 }
}
Border .java:
public abstract class Border extends Display {
    protected Display display;          // 指装饰外框里面的「內容」??
    protected Border(Display display) { // 在产生对象实例时，以参数指定「內容」
        this.display = display;
    }
}

 public StringDisplay(String string) { // 以参数指定打印的字串
  this.string = string;
 }

 public int getColumns() { // 字数
  return string.getBytes().length;
 }

 public int getRows() { // 行数为1
  return 1;
 }

 public String getRowText(int row) { // 仅在row为0时才返回
  if (row == 0) {
   return string;
  } else {
   return null;
  }
 }
}

SideBorder.java:
public class SideBorder extends Border {
 private char borderChar; // 装饰字符

 public SideBorder(Display display, char ch) { // 以构造子指定Display和装饰字符
  super(display);
  this.borderChar = ch;
 }

 public int getColumns() { // 字数要再加上內容两边的装饰字符
  return 1 + display.getColumns() + 1;
 }

 public int getRows() { // 行数同內容的行数
  return display.getRows();
 }

 public String getRowText(int row) { // 指定该行的內容即为在內容之指定行的两边
  // 加上装饰字符

  return borderChar + display.getRowText(row) + borderChar;
 }
}

UpDownBorder .java:
public class UpDownBorder extends Border {
 private char borderChar; // 装饰字符

 public UpDownBorder(Display display, char ch) { // 以构造子指定Display和装饰字符
  super(display);
  this.borderChar = ch;
 }

 public int getColumns() { // 字数同內容的字数
  return display.getColumns();
 }

 public int getRows() { // 行数要再加上內容上下的装饰字符的行数
  return 1 + display.getRows() + 1;
 }

 public String getRowText(int row) { // 指定该行的內容
  if (row == 0 || row == getRows() - 1) {
   return makeLine(borderChar, getColumns());
  } else {
   return display.getRowText(row - 1);
  }
 }

 private String makeLine(char ch, int count) { // 以字符ch，建立重复count次的连续字串
  StringBuffer buf = new StringBuffer();
  for (int i = 0; i < count; i++) {
   buf.append(ch);
  }
  return buf.toString();
 }
}

设计模式中定义: 为其他对象提供一种代理以控制对这个对象的访问.要用再建立
程序举例1：权限访问

public class ForumProxy implements Forum { private ForumPermissions permissions; private Forum forum; this.authorization = authorization; public ForumProxy(Forum forum, Authorization authorization, ForumPermissions permissions) { this.forum = forum; this.authorization = authorization; this.permissions = permissions; } ..... public void setName(String name) throws UnauthorizedException, ForumAlreadyExistsException { 　　//只有是系统或论坛管理者才可以修改名称 　　if (permissions.isSystemOrForumAdmin()) { 　　　　forum.setName(name); 　　} 　　else { 　　　　throw new UnauthorizedException(); 　　} } ... }

而DbForum才是接口Forum的真正实现,以修改论坛名称为例:

public class DbForum implements Forum, Cacheable { ... public void setName(String name) throws ForumAlreadyExistsException { 　　.... 　　this.name = name; 　　//这里真正将新名称保存到数据库中 　　saveToDb(); 　　.... } ... }

凡是涉及到对论坛名称修改这一事件,其他程序都首先得和ForumProxy打交道,由ForumProxy决定是否有权限做某一样事情,ForumProxy是个名副其实的"网关","安全代理系统".
程序举例2：用到才创建
实际执行打印 为了模仿长时间操作 在构建的时候延迟5S
public class Printer implements Printable {
 private String name;

 public Printer() {
  heavyJob("正在产生Printer的对象实例");
 }

 public Printer(String name) { // 构造子
  this.name = name;
  heavyJob("正在产生Printer的对象实例(" + name + ")");
 }

 public void setPrinterName(String name) { // 命名
  this.name = name;
 }

 public String getPrinterName() { // 取得名称
  return name;
 }

 public void print(String string) { // 输出名称
  System.out.println("=== " + name + " ===");
  System.out.println(string);
 }

 private void heavyJob(String msg) { // 较重的工作（假设）
  System.out.print(msg);
  for (int i = 0; i < 5; i++) {
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
   }
   System.out.print(".");
  }
  System.out.println("完成。");
 }
}
代理类：真正要打印了才去调用生成printer并且参数赋值进行打印操作
public class PrinterProxy implements Printable {
 private String name; // 名称

 private Printable real; // 「本人」

 private String className; // 「本人」的类名称

 public PrinterProxy(String name, String className) { // 构造子
  this.name = name;
  this.className = className;
 }

 public synchronized void setPrinterName(String name) { // 命名
  if (real != null) {
   real.setPrinterName(name); //「本人」也要命名
  }
  this.name = name;
 }

 public String getPrinterName() { // 取得名称
  return name;
 }

 public void print(String string) { // 输出到画面上
  realize();
  real.print(string);
 }

 private synchronized void realize() { // 产生「本人」
  if (real == null) {
   try {
    real = (Printable) Class.forName("Proxy." + className)
      .newInstance();
    real.setPrinterName(name);
   } catch (ClassNotFoundException e) {
    System.err.println("找不到类 " + className + "。");
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
 }
}
无论怎么调用setPrinterName方法都不会产生real实例 只有真正需要生成本人的时候才会生成
测试方法：
public class Main {
 public static void main(String[] args) {
  Printable p = new PrinterProxy("Alice", "Printer");
  System.out.println("现在的名称是" + p.getPrinterName() + "。");
  p.setPrinterName("Bob");
//不会生成Printer
  System.out.println("现在的名称是" + p.getPrinterName() + "。");
//不会生成Printer
  p.print("Hello, world.");
//生成Printer
 }
}

第二种形式:

使用Singleton.getInstance()可以访问单态类。

上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。

一般认为第一种形式要更加安全些。

Builder模式是一步一步创建一个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们.用户不知道内部的具体构建细节.Builder模式是非常类似抽象工厂模式,细微的区别大概只有在反复使用中才能体会到.

因为一个复杂的对象,不但有很多大量组成部分,如汽车,有很多部件:车轮 方向盘 发动机还有各种小零件等等,部件很多,但远不止这些,如何将这些部件装配成一辆汽车,这个装配过程也很复杂(需要很好的组装技术),Builder模式就是为了将部件和组装过程分开.

首先,需要一个接口,它定义如何创建复杂对象的各个部件:

public interface Builder { 　　//创建部件A　　比如创建汽车车轮 　　void buildPartA(); 　　//创建部件B 比如创建汽车方向盘 　　void buildPartB(); 　　//创建部件C 比如创建汽车发动机 　　void buildPartC(); 　　//返回最后组装成品结果 (返回最后装配好的汽车) 　　//成品的组装过程不在这里进行,而是转移到下面的Director类中进行. 　　//从而实现了解耦过程和部件 　　Product getResult(); }

用Director构建最后的复杂对象,而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的),也就是说Director的内容是如何将部件最后组装成成品:

public class Director { 　　private Builder builder; 　　public Director( Builder builder ) { 　　　　this.builder = builder; 　　} 　　// 将部件partA partB partC最后组成复杂对象 　　//这里是将车轮 方向盘和发动机组装成汽车的过程 　　public void construct() { 　　　　builder.buildPartA(); 　　　　builder.buildPartB(); 　　　　builder.buildPartC(); 　　} }

Builder的具体实现ConcreteBuilder:
通过具体完成接口Builder来构建或装配产品的部件;
定义并明确它所要创建的是什么具体东西;
提供一个可以重新获取产品的接口:

public class ConcreteBuilder implements Builder { 　　Part partA, partB, partC; 　　public void buildPartA() { 　　　　//这里是具体如何构建partA的代码 　　}; 　　public void buildPartB() { 　　　　//这里是具体如何构建partB的代码 　　}; 　　 public void buildPartC() { 　　　　//这里是具体如何构建partB的代码 　　}; 　　 public Product getResult() { 　　　　//返回最后组装成品结果 　　}; }

ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.construct();
Product product = builder.getResult();

builder类图：

        // 实现产生
        Product p1 = manager.create("strong message");
        p1.use("Hello, world.");
        Product p2 = manager.create("warning box");
        p2.use("Hello, world.");
        Product p3 = manager.create("slash box");
        p3.use("Hello, world.");
    }

也可以将product声明成抽象类实现Cloneable接口
并且实现createClone方法
这样子类中就不用再声明creatClone方法了 简化了代码

clone方法在Object中定义 因此所有类都会继承clone()方法
Cloneable这个接口表示 可用clone()方法进行复制
clone()方法做的是浅拷贝 所做的操作是直接复制字段内容 并不管该字段对应的对象实例内容 假定有一个数组 当使用clone方法进行拷贝以后 复制的结果，只是对应到该数组的参照 即指向该数组的内存地址 如果想做深拷贝 必须重写clone方法 记得要加上super.clone()

public class Factory{

　　public static Sample creator(int which){
         //getClass 产生Sample 一般可使用动态类装载装入类。
　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

}

那么在你的程序中,如果要实例化Sample时.就使用

Sample sampleA=Factory.creator(1);

这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误

2、Factory Pattern在父类规定对象的创建方法，但不深入到具体的类名，所有具体的实现都放在了子类，大致可以分为产生对象实例的大纲(框架)和实际产生对象实例的类两方面

实例：

framework中的Factory是实现creat的抽象类
 public final Product creat(String owner) {
  Product p = creadProduct(owner);
  registerProduct(p);
  return p;
 }

 public abstract Product creadProduct(String owner);
famework中的Product是仅实现use方法的抽象类

具体的生成和使用方法都用idcard中的类具体实现
 IDcardFactory：
 IDcardFactory extends Factory 
 public synchronized Product creadProduct(String owner) {
  IDcard ic = new IDcard(owner);
  return ic;
 }

IDcarrd：
class IDcard extends Product
IDcard(String owner) {
  System.out.println("建立" + owner +"的卡");
  this.owner = owner;
 }
此处构造函数不是public 只有通过同一个包中的factory才可以产生这个对象实例

 public void use() {
  System.out.println("使用"  + owner + "的卡");
 }

具体使用：
 public static void main(String[] args) {
  Factory fc = new IDcardFactory();
  Product p1 = fc.creat("card1");
  Product p2 = fc.creat("card2");
  Product p3 = fc.creat("card3");
  p1.use();
  p2.use();
  p3.use();
 }
这样不必修改framework包中的内容就能够创建出不同的产品和工厂