模板Ҏ中分两种ҎQ一U是模板ҎQ另一U是基本Ҏ?BR> 模板ҎQ就是把基本Ҏl合在一起Ş成一个ȝ法或则总行为，q个模板Ҏ一般会在抽象定义ƈ且在子类U不加以修改的承下来。一个抽象类可以有Q意多个模板方法?BR> 基本ҎQ它又分为抽象方法，具体ҎQ钩子方法?BR> 抽象Ҏ由抽象类xQ由子类具体实现Q具体方法由抽象cȝ明ƈ实现Q而子cdƈ不实现或则置换，q里面也可以有工厂方法；钩子ҎQ由抽象cȝ明ƈ实现Q但是它是一个空的实玎ͼ一般都是由子类q行扩张实现?img src ="http://www.aygfsteel.com/sky_team/aggbug/10550.html" width = "1" height = "1" />
]]>
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); //取得当前路径的文?BR> File[] file = currentFile.listFiles();
for(int i=0;i<file.length;i++){
StringBuffer s = null;
String lastDirectory = null;
/*
* 判断文gҎ否ؓ该目录下的最后一个文件夹Q如果是的话Q则取消打印"?W号
*/
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);
}
}
/*
* 格式化打华ͼ符h后的"──"变ؓ"├──"Q当最后的W号不ؓ"│──"Ӟ
*/
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不ؓI，则将s传入Ҏreplace中进行格式化
*/
if(s != null)
System.out.println(replace(s.toString()) + file[i].getName());
if(file[i].isDirectory()){
totalDirectory += 1;
/*
* 如果该文件夹的子目录下还有两个以上的文g和文件夹Q则打印一??W号Qƈ标记bool为true
*/
String pathstring = file[i].getAbsolutePath();
File current = new File(pathstring); //取得当前路径的文?BR> File[] fp = current.listFiles();
if(fp.length >1){
bool = true;
}
if(bool)
string.append("?);
searchFile(file[i],string.toString(),bool);
/*
* 如果bool已经被标记过Q则上一ơ的"?W号删除
*/
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中的FilecL法判断目录下的一些目录是文gҎ则是文gӞ
]]>
{略模式的对法的包装，是把使用法的责d法本生分开Q委z不同的对象管理。策略模式通常把一个系列的法包装Cpd的策略类里面Q作Z个抽象策略类的子cR?BR>使用条gQ?BR> 如果在一个系l种有许多类Q他们之间的区别仅仅在于他们的行为，q且q个pȝ需要动态的在几U算法种选择一U?nbsp;
]]>
不变模式可以增强对象的强壮性，不变模式准许多个对象׃n一个对象，q降低了对该对象q行q发讉K时的同步化开销。如果要修改一个不变对象的状态，则需要创Z个新的对象，q将其存入新的对象里。不变模式只涉及C个类Q一个类的内部状态一旦被创徏以后Q在整个期间都不会发生变化。他有两U一U是Z变模式和׃变模式?BR> ׃变模式：
首先满没有Ҏ可以改变对象的状态，则对象一旦被创徏之后Q对象的状态就不会改变。二该对象的所有的属性都是私有的Qƈ且不准许声明M公有的方法来改变他们。三q个对象所引用的对象也应该是不变的对象Q如果在初始化时应用了一个可变的对象Q则应该对该可变对象q行复制一份，而不要用原来的拯。这U模式的~点是他可以用子c，q且子类可以是可变的对象。可变的子类可能一修改父类对象的状态，从而可能会允许外界修改父对象的状态?BR>
问题Q?/FONT>
Z么说可变的对象可以修该父cd象的状态呢Q怎样做？
Z变模式首先要满׃变模式，然后这个类声明成finalc，则它变不可能有子cMQƈ且也该对象所考虑到的所有方法声明ؓfinal?BR>不变模式与n元模式有很大的相同处Q他们的对象状态都有要求不随环境的变化而变化，不过享元模式的内늊态在不媄响n元对象的׃nӞ可以为可变的。不变模式对对象的要求要比n元模式对对象的要求更严格?BR>
]]>
桥梁模式是抽象化和实现化脱藕，使得两者可以独立地变法。例子如java中的peer架构?BR> 桥梁模式与适配器模式的区别是，
]]>
]]>
享元模式包括两种状态，内蕴状态和外蕴状态。他的种cL单纯享元模式和复合n元模式，l构囑֦下：
我们从结构种可以看出Q复合n元模式是由单Un元模式和合成模式l合而成的?/SPAN>
享元模式有四U角Ԍ抽象享元角色Q具体n元角Ԍ享元工厂角色Q和客户角色。n元模式中的n元工厂角色可以通过单例模式来实现?/SPAN>
使用条gQ?/SPAN>
]]>
他的各个角色的作用ؓQ抽象角Ԍl出一个抽象的接口Q以规范准备接收附加责Q的对象?/SPAN>
具体角色Q定义一个将要接攉加责ȝcR?/SPAN>
装饰角色Q持有一个构件对象的实例Qƈ定义一个雨抽象接口一致的接口?/SPAN>
具体装饰角色Q负责给构g对象“脓上”附加责仅R?/SPAN>
装饰cM般在以下情况使用Q?/SPAN>
1?SPAN style="FONT: 7pt 'Times New Roman'">
需要扩展一个类的功能，或给一个类增加附加责Q?/SPAN>2?SPAN style="FONT: 7pt 'Times New Roman'">
需要动态的l一个对象增加功能，q些功能可以再动态的销?/SPAN>3?SPAN style="FONT: 7pt 'Times New Roman'">
需要增加由一些基本的排列l合产生非常大量的功能，从而ɾl承关系变得不现实?/SPAN>
他有很多特点Q?/SPAN>
1?SPAN style="FONT: 7pt 'Times New Roman'">
2?SPAN style="FONT: 7pt 'Times New Roman'">
他可以通过使用不同的具体修饰类以及q些装饰cȝ排例l合Q设计可以创造更多不同行为的l合?/SPAN>3?SPAN style="FONT: 7pt 'Times New Roman'">
他虽然比l承性要灉|Q这意味着他比l承更容易出错?/SPAN>~点Q由于用装饰模式可以比使用l承关系需要较数目的c，但是在另一斚wQ用装饰模式会产生比用承方式更多的对象。这在用时q行错误查询变得更困难了Q特别是q些对象看上去都很像?/SPAN>
]]>
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());
}
}
]]>
装饰模式?/SPAN>Decorator
装饰模式有名包装模式Q装饰模式以对客L透明的方式来扩展对象的功能，是承关pȝ一个替代的Ҏ?/SPAN>
客户端ƈ不会觉得装饰模式在装饰前和装饰后有什么不同，他可以在不用更多的子类的情况下来进行对对象的功能加以扩展。结构图如下Q?BR>
装饰模式原来被装饰类的一个子cȝ实例Q把客户端的调用委派到被装饰cR他有以下组成：抽象构gQ具体构Ӟ装饰角色Q具体装饎ͼ他一般在下面q些情况使用他最好：
1?SPAN style="FONT: 7pt 'Times New Roman'">
需要扩展一个类的功能，或给一个类增加附加责Q?/SPAN>2?SPAN style="FONT: 7pt 'Times New Roman'">
需要动态的l一个对象增加功能，q些功能可能被动态的撤消?/SPAN>3?SPAN style="FONT: 7pt 'Times New Roman'">
需要增加一些基本功能的排例l合而生的非常大量的功能，从而ɾl承关系变得不现实?/SPAN>优点Q他可以灉|的增加一个类或对象的功能Q也可以通过不同的具体装饰类的排例组合设计出更加复杂的，功能更强的类?/SPAN>
]]>