zoukankan      html  css  js  c++  java
  • 设计模式-抽象工厂模式(04)

    定义

      抽象工厂模式(Abstract Factory Pattern)是一种比较常见的模式。英文原话是Provide an interface for creating families of related or dependent objects without specifying their concrete classes。意思是为创建一组相关或相互依赖的对象提供一个接口,而且无需指定它们的具体类

      抽象工厂模式是工厂方法模式的升级版本。当有多个业务品种需要进行分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方法。

      抽象工厂模式中的角色与工厂方法类似,也是有四种角色:

        抽象工厂(Abstract Factory)角色:该角色是抽象工厂模式的核心,与应用系统无关,任何创建对象的工厂类必须实现这个接口。

        具体工厂(Concrete Factory)角色:该角色实现了抽象工厂角色所声明的接口,含有选择合适的产品对象的逻辑,并且受到应用程序的调用以创建产品对象。

        抽象产品(Abstract Product)角色:该角色负责定义产品的共性,实现对产品最抽象的定义。

        具体产品(Concrete Product)角色:该角色实现抽象产品角色所声明的接口,抽象工厂模式所创建的任何产品对象都是某个具体产品角色的实例。

    抽象工厂模式的优点

      抽象工厂模式是工厂方法模式的进一步抽象,针对的是一族产品。如果产品族中只有一种产品,则抽象工厂模式就退化为工厂方法模式。除了工厂方法模式的优点外,抽象工厂模式还有如下优点:

        1.产品族内的约束为非公开状态,在不同的工厂中,各种产品之间可能具有不同的相互依赖关系,这些依赖关系由工厂封装在其内部,对于工厂的使用者来说这些依赖关系是不可见的。

        2.生产线的扩展非常容易。如果要针对同一产品族建立新的生产线,只需要实现产品族中的所有产品接口并建立新的工厂类即可。

    抽象工厂模式的缺点

      抽象工厂模式的最大缺点就是产品族本身的扩展非常困难。如果在产品族中增加一个新的产品类型,则需要修改多个接口,并且会影响已有的工厂类。

    抽象工厂模式的使用场景

      抽象工厂模式的使用场景是:当一个对象族(或是一组没有任何关系的对象)都有相同的约束时,可以使用抽象工厂模式。

    /**
     * 抽象工厂-创建多个产品而不是单独的一个
     * 为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。
     */
    public interface IFactory {
        public IBook createBook();
        public IGame createGame();
        public IProduct createProduct();
    }
    /**
     * 具体工厂
     * 在工厂内部指定好,而不需要再调用时去指定.
     */
    public class Factory implements IFactory {
    
        @Override
        public IBook createBook() {
            return new Book("A","java核心技术");
        }
    
        @Override
        public IGame createGame() {
            return new Game("A","DOTA");
        }
    
        @Override
        public IProduct createProduct() {
            return new Product("A","BEATS");
        }
    
    }
    /**
     * 另一个具体工厂-生产另一组实例
     * 在工厂内部指定好,而不需要再调用时去指定.
     */
    public class FactoryAnother implements IFactory{
    
        @Override
        public IBook createBook() {
            return new Book("B","系统架构设计师");
        }
    
        @Override
        public IGame createGame() {
            return new Game("B","LOL");
        }
    
        @Override
        public IProduct createProduct() {
            return new Product("B","红米");
        }
    
    }
    /**
     * 产品-书
     */
    public interface IBook {
        public void method1();
        public void method2();
    }
    /**
     * 产品-游戏
     */
    public interface IGame {
        public void method1();
        public void method2();
    }
    /**
     * 产品-商品
     */
    public interface IProduct {
        public void method1();
        public void method2();
    }
    //抽象产品具体类
    public class Book implements IBook {
        String company = "";
        String bookName = "";
        public Book(String company,String bookName) {
            this.company = company;
            this.bookName = bookName;
        }
        @Override
        public void method1() {
            System.out.print("我们是"+company+"公司,我们发行的书是"+bookName);
            System.out.println("this is book method1 by "+this.getClass().getName());
        }
    
        @Override
        public void method2() {
            System.out.print("我们是"+company+"公司,我们发行的书是"+bookName);
            System.out.println("this is book method2 by "+this.getClass().getName());
        }
    
    }
    //抽象产品具体类
    public class Game implements IGame {
    
        String company = "";
        String gameName = "";
        public Game(String company,String gameName) {
            this.company = company;
            this.gameName = gameName;
        }
        @Override
        public void method1() {
            System.out.print("我们是"+company+"公司,我们做的游戏是"+gameName);
            System.out.println("this is Game method1 by "+this.getClass().getName());
        }
    
        @Override
        public void method2() {
            System.out.print("我们是"+company+"公司,我们做的游戏是"+gameName);
            System.out.println("this is Game method2 by "+this.getClass().getName());
        }
    
    }
    //抽象产品具体类
    public class Product implements IProduct {
    
        String company = "";
        String produceName = "";
        public Product(String company,String produceName) {
            this.company = company;
            this.produceName = produceName;
        }
        @Override
        public void method1() {
            System.out.print("我们是"+company+"公司,我们的卖产品是"+produceName);
            System.out.println("this is Product method1 by " + this.getClass().getName());
        }
    
        @Override
        public void method2() {
            System.out.print("我们是"+company+"公司,我们的卖产品是"+produceName);
            System.out.println("this is Product method2 by "+this.getClass().getName());
        }
    
    }
    
    //调用
    public class AbstractFactoryDemo {
        public static void main(String[] args) {
            //IFactory fc = new Factory();
            //要想生成另一组实例只需要更换具体工厂即可.
            IFactory fc = new FactoryAnother();
            IBook book = fc.createBook();
            IGame game = fc.createGame();
            IProduct product = fc.createProduct();
            book.method1();
            game.method1();
            product.method1();
        }
    }

    源码

  • 相关阅读:
    JSDeferred 源码分析
    前端MVVM框架avalon揭秘
    前端MVVM框架avalon揭秘
    轻量级前端MVVM框架avalon源码分析-总结
    JavaScript 中介者模式与观察者模式有何不同?
    Knockout 新版应用开发教程之"text"绑定
    Knockout 新版应用开发教程之"visible"绑定
    Knockout 新版应用开发教程之Observable Arrays
    设计模式之美:Decorator(装饰)
    设计模式之美:Composite(组合)
  • 原文地址:https://www.cnblogs.com/aeolian/p/7835077.html
Copyright © 2011-2022 走看看