第一篇javaEye文章

本人开这个博客的想法就是想好好学一下java里面的设计模式，先贴一篇“创建型模式”的代码，希望

大家多多批评指正，呵呵！

写道

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
//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;
}
}

//Builder
//一个产品的生成分为生成部件和组装部件，不同的产品每个部件生成的方式不同
//而组装的方式相同，部件的生成抽象成接口方法，而组装的方法使用一个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();
}
}

//一个简单的生成产品的实现
//1
abstract class Fy {
public abstract void med1();

static class Fy1 extends Fy {
public void med1() {
}
}

public static Fy getInstance() {
Fy fy = new Fy1();
return fy;

// Fy fy = new Fy1() {//这种匿名内部类是静态的！！
// public void med1() {
// }
// };
// return fy;
}
}

//2
interface Pdd {}

class Pdd1 implements Pdd {}

abstract class Fya {
public static Pdd getPd() {
Pdd pdd = new Pdd1();
return pdd;
}
}

//Prototype 在java中就是clone，又包含深拷贝和浅拷贝
class CloneObja {
public CloneObja MyClone() {
return new CloneObja();
}
}

class CloneObjb {
public CloneObjb MyClone() throws Throwable {
CloneObjb cobj = null;
cobj = (CloneObjb) pcl(this);
return cobj;
}

//深度拷贝算法
private Object pcl(Object obj) throws Throwable {
ByteArrayOutputStream bao = new ByteArrayOutputStream(1000);
ObjectOutputStream objo = new ObjectOutputStream(bao);
objo.writeObject(obj);

ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray());
ObjectInputStream obji = new ObjectInputStream(bai);

Object objr = obji.readObject();
return objr;
}
}

//Singleton
//一个类只有一个对象，例如一个线程池，一个cache
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;
}
}