工厂模式.md

工厂模式

工厂模式一般分三类，简单工厂模式，工厂方法模式，抽象工厂模式。下面分别来看一下

简单工厂模式

工厂模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

所以说白了，工厂就是用来创建各种对象的，简单工厂就是你跟工厂说你想要什么东西，工厂就把你要的东西给你。这里的东西其实就是对象。

工厂里面的产品特别多，我们要给这些产品抽象出来，定义一个统一的接口，具体的产品去实现这个接口。产品有了，然后就是工厂的逻辑实现了，实现很简单，你告诉我要什么（传一个参数），我就生产相应的东西。

简单工厂确实很简单，说来就两句话，下面看看uml类图对照一下。

下面放出代码，其实看看类图就差不多了，代码大概看一下就行了。

IFruit.java

public interface IFruit {
		void plant();
}

Apple.java

public class Apple implements IFruit {
	@Override
	public void plant() {
		// TODO Auto-generated method stub
		System.out.println( "今年种苹果");
	}
}

Banana.java

public class Banana implements IFruit {
	@Override
	public void plant() {
		// TODO Auto-generated method stub
		System.out.println("今年种香蕉"); 
	}
}

SimpleFcatory.java

public class SimpleFcatory {
	public static IFruit decidePlant(String fruit){
		IFruit ifruit=null;
		switch (fruit) {
		case "apple":
			ifruit=new Apple();
			break;
		case "banana":
			ifruit=new Banana();
			break;
		}
		return ifruit;
	}
}

这边注意工厂的方法应该为静态方法

客户端调用

	IFruit apple=SimpleFcatory.decidePlant("apple");
	apple.plant();
	IFruit banana = SimpleFcatory.decidePlant("banana");
	banana.plant();

结果

今年种苹果
今年种香蕉

工厂方法模式

工厂方法将前面的工厂类又抽象了一层，先定义一个抽象工厂，然后定义一些具体工厂类去继承抽象工厂，这些工厂类负责实例化产品。

看一下uml类图

Factory

public abstract class Factory {
	public abstract IFruit createFruie();
}

AppleFactoty

public class AppleFactory extends Factory {
	@Override
	public IFruit createFruie() {
		// TODO Auto-generated method stub
		return new Apple();
	}
}

BananaFactoty

public class BananaFactory extends Factory{
	@Override
	public IFruit createFruie() {
		// TODO Auto-generated method stub
		return new Banana();
	}
}

客户端调用

Factory appleFactory=new AppleFactory();
IFruit apple = appleFactory.createFruie();
apple.plant();

简单工厂和工厂方法看起来差不多，工厂方法其实是把判断逻辑放到了客户端，由客户端来决定要用哪个具体的工厂来创建对象，而简单工厂是接受客户端的参数，由工厂类判断要返回哪个对象。

我们来看看它们的主要差别，假设我们现在要再加一个西瓜，对于简单方法就是在工厂类里面在加一个判断，判断传入的参数是西瓜的话，就返还西瓜的对象。这样看起来挺简单的，只需要改一个类，但是这违背了对修改封闭，对扩展开放的原则。而用工厂方法则是再增加一个西瓜工厂类去继承抽象工厂就可以了。

静态工厂模式

静态工厂模式其实是前面工厂方法的升级版，前面我们一直只用到了水果类，那工厂里面有很多产品，如果我们要还要一个动物类怎么办？那我们要对工厂进行改造，首先最顶层一个抽象工厂，肯定要定义生产方法，所以有两个抽象方法，分别用来生产两种产品，然后有两个具体的工厂来继承这个类，同时也会继承并实现两个抽象方法。

水果工厂生产水果的方法通过传入的参数来判断要生产哪种水果，而生产动物的方法就让它返回空。动物工厂同理。uml类图如下

再看看代码，还是那句话，看类图就差不多理清关系了，代码只是对照一下，别扎进代码把自己搞晕了。先放产品的代码，即动物和水果类。当然产品代码你完全可以跳过，因为类图就已经很清楚了。

IFruit.java

public interface IFruit {
		void plant();
}

Apple.java

public class Apple implements IFruit  {
	@Override
	public void plant() {
		System.out.println( "今年种苹果");
	}
}

Banana.java

public class Banana implements IFruit {
	@Override
	public void plant() {
		System.out.println("今年种香蕉"); 
	}
}

IAnimal.java

public interface IAnimal {
	void keep();
}

Cat.java

public class Cat implements IAnimal {
	@Override
	public void keep() {
		System.out.println("接下来养猫");
	}
}

Dog.java

public class Dog implements IAnimal {
	@Override
	public void keep() {
		System.out.println("接下来养狗");
	}
}

AbstractFactory.java

public abstract class AbstractFactory {
	public abstract IFruit getFruit(String fruit);
	public abstract IAnimal getAnimal(String animal);
}

FruitFactory.java

public class FruitFactory extends AbstractFactory {
	@Override
	public IFruit getFruit(String fruit) {
		switch (fruit) {
		case "apple":
			return new Apple();
		case "banana":
			return new Banana();
		}
		return null;
	}
    
	@Override
	public IAnimal getAnimal(String animal) {
		return null;
	}

}

AnimalFactory.java

public class AnimalFactory extends AbstractFactory {
	@Override
	public IFruit getFruit(String fruit) {
		return null;
	}

	@Override
	public IAnimal getAnimal(String animal) {
		switch (animal) {
		case "dog":
			return new Dog();
		case "cat":
			return new Cat();
		}
		return null;
	}
}

FactoryProducer.java

public class FactoryProducer {
	public static AbstractFactory getFactory(String factoryType) {
		switch (factoryType) {
		case "fruit":
			return new FruitFactory();
		case "animal":
			return new AnimalFactory();
		}
		return null;
	}
}

这个类是用来判断是要生产哪类产品，你会发现和前面的简单工厂模式有点相似，FruitFactory.java和AnimalFactory.java也是差不多，都是通过传入的参数判断返回什么类型。

客户端调用

	AbstractFactory animalfactory = FactoryProducer.getFactory("animal");
	IAnimal cat = animalfactory.getAnimal("cat");
	cat.keep();

我们举的这个例子有点奇怪，在AnimalFactory.java和FruitFactory.java中其中总有一个方法返回null，什么都没干。其实还有另一种产品结构，类似下面这种

我用原来的图改了一下，不要管字，看一下结构。每一个工厂的方法都会生成一个对象，不像前面一个方法可以生成两个对象，而另一个方法什么都不干。

最后

其实这三种都是工厂模式，不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。他们的最终目的都是为了解耦，我们只要确保实现了解耦这个核心要求就行了。