创建型模式(Creational Pattern) 抽象工厂abstractfactory 建造者模式 buider 工厂方法模式 FactoryMethod 原型 prototype

package designpattern.creational.abstractfactory;//抽象工厂interface IProductA{}interface IProductB{}class Product1A implements IProductA{}class Product1B implements IProductB{}class Product2A implements IProductA{}class Product2B implements IProductB{}public abstract
 class AbstractFactory { public static AbstractFactory chooseFactory(int factoryName){
switch (factoryName) { case 1:
return new Factory1(); case 2:
return new Factory2(); default:
throw new NullPointerException(); }
} public abstract IProductA getProductA();
public abstract IProductB getProductB();}class Factory1 extends AbstractFactory{
@Override public IProductA getProductA() {
return new Product1A(); }
@Override public IProductB getProductB() {
return new Product1B(); }
}class Factory2 extends AbstractFactory{ 
@Override public IProductA getProductA() {
return new Product2A(); }
@Override public IProductB getProductB() {
return new Product2B(); }
}class Test{ public static void main(String[] args) {
System.out.println(AbstractFactory.chooseFactory(1).getProductA());
System.out.println(AbstractFactory.chooseFactory(1).getProductB());
System.out.println(AbstractFactory.chooseFactory(2).getProductA());
System.out.println(AbstractFactory.chooseFactory(2).getProductB());
}}

package designpattern.creational.builder;
//建造者模式

class Director{
	private Builder builder = null;
	public void setBuilder(Builder b){
		this.builder=b;
	}
	public void show(){
		this.builder.showA();
		this.builder.showB();
	}
}
public abstract class Builder {
	public abstract void showA();
	public abstract void showB();
}
class BuilderA extends Builder{
	@Override
	public void showA() {
		System.out.println("BuilderA-ShowA");
	}
	@Override
	public void showB() {
		System.out.println("BuilderA-ShowB");
	}	
}
class BuilderB extends Builder{
	@Override
	public void showA() {
		System.out.println("BuilderB-ShowA");
	}
	@Override
	public void showB() {
		System.out.println("BuilderB-ShowB");
	}	
}
class Test{
	public static void main(String[] args) {
		Director director = new Director();
		director.setBuilder(new BuilderA());
		director.show();
		director.setBuilder(new BuilderB());
		director.show();
	}
}
package designpattern.creational.factorymethod;
//工厂方法

class Product{}
class ProductA extends Product{}
class ProductB extends Product{}


public abstract class FactoryMethod {
	public static FactoryMethod chooseFactory(char factoryName){
		switch (factoryName) {
		case 'a':
			return new FactoryA();
		case 'b':
			return new FactoryB();
		default:
			throw new NullPointerException();
		}
	}
	public abstract Product getProduct();
}
class FactoryA extends FactoryMethod{
	@Override
	public Product getProduct() {
		return new ProductA();
	}	
}
class FactoryB extends FactoryMethod{
	@Override
	public Product getProduct() {
		return new ProductB();
	}	
}
class Test{
	public static void main(String[] args) {
		System.out.println(FactoryMethod.chooseFactory('a').getProduct());
		System.out.println(FactoryMethod.chooseFactory('b').getProduct());
	}
}
package designpattern.creational.prototype;
//原型

public class Prototype implements Cloneable {
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}
class Test{
	public static void main(String[] args) {
		Prototype p1 = new Prototype();
		System.out.println(p1);
		try {
			Prototype p2 = (Prototype) p1.clone();
			System.out.println(p2);
		} catch (Exception e) {
			System.out.println(e);
		}
	}
}