工厂设计模式:工厂模式可以动态的决定实例化哪一个类，减少类与类之间的耦合度，尽量让类达到：高内聚，低耦合。
工厂设计模式有2种:
1.静态工厂
2.实例工厂
一.简单工厂
简单工厂又被称为静态工厂，主要有一个静态方法，用它来接收参数，并根据参数来决定返回实现同一个接口的不同类型的实例。需要什么类型，就传递什么类型的参数！
简单工厂实现代码:
1.建立一个抽象类（Animal抽象类）：
package animalFactory1;
//定义一个动物抽象类
/**
*类描述:抽象动物类
*@author: 张宇
*@date: 日期: 2018年6月29日 时间: 上午11:01:51
*@version 1.0
*/
public abstract class Animal {
//有一个吃的抽象方法
public abstract void eat();
}
2.实现抽象类方法的动物实例（Cat实例）:
package animalFactory1;
/**
* 类描述:猫类继承动物类
* @author: 张宇
* @date: 日期: 2018年6月29日 时间: 上午11:00:47
* @version 1.0
*/
public class Cat extends Animal {
// 猫重写了动物的抽象方法
@Override
public void eat() {
System.out.println("猫吃鱼！");
}
}
3.实现抽象类方法的动物实例（Dog实例）:
package animalFactory1;
/**
*类描述:狗类实现动物类
*@author: 张宇
*@date: 日期: 2018年6月29日 时间: 上午11:02:48
*@version 1.0
*/
public class Dog extends Animal{
//狗也重写了动物的抽象方法
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("狗吃肉！");
}
}
4.动物工厂类的实例化过程（AnimalFactory）：
package animalFactory1;
/**
*类描述：
*@author: 张宇
*@date: 日期: 2018年6月29日 时间: 上午10:53:32
*@version 1.0
*/
public class AnimalFactory {
private AnimalFactory() {}
//静态方法判断哪个动物是哪个类，如果是狗就创建狗类型，如果是猫就创建猫类型，如果都不是就返回为空
/*
* @param type 动物的类型
* @param return 返回创建对象的类型
*/
public static Animal CreateAnimal(String type){
if("dog".equals(type)){//判断是否等于这个类型
return new Dog();
}else if("cat".equals(type)){//判断是否等于这个类型
return new Cat();
}else{
return null;
}
}
}
5.简单静态工厂的测试类(AnimalDemo):
package animalFactory1;
/**
* 类描述:工厂模式测试类
* @author: 张宇
* @date: 日期: 2018年6月29日 时间: 上午11:00:12
* @version 1.0
*/
public class AnimalDemo {
public static void main(String[] args) {
// 具体类调用
// Dog d=new Dog();
// d.eat();
// Cat c=new Cat();
// c.eat();
// System.out.println("-------------------------------");
// 狗的静态工厂方法
Animal animal = AnimalFactory.CreateAnimal("dog");
animal.eat();
// 猫的静态工厂方法
animal = AnimalFactory.CreateAnimal("cat");
animal.eat();
// 猪的静态工厂方法
animal = AnimalFactory.CreateAnimal("pig");
if (animal != null) {
animal.eat();
} else {
System.out.println("不好意思，暂时没有这种动物！");
}
}
}
测试结果:
狗吃肉！
猫吃鱼！
不好意思，暂时没有这种动物！由上面的代码看出，简单工厂的核心就是一个核心AnimalFactory类，我们想要什么样的产品之间传递参数就好了！
二，实例工厂：
实例工厂设计模式先创建类对象，然后通过对象来调用创建实例对象的方法，而不是在自己的类中创建对象。
实例工厂设计模式代码实现例子：
1.创建一个接口（Animal接口）：
package InstanceAnimalFactory;
public abstract class Animal {
public abstract void eat();
}
2.创建动物类的实现类（Cat类）
package InstanceAnimalFactory;
public class Cat extends Animal {
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("猫要吃鱼!");
}
}
3.创建动物类的实现类(Dog类)：
package InstanceAnimalFactory;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉！");
}
}
4.创建动物类的工厂（Factory类）：
package InstanceAnimalFactory;
public interface Factory {
public abstract Animal createAnimal();
}5.创建动物类的工厂（Cat类的工厂）：
package InstanceAnimalFactory;
public class CatFactory implements Factory{
public Animal createAnimal() {
// TODO Auto-generated method stub
return new Cat();
}
}
6.创建动物类的工厂(Dog类的工厂)：
package InstanceAnimalFactory;
public class DogFactory implements Factory {
public Animal createAnimal() {
// TODO Auto-generated method stub
return new Dog();
}
}
7.实例工厂的测试类:
package InstanceAnimalFactory;
import org.junit.Test;
/**
*类描述:测试工厂类设计模式
*@author: 张宇
*@date: 日期: 2018年7月2日 时间: 下午8:34:32
*@version 1.0
*/
public class AnimalDemo {
@Test
public void fun(){
DogFactory f1=new DogFactory();//获取工厂的调用对象
Animal a=f1.createAnimal();// 利用该对象调用方法创造该动物类型的对象
a.eat();//然后用该动物对象调用方法
System.out.println("-------------");
CatFactory f2=new CatFactory();
Animal b=f2.createAnimal();
b.eat();
System.out.println("-------------");
}
}
运行结果:
狗吃肉！
-------------
猫要吃鱼!
-------------实例工厂就是谁创建，就用谁的的工厂创建对象，降低类与类直接的耦合度，增强代码的实用性。
关于工厂模式的适用场景:
情况一：一个对象拥有很多子类，那么创建该对象的子类使用工厂模式是最合适的，不但可以面向接口的编程，为维护以及开发带来方便。
情况二：如果创建某个对象时需要进行许多额外的操作，如查询数据库然后将查询到的值赋予要创建的对象(单例初始化时使用比较多),或是需要许多额外的赋值等等，都需要工厂类设计模式。
Spring 框架中也用到了工厂模式--BeanFactory创建对象的实例，另外Spring框架中除了用到了工厂模式，还用到了前端控制器：spring用前端控制器DispatcherServlet对请求进行分发 ；单例模式：spring中bean默认是单例模式 。