java设计模式之抽象工厂模式

     设计模式系列
抽象工厂模式

     提供一个创建一系列相关或相互依赖对象的接口,而无须指定他们具体的类。
抽象工厂方法模式的四个角色
1、抽象工厂:它声明了一组用于创建一族产品的方法,每一个方法对一个一种产品。
2、具体工厂:它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中。
3、抽象产品:它为每种产品声明接口,在抽象产品中声明了产品所具有的业务方法。
4、具体产品:它定义具体产品工厂所生产的具体产品对象,实现抽象产品接口中所声明的业务方法。
     下面我将以一个例子来说明一下:我们通过抽象工厂模式来实现可以兼容windows、unix、linux三种系统的按钮和text文本的功能。
下面是示意图:

代码:
第一步:创建抽象产品接口

/**
 * 抽象产品 按钮
 */
public interface Button {
    /**
     * 获取按钮的方法
     */
    void getButton();
}

/**
 * 抽象产品 输入框
 */
public interface Text {

    /**
     *创建文本的方法
     */
    void getText();
}

第二步:创建具体产品：

/**
 * 具体产品 windows下的按钮
 */
public class WindowsButton implements Button{
    @Override
    public void getButton() {
        System.out.println("windows下的按钮生产好了-----");
    }
}

/**
 * 具体产品 windows下的创建文本
 */
public class WindowsText implements Text{
    @Override
    public void getText() {
        System.out.println("windows下的文本创建好了------");
    }
}

/**
 * 具体产品 unix下的按钮
 */
public class UnixButton implements Button {
    @Override
    public void getButton() {
        System.out.println("unix下的按钮创建好了-----");
    }
}

/**
 * 具体产品 unix下的创建文本
 */
public class UnixText implements Text{
    @Override
    public void getText() {
        System.out.println("unix下的文本创建好了-----");
    }
}

/**
 * 具体产品 linux下的按钮
 */
public class LinuxButton implements Button{
    @Override
    public void getButton() {
        System.out.println("linux下的按钮创建好了-----");
    }
}

/**
 * 具体产品方法 linux下的创建文本
 */
public class LinuxText implements Text{
    @Override
    public void getText() {
        System.out.println("linux下的文本创建好了-----");
    }
}

第三步:创建抽象工厂接口

/**
 * 抽象工厂
 */
public interface SystemFactory {

    Button createButton();

    Text createText();
}

第四步:创建具体产品工厂:

/**
 * 具体工厂 windows工厂
 */
public class WindowsFactory implements SystemFactory{
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Text createText() {
        return new WindowsText();
    }
}

/**
 * 具体工厂 unix工厂
 */
public class UnixFactory implements SystemFactory{
    @Override
    public Button createButton() {
        return new UnixButton();
    }

    @Override
    public Text createText() {
        return new UnixText();
    }
}

/**
 * 具体工厂 linux工厂
 */
public class LinuxFactory implements SystemFactory{
    @Override
    public Button createButton() {
        return new LinuxButton();
    }

    @Override
    public Text createText() {
        return new LinuxText();
    }
}

到这里抽象工厂模式已经写完,接下来测试一下:

/**
 * 测试
 */
public class Test {

    public static void main(String[] args) {
        WindowsFactory windowsFactory = new WindowsFactory();
        Button windowsFactoryButton = windowsFactory.createButton();
        windowsFactoryButton.getButton();
        Text windowsFactoryText = windowsFactory.createText();
        windowsFactoryText.getText();


        UnixFactory unixFactory = new UnixFactory();
        Button unixFactoryButton = unixFactory.createButton();
        unixFactoryButton.getButton();
        Text unixFactoryText = unixFactory.createText();
        unixFactoryText.getText();
    }
}

运行结果:

Connected to the target VM, address: '127.0.0.1:51747', transport: 'socket'
windows下的按钮生产好了-----
windows下的文本创建好了------
unix下的按钮创建好了-----
unix下的文本创建好了-----
Disconnected from the target VM, address: '127.0.0.1:51747', transport: 'socket'

     总结:抽象工厂方法模式的好处是:当我们需要增加一族产品(兼容mos系统),我们不需要对原有方法进行修改,只需要增加一个具体工厂和一个具体产品即可。
     抽象工厂模式的优缺点:
     优点:隔离了具体类的生成,使得客户端并不需要知道什么被创建,当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象,增加新的产品族很方便,无须修改已有系统,符合开闭原则。
     缺点:增加新的产品等级结构麻烦,需要对原有系统进行较大的修改,甚至需要修改抽象层代码,违背了开闭原则。