创建型模式

FactoryMethod

packagelq.test;

importjava.io.*;
importjava.util.*;

//factorymethod1
//1具体的构造算法，和2构造出的具体产品由子类实现
interfaceProduct...{
}

//或者我也提供一个工厂的接口，由这个抽象类来继承它

abstractclassFactory...{
abstractpublicProductfmd();

//我认为这个方方法的存在是，是对FactoryMethod方法的补充
//例如可以为生成的对象赋值，计算为生成对象应付何值，前后的日值
//且这些都是公用的，生成产品的最主要算法还是在FactoryMethod中，
//这个方法只是起辅助作用，这也是一种思维方法，将具体的算法实现在一个方法中
//而我不直接调用此方法，而使用另外的一个方法封装它，等到了更灵活的效果，而
//子类需实现的内容是FactoryMethod
//此方法是一个TemplateMethod
publicProductcreat()...{
Productpd=null;

System.out.println("beforeoperation");

pd=fmd();

System.out.println("endoperation");

returnpd;
}
}

classProduct1implementsProduct...{
}

classFactory1extendsFactory...{
publicProductfmd()...{
Productpd=newProduct1();
returnpd;
}
}

//FactroyMethod2
//这种方式简单实用
interfaceProducta...{
}

interfaceFactorya...{
Productacreate();
}

classProducta1implementsProducta...{}

classFactorya1implementsFactorya...{
publicProductacreate()...{
Productapda=null;
pda=newProducta1();
returnpda;
}
}

AbstractFactory

packagelq.test;
importjava.io.*;
importjava.util.*;

//AbstractFactory与FactoryMethod的不同在于AbstractFactory创建多个产品
//感觉此模式没有什么大用

//当然可以还有更多的接口
interfaceApda...{}

interfaceApdb...{}

interfaceAfactory...{
ApdacreateA();
ApdbcreateB();
}

classApda1implementsApda...{}

classApdb1implementsApdb...{}

//有几个接口就有几个对应的方法
classAfactory1implementsAfactory...{
publicApdacreateA()...{
Apdaapda=null;
apda=newApda1();
returnapda;
}

publicApdbcreateB()...{
Apdbapdb=null;
apdb=newApdb1();
returnapdb;
}
}

Buider

//一个产品的生成分为生成部件和组装部件，不同的产品每个部件生成的方式不同
//而组装的方式相同，部件的生成抽象成接口方法，而组装的方法使用一个TemplateMethod方法

interfaceCpda...{}

classCpda1implementsCpda...{}

interfaceBuilderI...{
voidbuildPart1();
voidbuildPart2();

voidinitPd();
CpdagetPd();
}

abstractclassBuilderAimplementsBuilderI...{
Cpdacpda;

publicCpdagetPd()...{
initPd();

//对对象的内容进行设置
buildPart1();
buildPart2();

returncpda;
}
}

classBuilderextendsBuilderA...{
publicvoidbuildPart1()...{
System.out.println(cpda);
}

publicvoidbuildPart2()...{
System.out.println(cpda);
}

publicvoidinitPd()...{
cpda=newCpda1();
}
}

Singleton

classSingleton1...{
publicstaticSingleton1instance=newSingleton1();

privateSingleton1()...{
}

publicstaticSingleton1getInstance()...{
returninstance;
}
}

classSingleton2...{
publicstaticSingleton2instance;

privateSingleton2()...{
}

//publicstaticSingleton2getInstance(){
//if(instance==null){
//instance=newSingleton2();
//}
//
//returninstance;
//}

publicstaticSingleton2getInstance()...{
synchronized(Singleton2.class)...{
if(instance==null)...{
instance=newSingleton2();
}
}

returninstance;
}
}