创建型模式

FactoryMethod

package lq.test;

import java.io. * ;
import java.util. * ;

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

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

abstract class Factory ... {
abstractpublicProductfmd();

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

System.out.println("beforeoperation");

pd=fmd();

System.out.println("endoperation");

returnpd;
}
}

class Product1 implements Product ... {
}

class Factory1 extends Factory ... {
publicProductfmd()...{
Productpd=newProduct1();
returnpd;
}
}

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

interface Factorya ... {
Productacreate();
}

class Producta1 implements Producta ... {}

class Factorya1 implements Factorya ... {
publicProductacreate()...{
Productapda=null;
pda=newProducta1();
returnpda;
}
}

AbstractFactory

package lq.test;
import java.io. * ;
import java.util. * ;

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

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

interface Apdb ... {}

interface Afactory ... {
ApdacreateA();
ApdbcreateB();
}

class Apda1 implements Apda ... {}

class Apdb1 implements Apdb ... {}

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

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

Buider

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

interface Cpda ... {}

class Cpda1 implements Cpda ... {}

interface BuilderI ... {
voidbuildPart1();
voidbuildPart2();

voidinitPd();
CpdagetPd();
}

abstract class BuilderA implements BuilderI ... {
Cpdacpda;

publicCpdagetPd()...{
initPd();

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

returncpda;
}
}

class Builder extends BuilderA ... {
publicvoidbuildPart1()...{
System.out.println(cpda);
}

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

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

Singleton

class Singleton1 ... {
publicstaticSingleton1instance=newSingleton1();

privateSingleton1()...{
}

publicstaticSingleton1getInstance()...{
returninstance;
}
}

class Singleton2 ... {
publicstaticSingleton2instance;

privateSingleton2()...{
}

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

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

returninstance;
}
}