他有很多特点：

1、  装饰模式雨继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。装饰模式准系统动态的决定“贴上”一个需要的“装饰”，或者除掉一个不需要的装饰。而继承则不同，继承关系是静态的，他在系统运行前就决定了。

2、  他可以通过使用不同的具体修饰类以及这些装饰类的排例组合，设计可以创造更多不同行为的组合。     

3、  他虽然比继承性要灵活，这意味着他比继承更容易出错。

缺点：由于使用装饰模式可以比使用继承关系需要较少数目的类，但是在另一方面，使用装饰模式会产生比使用继承方式更多的对象。这在使用时进行错误查询变得更困难了，特别是这些对象看上去都很像。

import java.util.*;

class BookName{
 String name;
 int number;
}
abstract class Note{
 BookName name = new BookName();
 abstract public void setName(String value);
 abstract public int getNumber();
 abstract public void setNumber(int value);
 abstract public String getName();
} 
class StudentNote extends Note implements Cloneable{
 BookName name = new BookName();
 int isbn;
 public void setName(String value){
  name.name = value;
 }
 public void setNumber(int i){
  name.number = i;
 }
 public int getNumber(){
  return name.number;
 }
 public String getName(){
  return name.name;
 }
 public Object clone() throws CloneNotSupportedException{
  StudentNote st = new StudentNote();
  st = (StudentNote)super.clone();
  st.name = new BookName();
  st.name.name = name.name;
  st.name.number = name.number;
  return st;
 }
 public void setIsbn(int i){
  isbn = i;
 }
 public int getIsbn(){return isbn;}
}
class Manager{
 private Vector v = new Vector();
 
 public void add(Note note){
  v.addElement(note);
 }
 public Note get(int i){
  return (Note)v.get(i);
 }
 public int size(){
  return v.size();
 }
}

class Client{
 private StudentNote student;
 private static Manager client = new Manager();
 public void register()throws CloneNotSupportedException{
  student = new StudentNote();
  StudentNote st = (StudentNote)student.clone();
  client.add(st);
 }
 public static Manager getInstance(){
  return client;
 }

}

class test{ 
 public static void main(String[] args)throws CloneNotSupportedException {
  Client c = new Client();
  c.register(); 
  c.register();
  Manager manager = c.getInstance();
  StudentNote student = (StudentNote)manager.get(0);
  StudentNote st = (StudentNote)manager.get(1);
  student.setName("sky");
  student.setNumber(101);
  student.setIsbn(10001);
  st.setName("fly");
  st.setNumber(102);
  st.setIsbn(10002);
  System.out.println(student.getName() + "\t" + student.getNumber() + "\t" + student.getIsbn());
  System.out.println(st.getName() + "\t" + st.getNumber() + "\t" + st.getIsbn());
 }
}

  <java与模式> ---电子书 page 425

装饰模式—Decorator

装饰模式有名包装模式，装饰模式以对客户端透明的方式来扩展对象的功能，是继承关系的一个替代的方案。

客户端并不会觉得装饰模式在装饰前和装饰后有什么不同，他可以在不使用更多的子类的情况下来进行对对象的功能加以扩展。结构图如下：

装饰模式原来被装饰类的一个子类的实例，把客户端的调用委派到被装饰类。他有以下组成：抽象构件，具体构件，装饰角色，具体装饰；他一般在下面这些情况使用他最好：

1、  需要扩展一个类的功能，或给一个类增加附加责任。

2、  需要动态的给一个对象增加功能，这些功能可能被动态的撤消。

3、  需要增加一些基本功能的排例组合而产生的非常大量的功能，从而使继承关系变得不现实。

优点：他可以灵活的增加一个类或对象的功能，也可以通过不同的具体装饰类的排例组合设计出更加复杂的，功能更强的类。

import java.io.*;

public class FileRead{
 private static int space=0;
 private static double totalFile = 0;
 private static double totalDirectory = 0;
 
 public String printSpace(int space){
  String str = "";
  for(int i=0;i<space;i++)
   str += "    ";
  return str; 
 }

