设计模式之工厂模式

工厂模式大致可以分为三类,1)简单工厂模式,2)工厂方法模式,3)抽象工厂模式,下面逐一进行介绍:

简单工厂:

产品:

public abstract class Product {
	public Product(){}
}
public class ItemA extends Product{
	public ItemA(){
		System.out.println("制造ItemA");
	}
}
public class ItemB extends Product{
	public ItemB(){
		System.out.println("制造ItemB");
	}
}

工厂:

public class Factory {
	public Product create(String s){
		switch (s){
		
		case "A":
			return new ItemA();
		case "B":
			return new ItemB();
		default :
			break;
		}
		return null;
	}
}

消费:

public class Customer {
	public static void main(String[] args) {
		Factory factory = new Factory();
		Product A = factory.create("A");
		Product B = factory.create("B");
	}
}

    消费的时候根据传入的条件不同,创建出不同的Product;缺点很明显,工厂和商品耦合严重,添加新的商品时需要对方法进行修改;

工厂方法模式:

    产品类不做改变,将工厂抽象成接口,并分别创建工厂的实现;

public interface Factory {
	Product create();
}
public class FactoryItemA implements Factory{

	@Override
	public Product create() {
		return new ItemA();
	}
	
}

public class FactoryItemB implements Factory{

	@Override
	public Product create() {
		return new ItemB();
	}
	
}

同时,工厂的创建也要稍作改变:

public class Customer {
	public static void main(String[] args) {
		FactoryItemA factoryitemA = new FactoryItemA();
		Product itemA = factoryitemA.create();
		FactoryItemB factoryitemB = new FactoryItemB();
		Product itemB = factoryitemB.create();
	}
}

    不同的产品要由不同的工厂生产,将接口Interface Factory比作葡萄酒厂,则ItemA为干白葡萄酒,ItemB为干红葡萄酒,生产葡萄酒的工序差不多是一样的,但是工序中的实现方法不尽相同,所以FactoryItemA为干白葡萄酒厂,FactoryItemB为干红葡萄酒厂;工厂方法模式的好处是显而易见的,假设现在有一个新的产品,冰酒,只需要新创建一个工厂类即可,并不需要对现有的工厂进行改造,缺点是,如果产品种类很多的话,需要创建大量的工厂对象,这是很消耗资源的;

抽象工厂模式:

    我们根据葡萄酒的例子进行分析,葡萄酒分为干红和干白,并且他们的包装即酒瓶子也是不一样的,现在工厂除了要生产就之外还要生产酒瓶子,使用抽象工厂模式进行建模:

首先是产品:

public interface Wine {

}
public class DryRedWine implements Wine{
	public DryRedWine(){
		System.out.println("干红葡萄酒");
	}
}
public class DryWhite implements Wine{
	public DryWhite(){
		System.out.println("干白葡萄酒");
	}
}
public interface Bottle {

}
public class BottleForRed implements Bottle{
	public BottleForRed(){
		System.out.println("干红葡萄酒的瓶子");
	}
}
public class BottleForWhite implements Bottle{
	public BottleForWhite(){
		System.out.println("干白葡萄酒的瓶子");
	}
}

然后是工厂:

public interface Factory {
	Wine createWine();
	Bottle createBottle();
}
public class FactoryForRed implements Factory{

	@Override
	public Wine createWine() {
		return new DryRedWine();
	}

	@Override
	public Bottle createBottle() {
		return new BottleForRed();
	}
	
}
public class FactoryForWhite implements Factory{

	@Override
	public Wine createWine() {
		return new DryWhite();
	}

	@Override
	public Bottle createBottle() {
		return new BottleForWhite();
	}
	
}

最后是消费类:   

public class Customer {
	public static void main(String[] args) {
		Factory facotryred = new FactoryForRed();
		Wine dryred = facotryred.createWine();
		Bottle bottleforred = facotryred.createBottle();
		Factory factorywhite = new FactoryForWhite();
		Wine drywhite = factorywhite.createWine();
		Bottle bottleforwhite = factorywhite.createBottle();
	}
}

         可以看到抽象工厂模式中,一个工厂可以生产多个产品,所以在使用过程中,工厂对象的创建数量会少一点儿,但是此时工厂类会变得比较重,比较占内存,实际使用过程中要具体问题要具体分析;