Java 设计模式 之 工厂模式

简介

前言：

工厂模式主要是为了我们在创建对象提供过渡接口，这样就能将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 所以对于比较常用的设计模式（工厂模式），这也是我们必须要掌握的

分类 ：

工厂模式主要被分为三种

• 简单工厂模式（Simple Factory）
• 工厂方法模式（Factory Method）
• 抽象工厂模式（Abstract Factory）

对于工厂模式这种设计模式，我们可以用实际开发中遇到的问题来举个例子，如果你现在正在开发一个应用或者是一个界面，你需要不同风格的按钮，对于生产出不同的按钮，在没有工厂模式的时候你需要这样做

ButtonA a = new ButtonA();
ButtonB b = new ButtonB();
ButtonC c = new ButtonC();

显而易见，这种方式在我们刚学习的时候都是用的这种方法，但是当我们在实际开发中这样写代码虽然能完成功能，但是这样是不利于维护的，如果要修改代码就需要修改引用类型的名字，这在代码比较多的项目里面并不简单，所以我们使用工厂模式，下面我使用了三种不同的工厂模式

简单工厂模式 ：

简单工厂模式的原理很简单，我们通过一个ButtonFactory的类来进行管理我们需要进行得到不同的Button类型,下面我们通过这张图来熟悉简单工厂模式的流程

相信上面的流程图已经能说明一切了，首先我们通关Control这个类来实例化ButtonFactory通过getButton传入需要的Button类型然后根据需要的类型来进行实例化不同的Button下面请看代码

---

Button类

public  class Button {
    public Button() {

    }
}

MacButton类

public class MacButton extends Button{
    public MacButton() {
    System.out.println("MacButton..........");
    }
}

WindowsButton类

public class WindowsButton extends Button{
    public WindowsButton() {
    System.out.println("WindowsButton..........");
    }
}

UbuntuButton类

public class UbuntuButton extends Button{
    public UbuntuButton() {
    System.out.println("UbuntuButton..........");
    }
}

ButtonType(按钮类型)

public enum ButtonType {
    mac,window,ubuntu;
}

ButtonFactory类

public class ButtonFactory {

    public Button getButton(ButtonType type) {
    if (type == ButtonType.mac) 
        return new MacButton();
    else if(type == ButtonType.window)
        return new WindowsButton();
    else if(type == ButtonType.ubuntu)
       return new UbuntuButton();
    else 
        return new Button() ;
    }
}

Control类

public class Control {
    public static void main(String[] args) {
    ButtonFactory btnFactory = new ButtonFactory();
    /*只需要传递不同的类型就返回不同的Button*/
    Button mac_btn = btnFactory.getButton(ButtonType.mac); 
    }
}

上面你所看到的就是简单工厂模式，现在我们来看一下工厂方法模式

---

工厂方法模式 ：

工厂方法模式主要是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类

对于工厂方法模式我们一般都是定义一个抽象的Factory类（可以是抽象类和接口），这个类将不再负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。

也许你会看完我上面的叙述有点混乱，请别着急，下面我们来通过这张流程图我们来搞懂工厂方法模式是怎么工作的

，
我们首先通过Control引用一个Factory 通过产生不同Button的Factory实例，通过Button的factory来获取到不同样式的按钮实例，下面是具体代码

Button接口

public interface Button {
    public  void Introduce_yourself();
}

三种Button样式

public class MacButton implements Button {

    @Override
    public void Introduce_yourself() {
    System.out.println("MacButton..........");
    }

}
public class UbuntuButton implements Button {

    @Override
    public void Introduce_yourself() {
    System.out.println("UbuntuBuuton............");
    }

}


public class WindowsButton implements Button {

    @Override
    public void Introduce_yourself() {
    System.out.println("WindowsButton..........");
    }
}

三种Button类型的Factory

public class FactoryMac implements ButtonFactory{

    @Override
    public Button getButton() {

    return new MacButton();
    }

}
public class FactoryUbuntu implements ButtonFactory{

    @Override
    public Button getButton() {

    return new UbuntuButton();
    }

}
public class FactoryWindows implements ButtonFactory{
    @Override
    public Button getButton() {

    return new WindowsButton();
    }
}

控制类

public class Control {
    public static void main(String[] args) {
    ButtonFactory factory = new FactoryMac();
    Button btn_mac = factory.getButton();
    btn_mac.Introduce_yourself();
   }
}

可以看到我们在Control中将ButtonFactory的引用赋值到一个FactoryMac所产生的实例上面

---

运行结果：

MacButton..........

对于工厂方法模式的优缺点

优点 ：

• 因为每个具体工厂类只负责创建产品，没有简单工厂中的逻辑判断，因此符合单一职责原则。
• 与简单工厂模式不同，工厂方法并不使用静态工厂方法，可以形成基于继承的等级结构。

缺点 ：

• 不利于扩展，添加的Button时，除了增加新的Button类外，还要提供与之对应的具体工厂类，系统类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销
• 虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要换用另外一种产品，仍然需要修改实例化的具体工厂。

抽象工厂模式 ：

对于抽象工厂模式 ，它与工厂方法模式最大的区别在于抽象工厂中每个工厂可以创建多个种类的产品(Button）。也许你还是不太懂，下面习惯性的看一张流程图

在这里我们通过Control引用一个Factory然后直接将new出来的ButtonFactory赋值个给引用的Factory，直接通过Factory引用的对象来进行活动不同的Button类型，下面是具体代码

---

三个接口

public interface MacButton {

}
public interface UbuntuButton {

}
public interface WindowsButton {

}

三个具体实现类

public class SpecificMacButton implements MacButton{
    public SpecificMacButton() {
    System.out.println("MacButton...........");
    }
}

public class SpecificUbuntuButton implements UbuntuButton{
    public SpecificUbuntuButton() {
    System.out.println("UbuntuButton.................");
    }

}
public class SpecificWindowsButton implements WindowsButton {
    public SpecificWindowsButton() {
    System.out.println("WindowsButton............");
    }
}

Factory 接口与ButtonFactory类

public interface Factory {
    public MacButton getMacButton();
    public WindowsButton getWindowsButton();
    public UbuntuButton getUbuntuButton();
}

public class ButtonFactory implements Factory {

    @Override
    public MacButton getMacButton() {

    return new SpecificMacButton();
    }

    @Override
    public WindowsButton getWindowsButton() {

    return new SpecificWindowsButton();
    }

    @Override
    public UbuntuButton getUbuntuButton() {

    return new SpecificUbuntuButton();
    }

}

最后就是Control调用了

public class Control {
    public static void main(String[] args) {
    Factory factory = new ButtonFactory();
    factory.getMacButton();
    factory.getUbuntuButton();
    factory.getWindowsButton();
    }
}

运行结果

MacButton...........
UbuntuButton.................
WindowsButton............

抽象工厂模式是对工厂方法模式的一种延伸，通过一个Factory就能得到不同的Button实例这样大大简便了，使的这样增加新的Button样式就会更为方便

好了关于工厂模式的三种运用我就讲到这里了