创建型设计模式之工厂模式

今天主要记录下工厂模式的学习心得，以及个人的理解。工厂模式下大致分为了一下几类：

1. 简单工厂模式（Simple Factory Pattern实际上不算做23中设计模式）
2. 静态工厂模式（Static Factory Pattern，就是单例模式的特殊形态）
3. 工厂方法模式（Factory Method Pattern）
4. 抽象工厂模式（Abstract Factory Pattern）

这里我主要说一下对简单工厂模式、工厂方法模式、抽象工厂模式的理解：

简单工厂模式（Simple Factory Pattern）

**简单工厂，就是提供一个可以创建对象实例的接口，而不需要去关心具体的细节。**简单来说，就是我的一个工厂里面，提供一个方法，这个方法可以根据名称、全限定名称创建同一类产品（可以理解为都有同一个父类或实现同一个接口）。下面来看看代码：

public interface IPerson {
    public abstract void doSomething();
}

public class Teacher implements IPerson {
    @Override
    public void doSomething() {
        System.out.println("===========我是老師，要去上課==========");
    }
}

public class Student implements IPerson {
    @Override
    public void doSomething() {
        System.out.println("=========我是學生，我要去學習==========");
    }
}

//简单工厂模式
public class SimpleFactoryPattern {
    public static IPerson create(String name){
        IPerson person = null;
        if("teacher".equals(name)){
            person = new Teacher();
        }else if("student".equals(name)){
            person = new Student();
        }
        return person;
    }
}

看以上代码是，通过判断名称来决定创建，如果要扩展就要改动代码，不够灵活，那我们在换一种方式来实现：

public class SimpleFactoryPattern_01 {
    public static IPerson create(String className){
        IPerson person = null;
        try {
            Object o = Class.forName(className).newInstance();
            if(null!=o){
                person = (IPerson)o;
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return person;
    }
}

上面这种方式，是传入类的全限定名称，通过反射来进行实例化，这种方式扩展性很强，即使IPerson有其他的实现类，也不用更改代码
这种方式类似LoggerFactory.getLogger()方法。

所以，简单工厂就是创建统一类产品，具体的细节由创建类封装。

工厂方法模式（Factory Method Pattern）

工厂方法模式，就是提供一类父产品的创建接口，由具体的子类来决定创建哪一类子产品。
意思就是提供一个接口类，并提供一个抽象方法，该方法返回的是一类产品的父类；
当有一个子类去实现接口类时，必须实现该方法，在当前这个子类中，可以自己决定创建哪个子产品，以及相关的逻辑，将每个子产品类的实现逻辑独立出来，这样每当有新的子产品类时，只需要新添加一个接口实现类，完成创建方法中新产品类的创建即可。
看代码：

public interface IFactoryMethod {
    IPerson create();
}

public class StudentFactoryMethod implements IFactoryMethod{

    @Override
    public IPerson create() {
        return new Student();
    }
}

public class TeacherFactoryMethod implements IFactoryMethod{

    @Override
    public IPerson create() {
        return new Teacher();
    }
}

public class Main {
    public static void main(String[] args) {
//        IFactoryMethod factoryMethod = new TeacherFactoryMethod();
        IFactoryMethod factoryMethod = new StudentFactoryMethod();
        IPerson iPerson = factoryMethod.create();
        iPerson.doSomething();
    }
}

这样就完成了一个工厂方法模式，从工厂模式的定义，以及上面的代码可以看出，当要创建一个新的子产品类，那就要必须要新创建一个类来实现工厂方法接口，如果子类产品不断增多，那么对应的工厂类也越来越多，不利于管理。

所以，总结来讲，工厂方法模式，是对一类产品的创建，且易于扩展，拥有独立的逻辑，但是会导致类的膨胀。

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式，从名称就知道这是一个抽象类，在这个类里面提供了创建一系列产品类（一类产品族）的抽象方法。
首先了解下产品族，比如联想、苹果、微软，都属于产品族，在他们旗下有各自的产品，如：联想的笔记本、键盘、鼠标，苹果的笔记本、键盘、鼠标，微软的笔记本、键盘、鼠标，属于产品族下的一系列产品。那这个抽象工厂模式到底是个什么样的呢，看下面的代码：

//电脑类
public class Computer {

}

//键盘类
public class Keyboard {
    
}

//鼠标类
public class Mouse {
    
}

//抽象工厂类
public abstract class AbstractFactory {

    //创建电脑类
    public abstract Computer createComputer();
    //创建键盘类
    public abstract Keyboard createKeyboard();
    //创建鼠标类
    public abstract Mouse createMouse();
}

以上是基础的类结构，下面我们需要创建联想产品、苹果产品、微软产品的工厂类，继续看代码：

//苹果电脑
public class AppleComputer extends Computer {
}

//苹果键盘
public class AppleKeyboard extends Keyboard {
}

//苹果鼠标
public class AppleMouse extends Mouse {
}

//联想电脑
public class LenovoComputer extends Computer {
}

//联想键盘
public class LenovoKeyboard extends Keyboard {
}

//联想鼠标
public class LenovoMouse extends Mouse {
}

//微软电脑
public class MicrosoftComputer extends Computer {
}

//微软键盘
public class MicrosoftKeyboard extends Keyboard {
}

//微软鼠标
public class MicrosoftMouse extends Mouse {
}

接下来才是工厂类：

//苹果工厂类
public class AppleFactory extends AbstractFactory {
    @Override
    public Computer createComputer() {
        return new AppleComputer();
    }

    @Override
    public Keyboard createKeyboard() {
        return new AppleKeyboard();
    }

    @Override
    public Mouse createMouse() {
        return new AppleMouse();
    }
}

//联想工厂类
public class LenovoFactory extends AbstractFactory {
    @Override
    public Computer createComputer() {
        return new LenovoComputer();
    }

    @Override
    public Keyboard createKeyboard() {
        return new LenovoKeyboard();
    }

    @Override
    public Mouse createMouse() {
        return new LenovoMouse();
    }
}

//微软工厂类
public class MicrosoftFactory extends AbstractFactory {
    @Override
    public Computer createComputer() {
        return new MicrosoftComputer();
    }

    @Override
    public Keyboard createKeyboard() {
        return new MicrosoftKeyboard();
    }

    @Override
    public Mouse createMouse() {
        return new MicrosoftMouse();
    }
}

这样就完成了整个抽象工厂模式的基础代码，这里仅仅是基础的代码，我们可以数一下一共有15个类，如果后续不断增加产品类，那么类的数量将不断增加。

在这里我们先用N来代表产品族，M代码产品族下的产品。那抽象工厂中的方法数量就是M个，对应的子类工厂也有N个，对应的子类数量M*N个。

综上来讲，抽象工厂模式就是生产产品族中的一系列产品，随着产品族和产品的增加，类会以(N+1)*M的方式增加，不利于管理。

以上就是我对工厂模式的拙见，多多指正!!!