设计模式之工厂模式

工厂设计模式:

简单工厂:

属于创建型工厂,定义了一个创建对象的类,这个类封装了实例化对象的行为,

package com.block.designPattern.factory.simpleFactory.order;

import com.block.designPattern.factory.simpleFactory.pizza.GreekPizza;
import com.block.designPattern.factory.simpleFactory.pizza.Pizza;
import com.block.designPattern.factory.simpleFactory.pizza.USAPizza;

import java.util.Scanner;

/**
 * @ClassName SimpleFactory
 * @author: fangwenjun
 * @date: Created in 2021/5/13 10:35
 * @description:
 * @version: 1.0
 */
public class SimpleFactory {

    /**
     * 简单工厂创建实例方法, 可以修改为静态方法,简化代码
     * @param orderType
     * @return
     */
    public Pizza creatInstance(String orderType){
        Pizza pizza = null;
        if ("greek".equals(orderType)){
            pizza = new GreekPizza();
            pizza.setName("希腊");
        }else if ("usa".equals(orderType)){
            pizza = new USAPizza();
            pizza.setName("usa");
        }
        return pizza;
    }
}

• 当要去新增XxxPizza的类的时候,只需要修改工厂类中的一处即可, 其他聚合工厂类的不受影响,所以需要Pizza相关实例对象的都可以从工厂类中获取

工厂方法模式:

定义一个创建对象的抽象方法,由子类决定要实例化的类,工厂方法模式是将对象的实例化推迟到子类中

package com.block.designPattern.factory.factoryMethod.order;

import com.block.designPattern.factory.factoryMethod.pizza.Pizza;

import java.util.Scanner;

/**
 * @ClassName OrderPizza
 * @author: fangwenjun
 * @date: Created in 2021/5/13 11:04
 * @description:
 * @version: 1.0
 */
public abstract class OrderPizza {

    /**
     * 定义一个抽象方法, 让其他子工厂实现该方法
     * @param orderType
     * @return
     */
    public abstract Pizza createInstance(String orderType);

    public OrderPizza() {
        do {
            String orderType = getType();
            Pizza pizza = createInstance(orderType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("不存在");
                break;
            }
        } while (true);

    }

    private String getType() {
        System.out.println("请输入披萨类型");
        Scanner scanner = new Scanner(System.in);
        return scanner.nextLine();
    }
}

public class BjPizza  extends OrderPizza{
    @Override
    public Pizza createInstance(String orderType) {
        Pizza pizza = null;
        if ("cheese".equals(orderType)){
            pizza = new BjCheesePizza();
        }else if ("pepper".equals(orderType)){
            pizza = new BjPepperPizza();
        }
        return pizza;
    }
}

抽象工厂模式:

定义一个接口用于创建相关或有依赖关系的对象簇,无需指明具体的类

将工厂抽象为两层, AbstractFactory (抽象工厂) 和具体实现的工厂子类, 可根据创建对象类型使用对应的工厂子类,提升代码维护性和扩展性

抽象工厂模式创建的时对象家族,创建很多对象,并且这些对象都是相关的,而工厂方法模式只是用于创建一个对象

package com.block.designPattern.factory.abstractFactory.order;

import com.block.designPattern.factory.abstractFactory.pizza.Pizza;

import java.util.Scanner;

/**
 * @ClassName OrderPizza
 * @author: fangwenjun
 * @date: Created in 2021/5/13 13:21
 * @description:
 * @version: 1.0
 */
public class OrderPizza {

    AbstractFactory abstractFactory;

    public OrderPizza(AbstractFactory factory){
        setAbstractFactory(factory);
    }

    private void setAbstractFactory(AbstractFactory abstractFactory) {

        do {
            String orderType = getType();
            Pizza pizza = abstractFactory.createInstance(orderType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("不存在");
                break;
            }
        } while (true);

    }

    private String getType() {
        System.out.println("请输入披萨类型");
        Scanner scanner = new Scanner(System.in);
        return scanner.nextLine();
    }
}

public interface AbstractFactory {

    Pizza createInstance(String orderType);
}

public class BjFactory  implements AbstractFactory{
    @Override
    public Pizza createInstance(String orderType) {

        Pizza pizza = null;
        if ("cheese".equals(orderType)){
            pizza = new BjCheesePizza();
        }else if ("pepper".equals(orderType)){
            pizza = new BjPepperPizza();
        }
        return pizza;

    }
}

public class LdFactory implements AbstractFactory{
    @Override
    public Pizza createInstance(String orderType) {
        Pizza pizza = null;
        if ("cheese".equals(orderType)){
            pizza = new LdCheesePizza();
        }else if ("pepper".equals(orderType)){
            pizza = new LdPepperPizza();
        }
        return pizza;
    }
}

JDK源码(工厂模式):

• jdk的日历类采用的就是工厂模式

总结:

• 将实例化对象的代码提取出来,放到一个类中统一维护和管理,达到和主项目的依赖关系解耦,从而提高项目的扩展和维护性
• 工厂模式分为三种: (简单工厂模式,工厂方法模式,抽象工厂模式)
• 设计模式的依赖抽象原则
  • 创建对象实例时,不要直接new,应该把这个new的动作放在工厂类的方法中,并返回, 即变量不要直接持有具体类的引用.
  • 不要让类继承具体类,应该继承抽象类或者实现接口