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类无法判断目录下的一些目录是文件夹或则是文件时？

     享元模式包括两种状态，内蕴状态和外蕴状态。他的种类有单纯享元模式和复合享元模式，结构图如下：

我们从结构种可以看出，复合享元模式是由单纯享元模式和合成模式组合而成的。

享元模式有四种角色：抽象享元角色，具体享元角色，享元工厂角色，和客户角色。享元模式中的享元工厂角色可以通过单例模式来实现。

使用条件：

        他的各个角色的作用为：抽象角色：给出一个抽象的接口，以规范准备接收附加责任的对象。

        具体角色：定义一个将要接收附加责任的类。

        装饰角色：持有一个构件对象的实例，并定义一个雨抽象接口一致的接口。

        具体装饰角色：负责给构件对象“贴上”附加责任。

装饰类一般在以下情况使用：

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

2、  需要动态的给一个对象增加功能，这些功能可以再动态的测销。

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

他有很多特点：

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

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

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

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

 

sky 2005-08-11 22:36 发表评论

]]>

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());
 }
}

装饰模式—Decorator

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

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

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

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

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

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

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