模板模式：
       
         模板方法中分两种方法：一种是模板方法，另一种是基本方法。
         模板方法：就是把基本方法组合在一起形成一个总算法或则总行为，这个模板方法一般会在抽象定义并且在子类种不加以修改的继承下来。一个抽象类可以有任意多个模板方法。
         基本方法：它又分为抽象方法，具体方法，钩子方法。
      抽象方法由抽象类申明，由子类具体实现；具体方法由抽象类申明并实现，而子类并不实现或则置换，这里面也可以有工厂方法；钩子方法，由抽象类申明并实现，但是它是一个空的实现，一般都是由子类进行扩张实现。

import java.io.*;

public class FileRead{
 private static double totalFile = 0;
 private static double totalDirectory = 0;

 public String replace(String value){
     StringBuffer replace = new StringBuffer(value);
     int i = 0;
     int last = replace.lastIndexOf("──");
     i = replace.indexOf("──");
     while((i != last)&&(i != -1)){
         replace.replace(i,i+"──".length(),"   ");
         i = replace.indexOf("──");
         last = replace.lastIndexOf("──");
     }
     return replace.toString();
 }

 public void searchFile(File f,String value,boolean b)throws IOException{
     StringBuffer string = new StringBuffer(value);
     string.append("──");
     boolean bool = b;
  String path = f.getAbsolutePath();
  File currentFile = new File(path); //取得当前路径的文件
  File[] file = currentFile.listFiles();

  for(int i=0;i<file.length;i++){      
      StringBuffer s = null;
      String lastDirectory = null; 
     
      /*
       * 判断文件夹是否为该目录下的最后一个文件夹，如果是的话，则取消打印"│"符号
       */
      for(int k=0;k<file.length;k++){
       if(file[k].isDirectory())
        lastDirectory = new String(file[k].getName()); 
      }
      if(file[i].getName().equals(lastDirectory)){
       if(string.indexOf("│") != -1){
           string.delete(string.lastIndexOf("│"),string.lastIndexOf("│")+1);
       }
      }
       
      /*
       * 格式化打印，将符号最后的"──"变为"├──"（当最后的符号不为"│──"时）
       */     
      if(!((string.lastIndexOf("──")-1) == string.lastIndexOf("│──"))){
          s = new StringBuffer(string.substring(0,string.lastIndexOf("──")));
       s.append("├──");         
      }else{
       if(string.indexOf("│──")!=-1){
        s = new StringBuffer(string.substring(0,string.lastIndexOf("│──")));
        s.append("├──");
       }
      }
     
      if(file[i].getName().equals(file[file.length-1].getName()))
       if(s != null)
        if(s.lastIndexOf("├") != -1)
         s.replace(s.lastIndexOf("├"),s.lastIndexOf("├")+1,"└");
     
      /*
       * 如果s不为空，则将s传入方法replace中进行格式化
       */
      if(s != null)           
       System.out.println(replace(s.toString()) + file[i].getName());
           
   if(file[i].isDirectory()){   
       totalDirectory  += 1;
        
       /*
        * 如果该文件夹的子目录下还有两个以上的文件和文件夹，则打印一个"│"符号，并标记bool为true
        */
           String pathstring = file[i].getAbsolutePath();
     File current = new File(pathstring); //取得当前路径的文件
     File[] fp = current.listFiles();
     if(fp.length >1){
         bool = true;                  
     }
    
       if(bool)
        string.append("│");
      
       searchFile(file[i],string.toString(),bool);
      
       /*
        * 如果bool已经被标记过，则将上一次的"│"符号删除
        */
       if(bool)
        if(string.indexOf("│") != -1)
            string.delete(string.lastIndexOf("│"),string.length());
       bool = false; 
   }
   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,"│",false);
  System.out.println("the file is :" + (totalFile-totalDirectory));
  System.out.println("thd directory is : " + totalDirectory);
 }
}

该程序存在一个问题，也就是当jdk中的File类无法判断目录下的一些目录是文件夹或则是文件时？

策略模式：

        策略模式的对算法的包装，是把使用算法的责任和算法本生分开，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。
使用条件：
        如果在一个系统种有许多类，他们之间的区别仅仅在于他们的行为，并且这个系统需要动态的在几种算法种选择一种。        不变模式：
       
        不变模式可以增强对象的强壮性，不变模式准许多个对象共享一个对象，这降低了对该对象进行并发访问时的同步化开销。如果要修改一个不变对象的状态，则需要创建一个新的对象，并将其存入新的对象里。不变模式只涉及到一个类，一个类的内部状态一旦被创建以后，在整个期间都不会发生变化。他有两种一种是强不变模式和弱不变模式。
        弱不变模式：
首先满足没有方法可以改变对象的状态，则对象一旦被创建之后，对象的状态就不会改变。二该对象的所有的属性都是私有的，并且不准许声明任何公有的方法来改变他们。三这个对象所引用的对象也应该是不变的对象，如果在初始化时应用了一个可变的对象，则应该对该可变对象进行复制一份，而不要使用原来的拷贝。这种模式的缺点是他可以用子类，并且子类可以是可变的对象。可变的子类可能一修改父类对象的状态，从而可能会允许外界修改父对象的状态。

问题：
       为什么说可变的对象可以修该父类对象的状态呢？怎样做？

强不变模式首先要满足弱不变模式，然后将这个类声明成final类，则它变不可能有子类了，并且也将该对象所考虑到的所有方法声明为final。
不变模式与享元模式有很大的相同处，他们的对象状态都有要求不随环境的变化而变化，不过享元模式的内涵状态在不影响享元对象的共享时，可以为可变的。不变模式对对象的要求要比享元模式对对象的要求更严格。


桥梁模式：
   
        桥梁模式就是抽象化和实现化脱藕，使得两者可以独立地变法。例子如java中的peer架构。
        桥梁模式与适配器模式的区别是， 门面模式：
        在外界访问要访问多个内部系统时，并且他与这些内部系统有着复杂的关系时，我们则可以用门面模式来解决这样的问题。
         门面模式他只是提供一个可以共外界方便访问内部子系统的一个接口，他并不会对子系统进行扩展，他只提供子系统所具有的方法。对外界来说，他是一个子系统，但是内部的子系统并不知道有这么一个类。例如：一个学生要去图书馆借书，这里有3个表，rule是记录不同的读者的借书规则（如研究生可以借7而本科生只能借4本），publish表是记录过期未还书的学生，passwork是记录图书馆所颁发过的借书证。如果一个学生要借书，则他必须要有一个在passwork中存在的借书证，并且没有在publish中的情况，则可以保证向该学生提供借阅，但是借阅的书则要按rule中的规则来进行。所以一个学生client借书必须访问这些类，为了便于管理，我们提供一个  FacadeFactory类来处理，这个类提供了所有client向子系统访问的方法。这样对于client来说就轻松多了，也便于我们维护代码了。但是FacadeFactory不能够向client提供内部子系统不存在的方法。
        由于一个系统中所需要的只需要一个实例，则我们可以把门面类设置为单例类，如上面的FacadeFactory，他应该设置为一个单例类，这样就不会发生多个人同时借一本书了。