java工厂模式

简介

工厂模式有三种：简单工厂模式，工厂方法模式，抽象工厂模式，这三种都属于工厂模式，但各有不同。

简单工厂模式

简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

模式中包含的角色及其职责

1.工厂（Creator）角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
2.抽象（Product）角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3.具体产品（Concrete Product）角色：简单工厂模式所创建的具体实例对象。
下面来看一个例子:

//先写工厂角色
public class FruitFactory {
	/*
	 * 获得Apple类的实例(第一种写法)
	 */
	public static  Fruit getApple() {
		return new Apple();
        }
	
	/*
	 * 获得Banana类实例(第一种写法)
	 */
	public static Fruit getBanana() {
		return new Banana();
	}
         //(第二种写法)传入类名的字符串做判断后产生对应的实体类对象
     public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
		if(type.equalsIgnoreCase("apple")) {
			return Apple.class.newInstance();
			
		} else if(type.equalsIgnoreCase("banana")) {
			return Banana.class.newInstance();
		} else {
			System.out.println("找不到相应的实例化类");
			return null;
		}
                       //第三种写法，传入类名，运用Java的反射机制生成实体类对象
			Class fruit = Class.forName(type);
			return (Fruit) fruit.newInstance();	
		
	}
}


//再写抽象角色（水果接口）
public interface Fruit {
	/*
	 * 采集
	 */
	public void get();
}
//再写两个具体产品角色实现抽象接口(苹果类)
public class Apple implements Fruit{
	/*
	 * 采集
	 */
	public void get(){
		System.out.println("采集苹果");
	}
}
//香蕉类
public class Banana implements Fruit{
	/*
	 * 采集
	 */
	public void get(){
		System.out.println("采集香蕉");
	}
}
//主类(客户端)
public class MainClass {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
		//实例化一个Apple（从工厂中获取）(第一种写法)
		Fruit apple = FruitFactory.getApple();
		Fruit banana = FruitFactory.getBanana();
	        apple.get();
		banana.get();	
                //(第二种写法)	
	        Fruit apple = FruitFactory.getFruit("Apple");
		Fruit banana = FruitFactory.getFruit("Banana");
		apple.get();
		banana.get();		
	}
}

所对应的类图：

运行结果：

采集苹果
采集香蕉

简单工厂模式的优缺点

1.在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。
2.不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

工厂方法模式

工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

模式中包含的角色及其职责

1.抽象工厂（Creator）角色：工厂方法模式的核心，任何工厂类都必须实现这个接口。
2.具体工厂（ Concrete Creator）角色：具体工厂类是抽象工厂的一个实现，负责实例化产品对象。
3.抽象（Product）角色：工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
4.具体产品（Concrete Product）角色：工厂方法模式所创建的具体实例对象。
对于简单工厂模式来说，工厂方法模式把那个工厂又抽象化了一层，具体的实体类对象的创建推迟放到具体的工厂中去
看例子：

//先写那个抽象工厂角色   工厂方法模式的核心，任何工厂类都必须实现这个接口。
public interface FruitFactory {
	public Fruit getFruit();
}

//再写具体工厂角色（要实现抽象工厂这个接口，苹果工厂）  具体工厂类是抽象工厂的一个实现，负责实例化产品对象
public class AppleFactory implements FruitFactory {
	public Fruit getFruit() {
		return new Apple();
	}

}

//香蕉工厂  具体工厂类是抽象工厂的一个实现，负责实例化产品对象

public class Banana implements Fruit{
	/*
	 * 采集
	 */
	public void get(){
		System.out.println("采集香蕉");
	}
}
//栗子工厂   具体工厂类是抽象工厂的一个实现，负责实例化产品对象
public class PearFactory implements FruitFactory {

	public Fruit getFruit() {
		return new Pear();
	}
}

//再写抽象角色(水果接口)  工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口

public interface Fruit {
	
	public void get();
}

//再写具体产品角色   （工厂方法模式所创建的具体实例对象）

//苹果类
public class Apple implements Fruit{
	/*
	 * 采集
	 */
	public void get(){
		System.out.println("采集苹果");
	}
}

//香蕉类

public class Banana implements Fruit{
	/*
	 * 采集
	 */
	public void get(){
		System.out.println("采集香蕉");
	}
}

