设计模式-工厂模式

工厂模式

工厂模式下有哪几种模式？在什么场景下使用？有什么区别？在那里有体现使用？

简单工厂模式

简单工厂模式（Simple Factory Pattern）是指将一个对象交给专有的对象创建。如果你的工厂类负责创建的对象较少的场景，你就可以考虑使用它。如下：
模拟一个支付的场景：有微信、阿里、visa

新建一个接口文件

package zh.stu.SimpleFactory;

public interface IPay {
    void Pay();
}

创建几个他的实现类：

• 微信支付

package zh.stu.SimpleFactory;

public class WeChatPay implements IPay {
    public void Pay() {
        System.out.println("微信支付");
    }
}

• 阿里支付

package zh.stu.SimpleFactory;

public class AliPay implements IPay {
    public void Pay() {
        System.out.println("阿里支付");
    }
}

• 银联支付

package zh.stu.SimpleFactory;

public class VisaPay implements IPay {
    public void Pay() {
        System.out.println("银联支付");
    }
}

• 对支付方式创建一个支付工厂的类，可以将几种方法进行实例化

package zh.stu.SimpleFactory;

public class PayFactory {
    //规定传进来的值，必须是IPay的子类
    public IPay payTest(Class<? extends  IPay> clazz){
        try {
            if(null != clazz){
                //不等于空，就返回这个对象
                return clazz.newInstance();
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

写一个测试类

package zh.stu.SimpleFactory;

/**
 * 工厂模式
 */
public class SimpleFactoryTest {
    public static void main(String[] args) {
        PayFactory payFactory = new PayFactory();
        IPay iPay = payFactory.payTest(WeChatPay.class);
        iPay.Pay();

    }
}

可以看到他们几个直接的关系图

工厂方法模式

工厂方法模式（Factory Method Pattern)是指定义一个创建对象的接口，让实现这个接口的类来决定实例化哪个类。
如下：

• 首先创建一个接口

package zh.stu.FactoryMethod;

/**
 * @Author：KoVaVo
 * @Version：1.0.0
 * @Description：
 */
public interface ICar {
    public void model();
}

• 在创建一个实现该接口的实现类

package zh.stu.FactoryMethod;

/**
 * @Author：KoVaVo
 * @Version：1.0.0
 * @Description：
 */
public class BMW implements ICar {
    public void model() {
        System.out.println("BMW class...");
    }
}

• 创建一个car接口工厂：ICarFactory

package zh.stu.FactoryMethod;

/**
 * @Author：KoVaVo
 * @Version：1.0.0
 * @Description：
 */
public interface ICarFactory {
    ICar buy();
}

• 可以创建一个BMW的工厂类并且实现接口工厂。实现接口中的方法

package zh.stu.FactoryMethod;

/**
 - @Author：KoVaVo
 - @Version：1.0.0
 - @Description：
 */
public class BMWFactory implements ICarFactory {
    public ICar buy() {
        return new BMW();
    }
}

• 最后通过测试查看返回结果

package zh.stu.FactoryMethod;

/**
 * @Author：KoVaVo
 * @Version：1.0.0
 * @Description：
 */
public class FactoryMethodTest {
    public static void main(String[] args) {
        BMWFactory bmwFactory = new BMWFactory();
        ICar buy = bmwFactory.buy();
        buy.model();
    }
}

我们来看他们的关系图：

工厂方法使用场景：

1. 一个类通过自类来制定创建哪一个对象
2. 创建对象需要大量的重复代码
3. 客户端不依赖常品实现如何被创建的细节

缺点：

1. 在编写的过程中我们也发现，需要创建的类的个数过多。如果再有一个类需要实例化，这时候就需要新建两个接口。分别实现ICar接口，和ICarFactory接口。