设计模式笔记 -- 工厂模式

现在有一个发快递的流程要实现，如果用传统的方式实现，代码是下面这样

//快递抽象类
public abstract class Express {
    private String name;

    //快递下单，不同的快递需要在不同的网站下单，做成抽象
    public abstract void placeAndOrder();

    //取件方法
    public void pickUp(){
        System.out.println(name+"快递员来取件");
    }

    //发货方法
    public void sendOut(){
        System.out.println(name+"快递发出");
    }

    public void setName(String name){
        this.name = name;
    }
}

//顺丰快递
public class SFExpress extends Express{

    public SFExpress(){
        super.setName("顺丰");
    }

    @Override
    public void placeAndOrder() {
        System.out.println("在顺丰官网下单");
    }
}

//京东快递
public class JDExpress extends Express{

    public JDExpress(){
        super.setName("京东");
    }

    @Override
    public void placeAndOrder() {
        System.out.println("在京东快递官网下单");
    }
}

//快递订单类    
public class ExpressOrder {
    public ExpressOrder(String type) {
        Express express = null;

        if ("JD".equals(type)) {
            express = new JDExpress();
        } else if ("SF".equals(type)) {
            express = new SFExpress();
        }
        //过程
        express.placeAndOrder();
        express.pickUp();
        express.sendOut();
    }
}

public class ExpressTest {
    public static void main(String[] args) {
        new ExpressOrder("SF");
        System.out.println("_____________");
        new ExpressOrder("JD");
    }
}

运行测试类的结果

这样看起来是没有问题的，但是这样设计违反了开闭原则，即对扩展开放，对修改关闭。

在实际开发中，订单类可能不只有一个，如果要新增一个快递种类，需要改多处代码。

 

简单工厂模式

简易工厂模式属于创建型模式，是工厂模式的一种。简易工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，是工厂模式中最简单实用的模式

简易工厂模式：定义了一个创建对象的类，这个类用来封装实例化对象的代码，在开发中，当需要大量的创建某种对象，某类对象，某批对象时，就会使用到工厂模式

 

现在在上面的代码基础上加一个简单工厂类

//简单工厂
public class SimpleFactory {

    public Express getExpress(String type){
        Express express = null;

        if ("JD".equals(type)) {
            express = new JDExpress();
        } else if ("SF".equals(type)) {
            express = new SFExpress();
        }
        return express;
    }
}

然后在订单类中聚合这个简单工厂类

//快递订单类
public class ExpressOrder {

    private SimpleFactory simpleFactory = new SimpleFactory();
    
    public ExpressOrder(String type){
        Express express = simpleFactory.getExpress(type);
        express.placeAndOrder();
        express.pickUp();
        express.sendOut();
    }
}

然后使用测试类

public class ExpressTest {
    public static void main(String[] args) {
        new ExpressOrder("SF");
        System.out.println("_____________");
        new ExpressOrder("JD");
    }
}

输出的结果还是一样的

这样一来，如果要新增一个新的快递类型，只需要在工厂类里面新增一句代码，而不需要每个订单类都要修改（如果有多个订单类）

如果把工厂类中的getExpress方法改成静态方法，在订单类中就可以直接类名调用，这样就变成了静态工厂模式

工厂方法模式

还是上面的寄快递需求，现在需求变了，京东和顺丰不止有快递还有物流，可能需要发京东快递或京东物流、顺丰快递或顺丰物流

这个时候可以考虑使用工厂方法模式

设计方案：将快递对象实例化的功能抽象成抽象方法，在不同的快递子类中具体实现

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

 

快递类不变，实现四个子类，如图

对象实例化方法放到订单类，做成抽象方法，由子类实现

//快递订单类
public abstract class ExpressOrder {

    abstract Express getExpress(String type);

    public ExpressOrder(String type){
        Express express = getExpress(type); //抽象方法，由子类完成
        express.placeAndOrder();
        express.pickUp();
        express.sendOut();
    }
}

两个订单子类

//京东快递订单类
public class JDExpressOrder extends ExpressOrder{

    public JDExpressOrder(String type) {
        super(type);
    }

    @Override
    Express getExpress(String type) {
        Express express = null;
        if("JD".equals(type)){
            express = new JDExpress();
        }else if("JDWL".equals(type)){
            express = new JDExpressWL();
        }
        return express;
    }
}

//顺丰快递订单类
public class SFExpressOrder extends ExpressOrder{

    public SFExpressOrder(String type) {
        super(type);
    }

    @Override
    Express getExpress(String type) {
        Express express = null;
        if("SF".equals(type)){
            express = new SFExpress();
        }else if("SFWL".equals(type)){
            express = new SFExpressWL();
        }
        return express;
    }
}

测试类测试

public class ExpressTest {
    public static void main(String[] args) {
        new JDExpressOrder("JD");
        System.out.println("_________________");
        new JDExpressOrder("JDWL");

        System.out.println("_________________");

        new SFExpressOrder("SF");
        System.out.println("_________________");
        new SFExpressOrder("SFWL");
    }
}

输出结果

 抽象工厂模式

抽象工厂模式是把上面两种方法综合起来，工厂类使用接口，然后根据分类新建多个工厂子类。

public interface AbsFactory {
    Express getExpress(String type);
}

public class JDFactory implements AbsFactory{
    @Override
    public Express getExpress(String type) {
        Express express = null;
        if("JD".equals(type)){
            express = new JDExpress();
        }else if("JDWL".equals(type)){
            express = new JDExpressWL();
        }
        return express;
    }
}

public class SFFactory implements AbsFactory{
    @Override
    public Express getExpress(String type) {
        Express express = null;
        if("SF".equals(type)){
            express = new SFExpress();
        }else if("SFWL".equals(type)){
            express = new SFExpressWL();
        }
        return express;
    }
}

然后在订单类中组合工厂类

//快递订单类
public class ExpressOrder {

    AbsFactory factory;

    public ExpressOrder(AbsFactory factory,String type){
        Express express = factory.getExpress(type); //抽象方法，由子类完成
        express.placeAndOrder();
        express.pickUp();
        express.sendOut();
    }
}

测试

public class ExpressTest {
    public static void main(String[] args) {
        new ExpressOrder(new JDFactory(),"JD");
        System.out.println("______________");
        new ExpressOrder(new JDFactory(),"JDWL");
        System.out.println("______________");
        new ExpressOrder(new SFFactory(),"SF");
        System.out.println("______________");
        new ExpressOrder(new SFFactory(),"SFWL");
    }
}

输出结果还是一样的

 

在jdk中哪里使用到了工厂模式呢，Calendar类（日历类）在创建的时候，使用静态方法getInstance，使用的是简单工厂模式

工厂模式的意义：将实例化对象的代码抽取出来，放到一个类中统一管理，达到和主项目的依赖关系解耦，提高项目的扩展性和维护性。

抽象工厂模式就遵循了八大原则中的依赖倒置原则，去依赖抽象而不是依赖细节