设计模式--抽象工厂模式

蹲街弑〆低调 提交于 2020-02-09 18:12:28

抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂示例:

假设我们需要两种产品,分别是鼠标和键盘,鼠标由鼠标厂生产,键盘由键盘厂生产。工厂为两个品牌提供代工,分别是戴尔和惠普。如下:

首先创建两个接口,分别是Mouse接口和Keyboard接口,表示鼠标和键盘两个类族。

package AbstractFactory;

public interface Keyboard {
    public void print();
}

package AbstractFactory;

public interface Mouse {
    public void print();
}

然后创建产品类:产品为戴尔鼠标、戴尔键盘、惠普鼠标、惠普键盘

package AbstractFactory;

public class HPKeyboard implements Keyboard {
    public void print(){
        System.out.println("惠普键盘");
    }
}

package AbstractFactory;

public class HPMouse implements Mouse {
    public void print(){
        System.out.println("惠普鼠标");
    }
}
package AbstractFactory;

public class DellMouse implements Mouse {
    public void print(){
        System.out.println("戴尔鼠标");
    }
}

package AbstractFactory;

public class DellKeyboard  implements Keyboard{
    public void print(){
        System.out.println("戴尔键盘");
    }
}

然后创建工厂,先创建抽象工厂:

package AbstractFactory;

public abstract class AbstractFactory {
    private static Object lock = new Object();
    private static KeyboardFactory keyboardFactory;
    private static MouseFactory mouseFactory;

    public static MouseFactory getMouseFactory() {
        if (mouseFactory == null) {
            synchronized (lock) {
                if (mouseFactory == null) mouseFactory = new MouseFactory();
            }
        }
        return mouseFactory;
    }

    public static KeyboardFactory getKeyboardFactory() {
        if (keyboardFactory == null) {
            synchronized (lock) {
                if (keyboardFactory == null) keyboardFactory = new KeyboardFactory();
            }
        }
        return keyboardFactory;
    }

}

 

然后创建小工厂,继承抽象工厂,专注于生产某种产品,例如鼠标厂、键盘厂:

package AbstractFactory;

public class KeyboardFactory extends AbstractFactory {
    public Keyboard getInstance(String name) {
        switch (name) {
            case "dell":
                return new DellKeyboard();
            case "hp":
                return new HPKeyboard();
            default:
                return null;
        }
    }
}

package AbstractFactory;

public class MouseFactory extends AbstractFactory {
    public  Mouse getInstance(String name) {
        switch (name) {
            case "dell":
                return new DellMouse();
            case "hp":
                return new HPMouse();
            default:
                return null;
        }
    }
}

然后就是创建超级工厂类:结合了单例模式,参考同系列 设计模式--单例模式部分

package AbstractFactory;

public class SuperFactory {
    private static Object lock = new Object();
    private static KeyboardFactory keyboardFactory;
    private static MouseFactory mouseFactory;

    public static MouseFactory getMouseFactory() {
        if (mouseFactory == null) {
            synchronized (lock) {
                if (mouseFactory == null) mouseFactory = new MouseFactory();
            }
        }
        return mouseFactory;
    }

    public static KeyboardFactory getKeyboardFactory() {
        if (keyboardFactory == null) {
            synchronized (lock) {
                if (keyboardFactory == null) keyboardFactory = new KeyboardFactory();
            }
        }
        return keyboardFactory;
    }

}

整个抽象工厂已经创建完毕,现在进行测试:

假设要为惠普代工鼠标:

package AbstractFactory;

public class Main {
    public static void main(String[] a){
        Mouse mouse=SuperFactory.getMouseFactory().getInstance("hp");
        mouse.print();
    }
}

输出结果:

惠普鼠标

 

注:在创建小工厂的时候我使用了单例模式,因为每一个工厂都是一样的,都只能创建实例,所以只需要实例化一次即可

 

 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!