//栗子类

public class Pear implements Fruit {

	public void get() {
		System.out.println("采集梨子");
	}

}

//主程序(客户端)

public class MainClass {
	public static void main(String[] args) {
		//获得AppleFactory
		FruitFactory ff = new AppleFactory();
		//通过AppleFactory来获得Apple实例对象
		Fruit apple = ff.getFruit();
		apple.get();
		
		//获得BananaFactory
		FruitFactory ff2 = new BananaFactory();
		Fruit banana = ff2.getFruit();
		banana.get();
		
		//获得PearFactory
		FruitFactory ff3 = new PearFactory();
		Fruit pear = ff3.getFruit();
		pear.get();
	}
}

所对应的类图

运行结果：

采集苹果
采集香蕉
采集梨子

工厂方法模式和简单工厂模式比较

1.工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
2.工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。
3.工厂方法模式退化后可以演变成简单工厂模式。

抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的，抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

模式中包含的角色及其职责

1.抽象工厂（Creator）角色:抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。
2.具体工厂（ Concrete Creator）角色:具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。
3.抽象（Product）角色:抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
4.具体产品（Concrete Product）角色:抽象模式所创建的具体实例对象
举个栗子

//先写抽象工厂角色
public interface FruitFactory {
	//实例化Apple
	public Fruit getApple();
	//实例化Banana
	public Fruit getBanana();
}

//再写具体工厂角色(和工厂方法模式不同的是：这次的具体工厂角色分不同层级)即不仅仅只是苹果香蕉的区别，还有南、北、温室之分
public class NorthFruitFactory implements FruitFactory {

	public Fruit getApple() {
		return new NorthApple();
	}

	public Fruit getBanana() {
		return new NorthBanana();
	}
}

public class SouthFruitFactory implements FruitFactory {

	public Fruit getApple() {
		return new SouthApple();
	}

	public Fruit getBanana() {
		return new SouthBanana();
	}

}


public class WenshiFruitFactory implements FruitFactory {

	public Fruit getApple() {
		return new WenshiApple();
	}

	public Fruit getBanana() {
		return new WenshiBanana();
	}

}
//再写抽象角色
public interface Fruit {
	/*
	 * 采集
	 */
	public void get();
}

//具体角色


public class NorthApple extends Apple {

	public void get() {
		System.out.println("采集北方苹果");
	}

}


public class NorthBanana extends Banana {

	public void get() {
		System.out.println("采集北方香蕉");
	}

}


public class SouthApple extends Apple {

	public void get() {
		System.out.println("采集南方苹果");
	}

}


public class SouthBanana extends Banana {

	public void get() {
		System.out.println("采集南方香蕉");
	}

}


public class WenshiApple extends Apple {

	public void get() {
		System.out.println("采集温室苹果");
	}

}


public class WenshiBanana extends Banana {

	public void get() {
		System.out.println("采集温室香蕉");
	}

}

//主类

public class MainClass {
	public static void main(String[] args) {
		FruitFactory ff = new NorthFruitFactory();
		Fruit apple = ff.getApple();
		apple.get();
		
		Fruit banana = ff.getBanana();
		banana.get();
		
		FruitFactory ff2= new SouthFruitFactory();
		Fruit apple2 = ff2.getApple();
		apple2.get();
		
		Fruit banana2 = ff2.getBanana();
		banana2.get();
		
		FruitFactory ff3 = new WenshiFruitFactory();
		Fruit apple3 = ff3.getApple();
		apple3.get();
		
		Fruit banana3 = ff3.getBanana();
		banana3.get();
	}
}

所对应的类图

运行结果

采集北方苹果
采集北方香蕉
采集南方苹果
采集南方香蕉
采集温室苹果
采集温室香蕉

总结

简单工厂：一个工厂类(FruitFactory)，一个产品抽象类(Fruit.)。
工厂方法：多个工厂类(FruitFactory是个顶层工厂，他是一个接口；AppleFactory、BananaFactory、PearFactory这三个实现FruitFactory)，一个产品抽象类(Fruit)。
抽象工厂：多个工厂类(FruitFactory、NorthFruitFactory、SouthFruitFactory、WenshiFruitFactory)，多个产品抽象类(Fruit、Apple、Banana)。
工厂方法模式和抽象工厂模式的区别