工厂模式

工厂方法模式

目的是生产对象，分离我们生产不同特点的不同对象。

简单工厂 ： 用来生产同一等级结构中的任意产品。（不支持拓展增加产品）

定义一个产品接口

package com.whale;

public interface Product {
	void desc();
}

实现产品

package com.whale;

public class ProductA implements Product{

	@Override
	public void desc() {
		System.out.println("ProductA");
	}
	
}

package com.whale;

public class ProductB implements Product{

	@Override
	public void desc() {
		System.out.println("ProductB");
	}
	
}

简单工厂生产产品

package com.whale;

public class SimpleFactory {
	private static final int A=1;
	private static final int B=2;
	Product createP(int i){;
		if(i==A){
			return new ProductA();
		}else{
			return new ProductB();
		}		
	}
}

简单工厂违背了开闭原则，当有新的产品时，可以增加新的产品类时，但是我们会修改SimpleFactory的代码。

工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）   

工厂方法是将我们的工厂抽象出来。一个工厂生产一个一类产品。

产品类不变，工厂类变化

package com.whale;

public interface Factory {
	Product createP();
}

package com.whale;

public class AFactory implements Factory{

	@Override
	public Product createP() {
		return new ProductA();
	}

}

package com.whale;

public class BFactory implements Factory{

	@Override
	public Product createP() {
		return new ProductB();
	}

}

 

抽象工厂模式

抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）  

 

抽象工厂是在工厂上进行产品的分级。

package com.whale;

public abstract class Factory {
	public abstract ProductA createPA();
	public abstract ProductB createPB();
}

package com.whale;

public class Factory1 extends Factory{

	@Override
	public ProductA createPA() {
		return new ProductA1();
	}

	public ProductB createPB(){
		return new ProductB1();
	}

}

package com.whale;

public class Factory2 extends Factory{

	@Override
	public ProductA createPA(){
		return new ProductA2();
	}

	public ProductB createPB(){
		return new ProductB2();
	}
}

package com.whale;

public interface ProductA{
	public void desc();
}

package com.whale;

public class ProductA1 implements ProductA {
	@Override
	public void desc() {
		System.out.println("ProductA1");
	}
}

package com.whale;

public class ProductA2 implements ProductA {
	@Override
	public void desc() {
		System.out.println("ProductA2");
	}
}

package com.whale;

public interface ProductB{ 
	void desc();
}

package com.whale;

public class ProductB1 implements ProductB {
	@Override
	public void desc() {
		System.out.println("ProductB1");
	}
}

package com.whale;

public class ProductB2 implements ProductB {
	@Override
	public void desc() {
		System.out.println("ProductB2");
	}
}

总结：