关于工厂模式的学习

简单工厂模式

对于工厂模式，原先发现自己其实了解的很抽象，或者说很肤浅而已。有种一叶蔽目，不见泰山的感觉的吧。其实对于这个模式有些东西根本就没有一个全面的概念吧。

最初的一种印象就是如下所示：

package demo05;

public class FactoryDemo01 {
	public static void main(String args []) throws Exception{
		Fruit apple = FruitFactory.createFruit("apple");
		Fruit orange = FruitFactory.createFruit("orange");
		Fruit banana = FruitFactory.createFruit("banana");
		if(apple != null){
			apple.getName();
		}
		if(orange !=null){
			orange.getName();
		}
		if(banana != null){
			banana.getName();
		}
	}
}


interface Fruit{
	public void getName();
}

class Apple implements Fruit{
	public void getName(){
		System.out.println("apple...");
	}
}

class Orange implements Fruit{
	public void getName(){
		System.out.println("orange...");
	}
}

class FruitFactory{
	public static Fruit createFruit(String type) throws  Exception{
		if("apple".equalsIgnoreCase(type)){
			return Apple.class.newInstance();
		}else if("orange".equalsIgnoreCase(type)){
			return Orange.class.newInstance();
		}else{
			System.out.println("没有找到相应的产品");
			return null;
		}
	}
}

程序运行结果为：

这还是在一次面试中，我在讲这种工厂模式的时候，面试官让我说什么叫抽象工厂模式，我才傻了眼，才知道其实对于工厂模式中其实还是又有好几种。回来后慢慢查资料，才知道其实上面这种工厂模式又被称为简单工厂模式（Simple Factory Pattern）,又叫静态工厂方法模式（Static FactoryMethod Pattern），主要是通过专门定义一个类来负责创建其他类的实例。

 

工厂模式方法

何为工厂模式？还是从以下代码着手：

package demo06;

public class FactoryDemo02 {
	public static void main(String args []){
		//FruitFactory factory = new AppleFactory();
		FruitFactory factory = new OrangeFactory();
		Fruit fruit= factory.createFruit();
		fruit.getName();
	}
}

 interface Fruit{
	public void getName();
}
 
 class Apple implements Fruit{
	 public void getName(){
		 System.out.println("apple...");
	 }
 }
 
 class Orange implements Fruit{
	 public void getName(){
		 System.out.println("orange...");
	 }
	 private Orange(){
		 
	 }
	 private static  Orange orange = new Orange();
	 public static Orange getInstance(){
		 return orange;
	 }
 }
 
 interface FruitFactory{
	 public Fruit createFruit();
 }
 
 class AppleFactory implements FruitFactory{
	public Fruit createFruit() {
		return new Apple();
	}
 }
 
 class OrangeFactory implements FruitFactory{
	public Fruit createFruit() {
		return Orange.getInstance();
	}
 }

对于这里的代码，我们明显的可以看到。对于每一个具体的类都有着一个具体的工厂类，而这个工厂类就是负责返回此具体类的一个实例。当然如何返回一个具体类的实例，可以在具体类中加上一些控制实例化的手段，比如以上代码段，可以进行单例模式的一个控制。其实归结到底，就是一个接口类，引申出实体类。一个工厂接口，引申出具体类实现的工厂。主要类的实例化一定是通过此类所对应的工厂类来实现的。而此工厂类就是通过接口工厂类实现的。（父类的引用指向子类对象）。

 

抽象工厂

什么叫抽象工厂？它和工厂模式又有什么区别？请看下面的代码：

package demo07;

/*
 * 比如有某个人想买一套电子设备
 * 电脑：imac，y470
 * 手机：iphone,MI 1S
 */
public class FactoryDemo {
	public static void main(String args []){
		AbstractFactory factory = new DefaultFactory();
		Computer computer = factory.createComputer();
		CellPhone cellPhone = factory.createCellPhone();
		computer.getName();
		cellPhone.getName();
	}
}

interface Computer{
	public void getName();
}

class Imac implements Computer{
	public void getName(){
		System.out.println("It's imac");
	}
}

class Y470 implements Computer{
	public void getName(){
		System.out.println("It's y470");
	}
}

interface CellPhone{
	public void getName();
}

class Iphone implements CellPhone{
	public void getName(){
		System.out.println("It's iphone");
	}
}

class MI1S implements CellPhone{
	public void getName(){
		System.out.println("It's MI1S");
	}
}

interface AbstractFactory{
	public Computer createComputer();
	public CellPhone createCellPhone();
}

class DefaultFactory implements AbstractFactory{
	public Computer createComputer() {
		return new Y470();
	}
	public CellPhone createCellPhone() {
		return new MI1S();
	}
}

class AnotherFactory implements AbstractFactory{
	public Computer createComputer() {
		return new Imac();
	}
	public CellPhone createCellPhone() {
		return new Iphone();
	}	
}

程序运行结果如下：

抽象工厂模式是工厂方法模式的升级版本，它用来创建一组相关或者相互依赖的对象。它与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。

在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产 品不再构成产品族之后，它就演变成了工厂方法模式。所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。