静态/简单工厂

类图

代码

AbstractProduct

package cn.zjm404.stu.design.factory;
public abstract class AbstractProduct {
    public void method1(){
        System.out.println("这是一个工厂模式中的产品");
    }
    public abstract void method2();
}

ConcreteProduct1

package cn.zjm404.stu.design.factory;
public class ConcreteProduct1 extends AbstractProduct{
    @Override
    public void method2() {
        System.out.print("这是产品1");
    }
}

ConcreteProduct2

package cn.zjm404.stu.design.factory;
public class ConcreteProduct2 extends AbstractProduct{
    @Override
    public void method2() {
        System.out.println("这是产品2");
    }
}

Factory

方式一使用if语句判断

package cn.zjm404.stu.design.factory.simple;
import cn.zjm404.stu.design.factory.AbstractProduct;
import cn.zjm404.stu.design.factory.ConcreteProduct1;
import cn.zjm404.stu.design.factory.ConcreteProduct2;
public class Factory {
    public static AbstractProduct create(String type){
        if(type.equalsIgnoreCase("1")){
            return new ConcreteProduct1();
        }else if(type.equalsIgnoreCase("2")){
            return new ConcreteProduct2();
        }else{
            return null;
        }
    }
}

方式二使用反射创建

    public static <T extends AbstractProduct> AbstractProduct createPlus(Class<T> clazz){
        AbstractProduct ap = null;
        try{
            ap = (AbstractProduct) Class.forName(clazz.getName()).getConstructor().newInstance();
        } catch (IllegalAccessException | ClassNotFoundException | NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return ap;
    }

Client

package cn.zjm404.stu.design.factory;
import cn.zjm404.stu.design.factory.simple.Factory;
import java.util.Scanner;
public class Client {
    public static void main(String[] args) {
        String str;
        Scanner sc = new Scanner(System.in);
        str = sc.nextLine();
        AbstractProduct abstractProduct = Factory().create(str);
        if (abstractProduct != null) {
            abstractProduct.method2();
        }
        AbstractProduct ap = Factory.createPlus(ConcreteProduct1.class);
        ap.method2();
    }
}

优缺点

可以很明显的看出
优点：高内聚，不暴露具体的产品类(使用反射除外）
确点：当有新产品出来时，需要去修改Factory类源码

工厂

介绍

每个对象都有对应的一个工厂，不对Client暴露具体的产品类

类图

关于依赖就只画有变量名的好了，例如：
在Client中
AbstractProduct ap = new ConcreteProduct1();
就只画
Client —> AbstractProduct
而不是
Client —> ConcreteProduct1
Client —> AbstractProduct

代码

AbstractFactory

如果不需要有相同的方法，改为接口也可以

package cn.zjm404.stu.design.factory.factory;
import cn.zjm404.stu.design.factory.AbstractProduct;
public abstract class AbstractFactory{
    public abstract AbstractProduct create();
}

ConcreteFactory1

package cn.zjm404.stu.design.factory.factory;
import cn.zjm404.stu.design.factory.AbstractProduct;
import cn.zjm404.stu.design.factory.ConcreteProduct1;
public class ConcreteFactory1 extends AbstractFactory{
    @Override
    public AbstractProduct create() {
        return new ConcreteProduct1();
    }
}

ConcreteFactory2

package cn.zjm404.stu.design.factory.factory;
import cn.zjm404.stu.design.factory.AbstractProduct;
import cn.zjm404.stu.design.factory.ConcreteProduct1;
public class ConcreteFactory1 extends AbstractFactory{
    @Override
    public AbstractProduct create() {
        return new ConcreteProduct1();
    }
}

抽象工厂

介绍

与工厂方法模式类似，不同的是工厂可以生产多个相关联的产品，或者说生产一组产品，其余一样。有多少组产品，就有多少对应的工厂

package cn.zjm404.stu.dp.creat.factory.af;
public abstract class AbstractFactoryType1 {
    public abstract AbstractProductType1 creatProduct1();
    public abstract AbstractProductType1 creatProduct2();
}

选择

三种工厂模式，如何选择呢？

• 当产品生产逻辑简单时，使用简单工厂模式
  • 当产品逻辑较多时使用反射的形式创建
  • 较少时，使用if即可
• 当产品生产逻辑较复杂时
  • 复杂且产品数量不多，工厂模式
  • 复杂且产品数量多并且产品间有共同点，抽象工厂模式