工厂模式（Java）

1：概述

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

        工厂模式分类：1）简单工厂模式（Simple Factory）；2）工厂方法模式（Factory Method）；3）抽象工厂模式（Abstract Factory）。这三种模式从上到下逐步抽象，并且更具一般性。

        将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

2：区别  

        工厂方法模式：一个抽象产品类，可以派生出多个具体产品类；一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。

        抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品类的实例。

        区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个；工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

3：代码实现

1：简单工厂模式Coding：

        一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象接口的实现类。

//抽象类接口：动物
interface Animal {
	
	public void say();
}
//实现接口：狗
class Dog implements Animal {

	@Override
	public void say() {
		System.out.println("汪汪汪");
	}

}
//实现接口：猫
class Cat implements Animal {

	@Override
	public void say() {

		System.out.println("喵喵喵");
	}

}
//动物工厂
class AnimalFactory {
	
	使用 getAnimalSay 方法获取Animal类型的对象
	public Animal getAnimalSay(String animalType){
		if(animalType==null){
			return null;
		}
		if(animalType.equalsIgnoreCase("Dog")){
			return new Dog();
		}else if(animalType.equalsIgnoreCase("Cat")){
			return new Cat();
		}
		return null;
	}
}
//工厂测试方法
public class SimpleFactoryTest {
	public static void main(String[] args) {
		AnimalFactory animalFactory = new AnimalFactory();
		
		//获取Dog对象并调用它的say()方法
		Animal animal1 = animalFactory.getAnimalSay("Dog");
		animal1.say();
		
		//获取Cat对象并调用它的say()方法
		Animal animal2 = animalFactory.getAnimalSay("Cat");
		animal2.say();
	}
}

2：工厂方法模式Coding：

        工厂方法模式是对简单工厂方法模式的改进，在简单工厂方法模式中，如果传入的字符串出错或者没有，则简单工厂模式是不能创建对象的。而工厂方法模式是提供了多个工厂方法并分别创建对象。即有四个角色：抽象工厂模式、具体工厂模式、抽象产品模式、具体产品模式；不再是由一个工厂类去实例化具体的动物，而是由抽象工厂的子类去实例化动物。

//抽象类接口：动物
interface Animal {
	public void say();
}
//实现抽象类接口：猫
class Cat implements Animal {

	@Override
	public void say() {

		System.out.println("喵喵喵");
	}

}
//实现抽象类接口：狗
class Dog implements Animal {

	@Override
	public void say() {
		System.out.println("汪汪汪");
	}

}
//抽象的动物工厂
abstract class AnimalFactory {
	public abstract Animal create();
}
//具体子工厂实例化：猫
class CatFactory extends AnimalFactory {

	@Override
	public Animal create() {
		return new Cat();
	}
}
//具体子工厂实例化：狗
class DogFactory extends AnimalFactory {

	@Override
	public Animal create() {
		return new Dog();
	}
	
}
//工厂测试方法
public class FactoryPatternTest {
	public static void main(String[] args) {
		AnimalFactory catFactory = new CatFactory();
		Animal animal1 = catFactory.create();
		animal1.say();
		
		AnimalFactory dogFactory = new DogFactory();
		Animal animal2 = dogFactory.create();
		animal2.say();
	}
}

3：抽象工厂模式

        抽象工厂和工厂方法模式很相似，工厂方法模式几乎已经很完美的对对象的创建进行了包装，使得测试类中仅仅处理抽象产品角色提供的接口，但是使得对象的数量成倍增长，当产品种类非常多时，会出现大量的与之对象的工厂对象，这是我们不希望看到的，即工厂方法模式有一个问题为类的创建依赖工厂类，即，如果想拓展程序增加一种产品，就必须要对工厂类进行修改，这违背了设计模式的闭包原则，所以从设计角度考虑，有一定的问题。解决的方法就是抽象工厂模式，工厂模式中工厂只能生产单一的产品，而抽象工厂模式的工厂可以生产多个产品。利用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能时，直接增加新的工厂类就可以了，不需要修改之前的代码。注：抽象工厂至少需要两个不同的产品种类。

        百科：每当抽象产品都有多于一个的具体子类的时候（Coding Demo：人有两名，动物有两只），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（动物有两个具体类型：Dog and Cat）。抽象工厂模式提供两个具体工厂角色（Factory1和Factory2），分别对应于这两个具体产品角色，每一个具体工厂角色只负责一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

//抽象接口人
interface Person {
	public void say();
}
//实现人的接口：Peter
class Peter implements Person{

	@Override
	public void say() {

		System.out.println("I am Peter.");
	}
	
}
//实现人的接口：Rose
class Rose implements Person{

	@Override
	public void say() {

		System.out.println("I am Rose.");
	}
	
}
//抽象接口动物
interface Animal {
	public void say();
}
//实现动物接口：猫
class Cat implements Animal {
	@Override
	public void say() {

		System.out.println("喵喵喵");
	}

}
//实现动物接口：狗
class Dog implements Animal{

	@Override
	public void say() {

		System.out.println("汪汪汪");
	}
}
//抽象工厂
abstract class AbstractFactory {
	public abstract Animal createAnimal();
	public abstract Person createPerson();
}
//实例化Rose和她猫
class Factory1 extends AbstractFactory {

	@Override
	public Animal createAnimal() {
		return new Cat();
	}

	@Override
	public Person createPerson() {
		return new Rose();
	}

}
//实例化Peter和他的狗
class Factory2 extends AbstractFactory{

	@Override
	public Animal createAnimal() {
		return new Dog();
	}

	@Override
	public Person createPerson() {
		return new Peter();
	}
}
//抽象工厂测试
public class AbstractFactoryTest {
	public static void main(String[] args) {
		//Rose和她的猫
		Factory1 factory1 = new Factory1();
		Person person1 = factory1.createPerson();
		Animal animal1 = factory1.createAnimal();
		person1.say();
		animal1.say();
		
		//Peter和他的狗
		Factory2 factory2 = new Factory2();
		Person person2 = factory2.createPerson();
		Animal animal2 = factory2.createAnimal();
		person2.say();
		animal2.say();
	}
}