java工厂模式

工厂模式

    工厂设计模式在实际开发中是最常用的模式之一也是非常经典的模式之一，今天通过写博的方式温故而知新，下面我们来共同学习下工厂模式。

 

一、目的

        工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

二、分类

1. 简单工厂模式（Simple Factory） 不利于产生系列产品；

 

2. 工厂方法模式（Factory Method）又称多形性工厂；

3.抽象工厂（Abstract Factory） 又称为工具箱，产品产品族，但不利于产生新的产品；

 

三、 具体介绍

 

1. 简单工厂模式（Simple Factory）

      简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。

在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

  它的组成：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

         

2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

         

3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

 

简单工厂模式结构：

 案例实现

 

/**
 * 
 * @author Col.Man
 * <P>抽象产品角色</P>
 */
public interface Product {
	/**
	 * 输出产品名称
	 */
	void printName();
}

/**
 * 
 * @author Col.Man
 * <P>具体产品角色</P>
 */
public class ProductA implements Product {

	public void printName() {
		System.out.println("I am product A!");
	}
}

/**
 * 
 * @author Col.Man
 * <P>具体产品角色</P>
 */
public class ProductB implements Product {

	public void printName() {
		System.out.println("I am product B!");
	}

}

/**
 * 
 * @author Col.Man
 *   <P>  工厂类角色  </P>
 */
public class ProductCreator {
	public Product factory(String pdtType) {
		Product product = null;
		if (pdtType.equals("A")) {
			product = new ProductA();
		} else if (pdtType.equals("B")) {
			product = new ProductB();
		}
		return product;
	}

	public static void main(String[] args) {
		ProductCreator c = new ProductCreator();
		c.factory("A").printName();
		c.factory("B").printName();
	}
}

 4)小结

 

     a)在编码不能预见创建哪一个类的实例时。

     b)一个类使用它的子类创建对象。

     c) 开发人员不希望创建哪个类的实例以及如何创建暴漏出来。

     d)从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。

       当添加一个产品时，只要符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户端使用了。

所以对产品部分来说，它是符合开闭原则的；

      但是工厂部分好像不太理想，因为每增加一个产品，都要在工厂类中（ProductCreator.java）增加相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。

可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。 

我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。

于是工厂方法模式作为救世主出现了。

2. 工厂方法（Factory Method）

     工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

　　

来看下它的组成：

       

1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

       

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

       

3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

       

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

       

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品（产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！

工厂方式模式结构：

 案例实现

 

/**
 * 
 * @author Col.Man
 * <P>抽象产品角色</P>
 */
public interface Product {
	void printName();
}

/**
 * 
 * @author Col.Man
 * <P>具体产品角色</P>
 */
public class ProductA implements Product {

	public void printName() {
		System.out.println("I am Product A!");
	}
}
/**
 * 
 * @author Col.Man
 * <P>具体产品角色</P>
 */
public class ProductB implements Product {

	public void printName() {
		System.out.println("I am Product B!");
	}
}
/**
 * 
 * @author Col.Man
 * <P>抽象工厂角色</P>
 */
public abstract class AbstractFactory {
	 abstract Product  create();
}
/**
 * 
 * @author Col.Man
 * <P>具体工厂角色</P>
 */
public class ProductAFactory extends AbstractFactory {

	@Override
	public Product create() {
		 
		return new ProductA();
	}
}
/**
 * 
 * @author Col.Man
 * <P>具体工厂角色</P>
 */
public class ProductBFactory extends AbstractFactory {

	@Override
	Product create() {
		return new ProductB();
	}
}
public class ClientTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		AbstractFactory factory = new ProductAFactory();
	    factory.create().printName();
	    factory = new ProductBFactory();
	    factory.create().printName();
	}

}

 5) 小结

 

      工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。

3. 简单工厂和抽象工厂比较

可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。 

 

 

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢？大可不必。也许在下面情况下你可以考虑使用工厂方法模式： 

     

1)当客户程序不需要知道要使用对象的创建过程。 

 

2)客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。 

   简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。

 

4. 抽象工厂模式（Abstract Factory）

    抽象工厂模式的用意为给客户端提供一个接口，可以创建多个产品族中的产品对象。

抽象工厂模式可以说是简单工厂模式的扩展，它们主要的区别在于需要创建对象的复杂程度上。 

在抽象工厂模式中，抽象产品可能是一个或多个，从而构成一个或多个产品族。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

抽象工厂模式的各个角色 

     

1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。 

 3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 

     

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 

抽象工厂模式结构图

 案例实现

public interface AbstractFactory {
	ICar createCar();
	ITelevision createTeleversion();
}
public class DefaultFactory implements AbstractFactory {

	public ICar createCar() {

		return new Car();
	}

	public ITelevision createTeleversion() {

		return new Television();
	}

}
public interface ICar {
	void printName();
}


public class Car implements ICar {

	public void printName() {
	 System.out.println("I am Car !");
	}
}


public interface ITelevision {
	void printName();
}
public class Television implements ITelevision {

	public void printName() {
		System.out.println("I am Television");

	}
}
public class ClientTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		AbstractFactory productFactory =new DefaultFactory();
		productFactory.createCar().printName();
		productFactory.createTeleversion().printName();

	}

}

 四、总结

1.简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。 

2.工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。 

3.抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。