Java设计模式(一)——工厂方法模式

本文转载自：https://www.cnblogs.com/gdwkong/p/8413342.html，原文是将工厂方法模式和抽象工厂模式放在一起了好做比较，我这里拆分开

1.工厂模式介绍

　　1.1定义：定义一个创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到子类。

　　工厂方法的通用类图

　　

 

 

 　　在工厂模式中，抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义，Creator为抽象类的创建类，也就是抽象工厂，具体如何创建类是由具体的实现工厂ConcreteCreator完成的。

　　1.2工厂方法模式的有点

• 良好的封装性，代码结构清晰
• 扩展性非常好，在增加产品类的情况下，只要适当的修改一个具体工厂类或者扩展一个工厂类，就可以“拥有变化”。
• 屏蔽产品类。产品类如何变化，调用者无需关心，它只需关心产品的接口，只要接口保持不变，系统的上层模块就不需要发生变化。
• 解耦框架。高层模块只需要关心产品的抽象类，其他实现类都不用关心。

　　1.3工厂方法模式的使用场景

　2.简单工厂模式的实现

　　2.1简单工厂模式（静态工厂模式）

　　以实现一个计算器为例：

　　整个过程设计三个对象：人（Program4表示），计算器（以OperationFactory表示），计算方式（计算方式有多种，加减乘除等，都属于计算方法，以一个父类Operation，加减乘除继承覆写方法即

　　可）。整个示例类如下：

　　

 

 

 

public class Program4 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数字A");
        double numberA = Double.parseDouble(scanner.nextLine());
        System.out.println ("选择运算符(+、-、*、/):");
        String atrithmeticType = scanner.nextLine();
        System.out.println("请输入数字B");
        double numberB = Double.parseDouble(scanner.nextLine());
        Operation operate = OperationFactory.createOperate(atrithmeticType);

        if (atrithmeticType.equals("/") && numberB == 0){
            System.out.println("除数不能为0");
        }else {
            operate.setNumberA(numberA);
            operate.setNumberB(numberB);
            double result = operate.result();
            System.out.println("结果为：1" + result);
        }
        scanner.close();
    }
}

　　计算器（工程）用户需求，选择（生产）符合需要的计算方式创建对应的示例对象，创建过程需要用户参与。

　　

public class OperationFactory {

    public static Operation createOperate(String arithmeticType){
        Operation operation = null;
        switch (arithmeticType){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation= new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
        }
        return operation;
    }
}

public class Operation {
    private double numberA;
    private double numberB;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }
    public double result(){
        double result = 0;
        return 0;
    }
}

public class OperationAdd extends Operation{
    @Override
    public double result() {
        return getNumberA() + getNumberB();
    }
}

public class OperationSub extends Operation {
    @Override
    public double result() {
        return getNumberA() - getNumberB();
    }
}

public class OperationMul extends Operation {
    @Override
    public double result() {
        return getNumberA() * getNumberB();
    }
}

public class OperationDiv extends Operation {
    @Override
    public double result() {
        return getNumberA() / getNumberB();
    }
}

简单工厂的缺点是不符合“开闭原则”，要增加新的功能（计算方式）时，需要修改工厂类（增加分支）。

2.2多方法工厂模式

是对简单工厂模式的改进，在简单工厂方法模式中，如果传递的字符串出错，则不能创建对象，而多方法工厂模式是提供多个工厂方法，分别创建对象

public class OperationFactory03 {
    public Operation add(){
        return new OperationAdd();
    }
    public Operation sub(){
        return new OperationSub();
    }
    public Operation mul(){
        return new OperationMul();
    }
    public Operation div(){
        return new OperationDiv();
    }
}


// main方法中
OperationFactory03 operationFactory03 = new OperationFactory03();
        Operation add = operationFactory03.add();
        add.setNumberA(1);
        add.setNumberB(2);
        double result = add.result();
        System.out.println("结果是：" + result);

2.3静态工厂方法

多个工厂方法设置为静态，不需要创建工厂，直接创建对象

public class OperationFactory04 {
    public static Operation add(){
        return new OperationAdd();
    }
    public static Operation sub(){
        return new OperationSub();
    }
    public static Operation mul(){
        return new OperationMul();
    }
    public static Operation div(){
        return new OperationDiv();
    }
}

// main方法中
Operation add = OperationFactory04.add();
        add.setNumberA(1);
        add.setNumberB(2);
        double result = add.result();
        System.out.println("结果是：" + result);

总体来说：工厂模式，适合出现了大量产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。

在以上三种工程方法模式中，第一种如果不能正确的传入字符，不能正确创建对象；第三种相对于第二种不需要实例化工厂，所以大多数情况下我们会选择第三种--------静态工厂方法模式。

3.工厂方法模式

一个抽象类可以派生出多个具体的产品类，主要针对某一类产品

　　3.1工厂方法模式分为个角色：

　　Product：抽象产品类

　　ConcreteProduct：具体的产品类

　　Creator：抽象的工厂类

　　ConcreteCreator：具体的工厂类

　　3.2应用

　　这里就不和原文一样了，就用通用 例子来演示：冰箱

　　冰箱有很多品牌：海尔 格力 小米 

 

 

 

 

 

 

public class Market {
    public static void main(String[] args) {
        System.out.println("商场跟工厂说我要海尔冰箱10台, 美的冰箱2台, 小米冰箱2台");
        Factory hairFridgeFactory = new HairFridgeFactory();
        // 工厂生产 海尔
        Fridge hairFridge = hairFridgeFactory.createFridge();
        hairFridge.info();
        // 工厂生产 美的
        Factory mediFridgeFactory = new MediFridgeFactory();
        Fridge mediFridge = mediFridgeFactory.createFridge();
        mediFridge.info();
        // 工厂生产 小米
        Factory miFridgeFactory = new MiFridgeFactory();
        Fridge miFridge = miFridgeFactory.createFridge();
        miFridge.info();
    }
}

/**
 * 抽象工厂类
 */
public abstract class Factory {

    /**
     *  创建冰箱类
     * @param
     * @return
     */
    public abstract Fridge createFridge();
}
/**
 * 抽象冰箱类
 */
public abstract class Fridge {
    public abstract void info();
}

public class HairFridgeFactory extends Factory {
    @Override
    public Fridge createFridge() {
        return new HairFridge();
    }
}

public class MediFridgeFactory extends Factory {
    @Override
    public Fridge createFridge() {
        return new MediFridge();
    }
}

public class MiFridgeFactory extends Factory {
    @Override
    public Fridge createFridge() {
        return new MediFridge();
    }
}

public class HairFridge extends Fridge {
    @Override
    public void info() {
        System.out.println("美的冰箱");
    }
}


public class MediFridge extends Fridge {
    @Override
    public void info() {
        System.out.println("美的冰箱");
    }
}

public class MiFridge extends Fridge {
    @Override
    public void info() {
        System.out.println("小米冰箱");
    }
}

 

从上面的代码可以看出这里遵循了开闭原则，单一原则，同时这里发现如果我想增加冰箱品牌，我直接扩展一个冰箱的实现类和一个冰箱的工厂类

优点：

在工厂方法中，客户端只需要知道所要产品的具体工厂，无需关心具体的创建过程，甚至不需要具体产品的类名。

增加新的产品时，只需要添加一个具体产品类和对应的实现工厂，无需对原工厂进行任何修改，符合开-闭原则。

缺点：

每增加一个产品时，都需要增加一个具体类和实现工厂，导致系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖 。