 public void searchFile(File f)throws IOException{
  String path = f.getAbsolutePath();
  File currentFile = new File(path); //取得当前路径的文件
  File[] file = currentFile.listFiles();
  
  space++;

  for(int i=0;i<file.length;i++){
   System.out.println(printSpace(space) + file[i].getName());
   if(file[i].isDirectory()){
    totalDirectory  += 1;
    searchFile(file[i]);
    if(space>0)
     space--;   
   }
   totalFile += 1; 
  }
 } 
 public static void main(String args[])throws IOException{
  String path = null;
  if(args.length<1)
   path =".";
  else
   path = args[0];
  FileRead read = new FileRead();
  File file = new File(path);
  
  if(!file.exists()){
   System.err.print("the path is error");
   System.exit(1);
  } 
  read.searchFile(file);
  System.out.println("the file is :" + (totalFile-totalDirectory));
  System.out.println("thd directory is : " + totalDirectory);
 }
}
这个程序在便历多文件时会出现问题？不知道问题在哪里？

合成模式
        合成模式他是一种树型结构，他可以通过对合成的图的单独部分方法达到对整个合成图方法问。他由三部分组成，抽象构件—Component和树枝构件—Composite以及树叶构件Leaf。合成模式分为两种，一种是透明式的。另一个是安全式的合成模式。
         透明式的合成模式和安全式的合成模式，他们的组成成分都一样，他们的区别是：透明式的合成模式，他在抽象构件种增加了操作子类对象的一些接口，这样在实现的过程中，无论是树枝构件还是树叶构件都必须实现这些接口，这对树叶构件来说，这种接口实现是多余的，所以树叶构件是通过平庸式的方式来实现，这种实现，将造成编译时可以通过，但是当用户在应用的过程过如果调用这些方法，将造成运行时的错误，这就造成了程序的不安全；而安全式的合成模式，他并没有在抽象构件实现对子结点接口的申明，他是通过树枝直接对管理子类所需要的方法进行申明，这就给程序带来灵活性，但是也给程序带来不便的管理性，这种实现使得程序不会出现运行时的错误。
         一般我们在这样的情况下应用合成模式：
                  1、当我们要体现构件的部分和整体的结构时。
                  2、当我们要要忽略个体构件与整体构件的区别时，并且要平等的对待个体构件和整体构件时。
         使用合成构件有以下好处：
                  1、使用合成模式可以很容易的增加新构件的种类。
                  2、使用合成模式方便了用户对构件的使用，因为他们不用担心使用的是树页构件还是树枝构件。
         他的缺点：使用合成模式之后在控制树枝构件的类型就不是那么容易了。

      <java与模式> ---电子书

结构模式(Structural Pattern)描述的是类和对象结合在一起行成的更大的结构。分为类的结构模式和对象的结构的结构模式。类的结构模式如：适配器模式，对象的结构模式：代理人模式。

结构模式：合成模式、享元模式、装饰模式、适配器模式、缺省适配器模式、代理模式、门面模式、桥梁模式

适配器模式与缺省适配器模式——Adapter ，Default Adapter  page349 第22章

适配器模式就是把一个类的接口变换成客户端所期待的接口，从而使原来因接口不匹配而无法在一起工作的两个类可以在一起工作。它有两种模式，一种是类的适配器模式，一种叫对象的适配器模式。

模式中三种角色：

1、  目标角色：这就是客户端所期待的接口。

2、  源角色：现有的适配接口。

3、  适配器角色：它负责叫源接口转换成目标接口。

类适配器一般用的是继承的方式来实现的，但对象适配器是用的委派。其中对象适配器比起类配器有一些优势，它可以将不同源适配到同一个目标，它甚至可以适配同一个源和它的子类，这对类适配器来说很难的。（类适配器就要先做一个源类的子类，然后将源类的子类进行适配）

系统在什么时候使用适配器：

1、  系统需要使用现有的类，而此类的接口有不符合系统的要求。

2、  想成立一个可以重复使用的类，用于将那些之间没有太大的关系的类一起工作。

缺省适配器模式：它和适配器模式几乎相同，它的作用也和适配器的作用一样，它是适配器模式中的一种特殊的模式。其中的适配器类是一个平庸化的类，它是一个抽象类，但是它实现了从源接口中继承的所有方法，如果不存在适配类的子类，那么适配类就没有意义。如：WindowListener 的适配类WindowsAdapter。

J2SE中的缺省适配器模式