创建型模式

FactoryMethod

package  lq.test;

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

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

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

abstract   class  Factory  ... {
abstract public Product fmd();

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

System.out.println("before operation");

pd = fmd();

System.out.println("end operation");

return pd;
}
}

class  Product1  implements  Product  ... {
}

class  Factory1  extends  Factory  ... {
public Product fmd() ...{
Product pd = new Product1();
return pd;
}
}

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

interface  Factorya  ... {
Producta create();
}

class  Producta1  implements  Producta  ... {}

class  Factorya1  implements  Factorya  ... {
public Producta create() ...{
Producta pda = null;
pda = new Producta1();
return pda;
} 
}

  AbstractFactory

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

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

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

interface  Apdb  ... {}

interface  Afactory  ... {
Apda createA();
Apdb createB();
}

class  Apda1  implements  Apda  ... {}

class  Apdb1  implements  Apdb  ... {}

// 有几个接口就有几个对应的方法
class  Afactory1  implements  Afactory  ... {
public Apda createA() ...{
Apda apda = null;
apda = new Apda1();
return apda;
}

public Apdb createB() ...{
Apdb apdb = null;
apdb = new Apdb1();
return apdb;
}
}

Buider

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

interface  Cpda  ... {}

class  Cpda1  implements  Cpda  ... {}

interface  BuilderI  ... {
void buildPart1();
void buildPart2();

void initPd();
Cpda getPd();
}

abstract   class  BuilderA  implements  BuilderI  ... {
Cpda cpda;

public Cpda getPd() ...{
initPd();

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

return cpda;
}
}

class  Builder  extends  BuilderA  ... {
public void buildPart1() ...{
System.out.println(cpda);
}

public void buildPart2() ...{
System.out.println(cpda);
}

public void initPd() ...{
cpda = new Cpda1();
}
}

Singleton 

class  Singleton1  ... {
public static Singleton1 instance = new Singleton1();

private Singleton1() ...{
}

public static Singleton1 getInstance() ...{
return instance;
}
}

class  Singleton2  ... {
public static Singleton2 instance;

private Singleton2() ...{
}

//public static Singleton2 getInstance() {
//if (instance == null) {
//instance = new Singleton2();
//}
//
//return instance;
//}

public static Singleton2 getInstance() ...{
synchronized(Singleton2.class) ...{
if (instance == null) ...{
instance = new Singleton2();
}
}

return instance;
}
}