之前我们提到过简单工厂模式  ----戳这里---->设计模式----简单工厂模式

今天来介绍一个和简单工厂模式很像的设计模式 ： 工厂方法模式

先看UML类图：

设计模式----工厂方法模式_工厂方法模式

 

再来看看代码：

这是产品类~

package template;

/**
 * @author  陈柏宇
 * 工厂方法模式生产的抽象产品父类以及它的具体产品子类
 * 这里我们应该灵活一点，可以不用类，也可以用接口啥的
 */

public abstract class Product {

    /*
        产品参数
     */
    private int arguments;

    /*
        产品的具体功能
     */
    public abstract void operation();
}

class ConcreteProduct1 extends Product
{
    @Override
    public void operation() {
        System.out.println("产品1的具体功能");
    }
}

class ConcreteProduct2 extends Product
{
    @Override
    public void operation() {
        System.out.println("产品2的具体功能");
    }
}

class ConcreteProduct3 extends Product
{
    @Override
    public void operation() {
        System.out.println("产品3的具体功能");
    }
}

下面是工厂类~

package template;

/**
 * @author 陈柏宇
 * 工厂类，用来生产产品
 * 这里可以用抽象工厂父类也可以用接口，都可以，我这里就用抽象父类了
 */

public abstract class Creator {
    /**
     * 生产产品的抽象方法
     */
    public abstract Product factoryMethod();
}

/**
 * 下面就是具体的工厂，生产具体的产品
 */

class ConcreteCreator1 extends Creator{
    @Override
    public Product factoryMethod() {
        return new ConcreteProduct1();
    }
}

class ConcreteCreator2 extends Creator{
    @Override
    public Product factoryMethod() {
        return new ConcreteProduct2();
    }
}

class ConcreteCreator3 extends Creator{
    @Override
    public Product factoryMethod() {
        return new ConcreteProduct3();
    }
}

main函数：

public class FactoryTest {
    public static void main(String[] args) {

        Creator creator = new ConcreteCreator2();
        Product product = creator.factoryMethod();

        product.operation();

    }
}

输出：

产品2的具体功能

估计现在就会有人问：简单工厂模式好像比这个工厂方法模式要简单诶

没错，确实简单工厂简洁一些，那为什么我们要引入这种模式呢？

/**
 * 这里主要运用了多态的知识点
 * 对象的声明始终是其抽象父类，但是实例化是你要具体生产的Product
 *
 * 我们回过头来想一想之前学的简单工厂模式，这里的工厂方法模式其实和简单工厂模式很像
 * 只不过我们把循环判断改成了具体的工厂类
 * 这样给人的感觉反而麻烦了，问题也就出在这里，我们为什么要化简为繁呢？
 *
 * 这其实也就是工厂方法模式和简单工厂的区别所在。
 * 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化
 * 相关的类，对于客户端来说，去除了与具体产品的依赖。
 * 但是它有一点问题，就是破坏了我们的封闭开放原则，因为如果我们要添加功能势必要增加一个分支，
 * 改变原有的类？这不是一个好方法。于是工厂方法就来了~
 */

这就是原因啦~

那么我来举一个学雷锋的例子~

package example;

/**
 * @author 陈柏宇
 * 雷锋类  我们都要学习雷锋的精神
 */

public class LeiFeng {
    public void sweep()
    {
        System.out.println("扫地");
    }
    public void Wash()
    {
        System.out.println("洗衣服");
    }
    public void BuyRice()
    {
        System.out.println("买衣服");
    }
}

class Undergraduate extends LeiFeng
{
    /**
     * 学雷锋的大学生
     */
}

class Volunteer extends LeiFeng
{
    /**
     * 社区志愿者
     */
}
package example;

/**
 * @author 陈柏宇
 * 雷锋工厂
 * 生产大学生实例和社区志愿者实例
 */

public interface IFactory {
    public abstract LeiFeng createLeiFeng();
}

class UndergraduateFactory implements IFactory{
    @Override
    public LeiFeng createLeiFeng() {
        return new Undergraduate();
    }
}

class VolunteerFactory implements IFactory
{
    @Override
    public LeiFeng createLeiFeng() {
        return new Volunteer();
    }
}
public class FactoryTest
{
    public static void main(String[] args) {
        IFactory factory = new UndergraduateFactory();

        LeiFeng undergraduate = factory.createLeiFeng();

        undergraduate.BuyRice();
        undergraduate.sweep();
        undergraduate.Wash();
    }
}

控制台输出：

买衣服
扫地
洗衣服