23种设计模式示例（学习整理中）

1.singleton（单例模式，有些地方称为单身模式）：保证一个类只有一个实例对象，并提供访问这个实例的全局访问点。

当然实例可以在静态代码块、属性、方法、构造函数中进行初始化，建议使用静态代码块的方式创建实例。

1.1通过静态代码块创建

public class Singleton_StaticBlock {
	private static Singleton_StaticBlock singleton_StaticBlock=null;
	static
	{
		singleton_StaticBlock=new Singleton_StaticBlock();
	}
	private Singleton_StaticBlock(){};
	public static Singleton_StaticBlock getInstance()
	{
		return singleton_StaticBlock;
	}
}

1.2 通过属性创建唯一实例

public class Singleton_Per {
	private final static Singleton_Per singleton=new Singleton_Per();
	private Singleton_Per(){};
	public static Singleton_Per getInstance()
	{
		return singleton;
	}
}

1.3 通过方法创建

public class Singleton_Method {
	private static Singleton_Method singleton=null;
	private Singleton_Method(){};
	public static Singleton_Method getInstance()
	{
		if(singleton==null)
		{
			singleton=new Singleton_Method();
		}
		return singleton;
	}
}

1.4通过构造函数创建

public class Singleton_Con {
	private static Singleton_Con single=null;
	public Singleton_Con()
	{
		if(single==null)
		{
			single=new Singleton_Con();
		}
	}
	public Singleton_Con getInstance()
	{
		return single;
	}
}

1.5 1.3改进，线程同步

	private static Singleton_Method singleton = null;
	private Singleton_Method() {
	};
	public static Singleton_Method getInstance() {
		if (singleton == null) {
			synchronized (Singleton_Method.class) {
				if (singleton == null) {
					singleton = new Singleton_Method();
				}
			}
		}
		return singleton;
	}
}

ps:这4种方式的单例模式中1.1最好，1.1利用静态代码块只初始化一次的特性实现，通过getInstance()获得实例不需要判断实例是否存在即可获得唯一实例对象，相对于另外几种来说效率上也会更好；1.2通过属性创建唯一实例，这种方法的特点是在属性中用final修饰静态属性来保证实例只初始化一次，有些地方也称这种模式为醉汉式singleton；1.3的这种实例也成为懒汉式singleton，这种情况存在线程安全问题，在多线程的环境下初始化实例可能会存在这种情况：当2个线程都执行到singleton=new Singleton_Method();这时实例并未创建，虽然最终可以获得同一个实例对象，但是这样就使得实例创建过2次，最近一次覆盖了以前的实例。可以采用synchronized进行线程同步，如1.5,线程同步后的代价会使得效率比1.3更差；1.4和1.3差不多，但是1.4需要通过new对象后再调用方法来获得唯一实例（newSingleton_Con().getInstance();）,而且不安全。

singleton被不同的classload装载的时候还是无法获得同一个实例对象的。

---

2.simple_factory

提供一个创建对象的方法，根据传入类型决定实例化哪个对象

Fruit.java Fruit_Interface

package com.wzucxd.designpattern.create.simple_factory;
public interface Fruit{
	public void getType();
}

Apple.java Apple implements Fruit

package com.wzucxd.designpattern.create.simple_factory;
public class Apple implements Fruit{
	public void getType() {
		System.out.println("this is an apple");
	}
	
}

Banana.java Banana implements Fruit

package com.wzucxd.designpattern.create.simple_factory;
public class Banana implements Fruit{
	public void getType() {
		System.out.println("this is an banana");
	}
}

FruitFactory.java

package com.wzucxd.designpattern.create.simple_factory;
public class FruitFactory {
	public final static int FruitFactory_APPLE=100;//apple
	public final static int FruitFactory_BANANA=101;//banana
	public static Fruit getFruit(int fruittype)
	{
		Fruit fruit=null;
		switch(fruittype)
		{
			case FruitFactory_APPLE:
				fruit=new Apple();
				break;
			case FruitFactory_BANANA:
				fruit=new Banana();
				break;
		}
		return fruit;
	}
}

Test.java

package com.wzucxd.designpattern.create.simple_factory;
public class Test {
	public static void main(String[] args) {
		Fruit apple=FruitFactory.getFruit(FruitFactory.FruitFactory_APPLE);
		apple.getType();
	}
}

ps:这个模式存在问题：当增加一种水果的时候，就要修改水果工厂（FruitFactory.java）中生产水果的方法（加上对应的创建水果实例代码）

---

3.factory_method

定义一个用于创建对象的接口，让子类决定把哪一个类进行实例化。

Fruit.java//水口接口

package com.wzucxd.designpattern.create.factory_method;
public interface Fruit{
	public void getType();
}

Apple.java//Apple implements Fruit

package com.wzucxd.designpattern.create.factory_method;
public class Apple implements Fruit{
	public void getType() {
		System.out.println("this is an apple");
	}
	
}

Banana.java//Banana implements Fruit

package com.wzucxd.designpattern.create.factory_method;
public class Banana implements Fruit{
	public void getType() {
		System.out.println("this is an banana");
	}
}

FruitFactory.java//水果工厂接口

package com.wzucxd.designpattern.create.factory_method;
public interface FruitFactory {
	public Fruit getFruit();
}

create apple and banana's FruitFactory

AppleFactory.java//AppleFactory implements FruitFactory,example:AppleFactory

package com.wzucxd.designpattern.create.factory_method;

public class AppleFactory implements FruitFactory{
	public Fruit getFruit() {
		return new Apple();
	}
}

Test.java

package com.wzucxd.designpattern.create.factory_method;
public class Test {
	public static void main(String[] args) {
		FruitFactory fruitFactory=new AppleFactory();
		fruitFactory.getFruit().getType();
	}
}

ps:factory_mathod存在的问题：假设如果有1000种"水果"，那么就需要1000个"水果工厂"