精华内容
下载资源
问答
  • 抽象工厂

    万次阅读 多人点赞 2018-09-09 18:30:12
    抽象工厂 示例 使用典范 抽象工厂 定义 :抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类 创建型 :创建型 适用场景: 客户端(应用层)不依赖于产品类实例如何被...

    抽象工厂

    定义 :抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类

    创建型 :创建型

    适用场景

    • 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
    • 强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量的重复代码
    • 提供一个产品类的库,所有的产品以同样的接口出现,从而使得客户端不依赖于具体的实现

    优点

    • 具体产品在应用层的代码隔离,无需关心创建的细节
    • 将一个系列的产品统一到一起创建

    缺点

    • 规定了所有可能被创建的产品集合,产品簇中扩展新的产品困难;
    • 增加了系统的抽象性和理解难度

    UML类图

    Creator:产品族工厂,定义了一系列的产品生产行为

    ConcreteCreator:具体的产品族工厂

    Product:抽象产品接口

    ProductA1/A2/B1/B2:都是具体的产品,实现了相应的产品接口

    为了更好理解抽象工厂模式,需要先搞清楚产品等级和产品族的概念,举个粟子:手机有小米手机、华为手机,它们都是手机,这些具体的手机和抽象手机就构成了一个产品等级结构。同样的,路由器有小米路由器,华为路由器,这些具体的路由器和抽象路由器就构成了另外一个产品等级结构,实质上产品等级结构即产品的继承结构。小米手机位于手机产品等级结构中,小米路由器位于路由器的产品等级结构中,而小米手机和小米路由器都是小米公司生产的,就构成了一个产品族,同理,华为手机和华为路由器也构成了一个产品族 。划重点就是产品族中的产品都是由同一个工厂生产的,位于不同的产品等级结构

    对比工厂方法,其针对的是产品等级结构,而抽象工厂是针对产品族。在二者的使用选择上,需要结合实际业务,对于产品等级数量相对固定的产品族,可以优先考虑抽象工厂模式,但是如果频繁变动,则不大适用,因为在现有的产品族中新增产品等级时,就需要修改产品族工厂,也就违背了开闭原则

    示例

    这里就以上面的栗子进行代码描述

    • 定义抽象产品接口
    /**
     * 手机产品接口
     */
    public interface IPhoneProduct {
    
        /**
         * 开机
         */
        void start();
    
        /**
         * 关机
         */
        void shutdown();
    
        /**
         * 拨打电话
         */
        void callUp();
    
        /**
         * 发送短信
         */
        void sendSMS();
    
    }
    
    
    /**
     * 路由器产品接口
     */
    public interface IRouterProduct {
    
        /**
         * 开机
         */
        void start();
    
        /**
         * 关机
         */
        void shutdown();
    
        /**
         * 开启wifi
         */
        void openWifi();
    
        /**
         * 设置参数
         */
        void setting();
    
    }
    	
    
    • 定义小米品牌手机和路由器产品实现类、华为品牌手机和路由器产品实现类
    /**
     * 小米手机产品
     */
    public class XiaomiPhone implements IPhoneProduct {
        @Override
        public void start() {
            System.out.println("开启小米手机");
        }
    
        @Override
        public void shutdown() {
            System.out.println("关闭小米手机");
        }
    
        @Override
        public void callUp() {
            System.out.println("用小米手机打电话");
        }
    
        @Override
        public void sendSMS() {
            System.out.println("用小米手机发短信");
        }
    }
    
    
    /**
     * 小米路由器产品
     */
    public class XiaomiRouter implements IRouterProduct {
        @Override
        public void start() {
            System.out.println("启动小米路由器");
        }
    
        @Override
        public void shutdown() {
            System.out.println("关闭小米路由器");
        }
    
        @Override
        public void openWifi() {
            System.out.println("打开小米路由器的wifi功能");
        }
    
        @Override
        public void setting() {
            System.out.println("设置小米路由器参数");
        }
    }
    
    /**
     * 华为手机产品
     */
    public class HuaweiPhone implements IPhoneProduct {
        @Override
        public void start() {
            System.out.println("开启华为手机");
        }
    
        @Override
        public void shutdown() {
            System.out.println("关闭华为手机");
        }
    
        @Override
        public void callUp() {
            System.out.println("用华为手机打电话");
        }
    
        @Override
        public void sendSMS() {
            System.out.println("用华为手机发短信");
        }
    }
    
    
    /**
     * 华为路由器产品
     */
    public class HuaweiRouter implements IRouterProduct {
        @Override
        public void start() {
            System.out.println("启动华为路由器");
        }
    
        @Override
        public void shutdown() {
            System.out.println("关闭华为路由器");
        }
    
        @Override
        public void openWifi() {
            System.out.println("打开华为路由器的wifi功能");
        }
    
        @Override
        public void setting() {
            System.out.println("设置华为路由器参数");
        }
    }
    
    
    • 定义一个抽象工厂接口,感觉称为抽象产品族工厂可能更容易理解,毕竟它不止生产一种产品
    /**
     * 抽象产品工厂(定义了同一个产品族的产品生产行为)
     */
    public interface IProductFactory {
    
        /**
         * 生产手机
         * @return
         */
        IPhoneProduct produceTelPhone();
    
        /**
         * 生产路由器
         * @return
         */
        IRouterProduct produceRouter();
    
    }
    
    
    • 小米工厂和华为工厂实现类
    /**
     * 小米产品工厂
     */
    public class XiaomiProductFactory implements IProductFactory {
        @Override
        public IPhoneProduct produceTelPhone() {
            System.out.println(">>>>>>生产小米手机");
            return new XiaomiPhone();
        }
    
        @Override
        public IRouterProduct produceRouter() {
            System.out.println(">>>>>>生产小米路由器");
            return new XiaomiRouter();
        }
    }
    
    /**
     * 华为产品工厂
     */
    public class HuaweiProductFactory implements IProductFactory{
        @Override
        public IPhoneProduct produceTelPhone() {
            System.out.println(">>>>>>生产华为手机");
            return new HuaweiPhone();
        }
    
        @Override
        public IRouterProduct produceRouter() {
            System.out.println(">>>>>>生产华为路由器");
            return new HuaweiRouter();
        }
    }
    
    • 客户端
    /**
     * 客户端
     */
    public class Client {
    
        public static void main(String[] args) {
            System.out.println("===================小米系列产品=================");
            //小米产品工厂实例
            IProductFactory xiaomiProductFactory = new XiaomiProductFactory();
            //生产小米路由器
            IRouterProduct xiaomiRouter = xiaomiProductFactory.produceRouter();
            xiaomiRouter.start();
            xiaomiRouter.setting();
            xiaomiRouter.openWifi();
            xiaomiRouter.shutdown();
            //生产小米手机
            IPhoneProduct xiaomiPhone = xiaomiProductFactory.produceTelPhone();
            xiaomiPhone.start();
            xiaomiPhone.callUp();
            xiaomiPhone.sendSMS();
            xiaomiPhone.shutdown();
            
            System.out.println("===================华为系列产品=================");
            //华为产品工厂实例
            IProductFactory huaweiProductFactory = new HuaweiProductFactory();
            //生产华为路由器
            IRouterProduct huaweiRouter = huaweiProductFactory.produceRouter();
            huaweiRouter.start();
            huaweiRouter.setting();
            huaweiRouter.openWifi();
            huaweiRouter.shutdown();
            //生产华为手机
            IPhoneProduct huaweiPhone = huaweiProductFactory.produceTelPhone();
            huaweiPhone.start();
            huaweiPhone.callUp();
            huaweiPhone.sendSMS();
            huaweiPhone.shutdown();
        }
    }
    

    控制台输出结果:

    ===小米系列产品=

    >>>>>>生产小米路由器
    启动小米路由器
    设置小米路由器参数
    打开小米路由器的wifi功能
    关闭小米路由器
    >>>>>>生产小米手机
    开启小米手机
    用小米手机打电话
    用小米手机发短信
    关闭小米手机
    ===华为系列产品=
    >>>>>>生产华为路由器
    启动华为路由器
    设置华为路由器参数
    打开华为路由器的wifi功能
    关闭华为路由器
    >>>>>>生产华为手机
    开启华为手机
    用华为手机打电话
    用华为手机发短信
    关闭华为手机

    从上面的整个示例可以发现,如果现在想增加一个产品等级,如新加一种笔记本产品,就需要修改抽象产品工厂接口IProductFactory,如下

     * 抽象产品工厂(定义了同一个产品族的产品生产行为)
     */
    public interface IProductFactory {
    
        /**
         * 生产手机
         * @return
         */
        IPhoneProduct produceTelPhone();
    
        /**
         * 生产路由器
         * @return
         */
        IRouterProduct produceRouter();
        
        /**
         * 生产笔记本(新增)
         * @return
         */
        IComputerProduct produceComputer();
    
    }
    
    
    

    这种直接修改抽象接口的做法,会导致其所有实现子类都需要进行修改,违反了开闭原则。当然,如果这种修改是长期稳定的,那么也可以接受。看起来上面的例子可能大合适,整个工厂的产品等级数量不是很稳定(小米和华为的后续延伸产品还有很多),但足以描述抽象工厂的应用。

    如果该场景以工厂方法实现,那么我们需要定义一个手机工厂、一个路由器工厂、然后小米手机工厂实现类,华为手机工厂实现类,小米路由器工厂实现类,华为路由器工厂实现类,其余的产品接口和产品实现类均与上相同,这样就多出了一些产品工厂,略显啰嗦

    实际使用中,都需要根据业务去权衡使用工厂方法还是抽象工厂,前者关注点在产品等级上,后者关注点在产品族上,对于稳定的产品族,也即是产品等级数量稳定,使用抽象工厂会更加有效率,毕竟不再是一个工厂生产一种产品,而是一个工厂生产多种同族产品,对于不稳定的产品族,单独使用工厂方法会显得更加灵活

    使用典范

    • java.sql.Connection
    public interface Connection  extends Wrapper, AutoCloseable {
    	//...    	
        	//返回普通的sql执行器
            Statement createStatement() throws SQLException;
    		//返回具有参数化预编译功能的sql执行器
        	PreparedStatement prepareStatement(String sql) throws SQLException;
        	//返回可以执行存储过程的sql执行器
            CallableStatement prepareCall(String sql) throws SQLException;   
        //...         
    }
    

    从上面的注释就可以看出,这就是典型的抽象工厂接口,描述了不同的产品等级Statement、PreparedStatement、CallableStatement,它们都位于抽象接口Statement产品等级结构中。我们可以继续寻找该抽象工厂接口的实现类

    这里就以Mysql为例,可以找到Mysql对这个工厂接口的实现类ConnectionImpl,ConnectionImpl并不是直接实现了java.sql.Connection,而是通过实现自己扩展的MySQLConnection接口,该接口也是间接继承了java.sql.Connection

    public class ConnectionImpl extends ConnectionPropertiesImpl implements MySQLConnection {
    	//...
    
     public java.sql.Statement createStatement() throws SQLException {
            return createStatement(DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY);
        }
       
     public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException {
            return prepareStatement(sql, DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY);
        }
        
     public java.sql.CallableStatement prepareCall(String sql) throws SQLException {
    
            return prepareCall(sql, DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY);
        }
    	
    	//...
    }
    

    createStatement为例,跟踪其调用代码可以看到StatementImpl这个类就是实现了java.sql.Statement的具体产品类

        public java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
            checkClosed();
    
            StatementImpl stmt = new StatementImpl(getMultiHostSafeProxy(), this.database);
            stmt.setResultSetType(resultSetType);
            stmt.setResultSetConcurrency(resultSetConcurrency);
    
            return stmt;
        }
    
    • mybatis中的SqlSessionFactory
    /**
     * Creates an {@link SqlSession} out of a connection or a DataSource
     * 
     * @author Clinton Begin
     */
    public interface SqlSessionFactory {
    
      SqlSession openSession();
    
      SqlSession openSession(boolean autoCommit);
      SqlSession openSession(Connection connection);
      SqlSession openSession(TransactionIsolationLevel level);
    
      SqlSession openSession(ExecutorType execType);
      SqlSession openSession(ExecutorType execType, boolean autoCommit);
      SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
      SqlSession openSession(ExecutorType execType, Connection connection);
    
      Configuration getConfiguration();
    
    }
    
    

    SqlSessionFactory也是抽象工厂接口,Configuration和SqlSession都是在不同的产品等级上。通过IDEA工具可以通过UML图清晰得看到SqlSessionFactory的工厂实现类

    以上两个例子都和数据库操作相关,同样使用了抽象工厂模式。在jdbc中,客户端通过Connection工厂获取到Statement产品对象,然后通过该对象进行增删改查操作,对于mybatis这种数据库操纵框架而言(底层也是封装了jdbc api)有异曲同工,通过SeqSessionFactory工厂获取到SqlSession产品对象,然后进行增删改查操作

    展开全文
  • 常用设计模式-抽象工厂

    万次阅读 2020-11-19 17:18:48
    模式简介 工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类: 1. 简单工厂模式(Simple Factory) 2. 工厂方法模式(Factory Method) ...在抽象工厂模式中,接口是负责创建一


    模式简介

    工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类:
    1. 简单工厂模式(Simple Factory)
    2. 工厂方法模式(Factory Method)
    3. 抽象工厂模式(Abstract Factory)


    抽象工厂模式,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
    在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

    抽象工厂模式的优点

    抽象工厂模式除了具有工厂方法模式的优点外,最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族,一般或多或少的都存在一定的关联,抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述,而不必专门引入一个新的类来进行管理。

    抽象工厂模式的缺点

    产品族的扩展将是一件十分费力的事情,假如产品族中需要增加一个新的产品,则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时,对产品等级结构的划分是非常重要的。

     

    实际应用场景

    Spring中的BeanFactory


    UML类图

    案例:数据库切换

    IUser
    /**
     * @Author l'amour solitaire
     * @Description 用户表操作
     * @Date 2020/11/19 下午3:13
     **/
    public interface IUser {
    
        /**
         * 新增用户
         **/
        void addUser(User user);
    
    }
    MysqlUser
    /**
     * @Author l'amour solitaire
     * @Description Mysql
     * @Date 2020/11/19 下午3:24
     **/
    public class MysqlUser implements IUser {
    
        @Override
        public void addUser(User user) {
            System.out.println("Mysql 执行了新增用户操作");
        }
    }
    SqlServerUser
    /**
     * @Author l'amour solitaire
     * @Description SqlServer
     * @Date 2020/11/19 下午3:29
     **/
    public class SqlServerUser implements IUser {
    
        @Override
        public void addUser(User user) {
            System.out.println("SqlServer 执行了新增用户操作");
        }
    }
    DataAccess超级工厂
    /**
     * @Author l'amour solitaire
     * @Description 抽象工厂
     * @Date 2020/11/19 下午3:33
     **/
    @Data
    @AllArgsConstructor
    public class DataAccess {
    
        public static final String MYSQL = "Mysql";
        public static final String SQL_SERVER = "SqlServer";
    
        private String DB = "SqlServer";
    
        public IUser createUser() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            String className = String.format("com.aeert.design.abstractfactory.db.%sUser", DB);
            return (IUser) Class.forName(className).newInstance();
        }
    
    }
    

     

    测试

    @SpringBootTest
    class DesignApplicationTests {
    
        @Test
        void test() throws IllegalAccessException, InstantiationException, ClassNotFoundException {
            new DataAccess(DataAccess.MYSQL).createUser().addUser(new User());
            new DataAccess(DataAccess.SQL_SERVER).createUser().addUser(new User());
        }
    
    }

     

    欢迎关注公众号《JAVA拾贝》回复: 设计模式 即可获取

    展开全文
  • 抽象工厂模式

    千次阅读 2019-09-25 20:07:55
    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中,接口是负责...

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

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

    介绍

    意图:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

    主要解决:主要解决接口选择的问题。

    何时使用:系统的产品有多于一个的产品族,而系统只消费其中某一族的产品。

    如何解决:在一个产品族里面,定义多个产品。

    关键代码:在一个工厂里聚合多个同类产品。

    应用实例:工作了,为了参加一些聚会,肯定有两套或多套衣服吧,比如说有商务装(成套,一系列具体产品)、时尚装(成套,一系列具体产品),甚至对于一个家庭来说,可能有商务女装、商务男装、时尚女装、时尚男装,这些也都是成套的,即一系列具体产品。假设一种情况(现实中是不存在的,要不然,没法进入共产主义了,但有利于说明抽象工厂模式),在您的家中,某一个衣柜(具体工厂)只能存放某一种这样的衣服(成套,一系列具体产品),每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解,所有的衣柜(具体工厂)都是衣柜类的(抽象工厂)某一个,而每一件成套的衣服又包括具体的上衣(某一具体产品),裤子(某一具体产品),这些具体的上衣其实也都是上衣(抽象产品),具体的裤子也都是裤子(另一个抽象产品)。

    优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

    缺点:产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。

    使用场景 :1、QQ 换皮肤,一整套一起换。 2、生成不同操作系统的程序。

    注意事项:产品族难扩展,产品等级易扩展。

    实现

    我们将创建 ShapeColor 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactoryColorFactory,这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer

    AbstractFactoryPatternDemo,我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 ShapeCIRCLE / RECTANGLE / SQUARE),以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 ColorRED / GREEN / BLUE),以便获取它所需对象的类型。
    抽象工厂模式

    步骤 1

    为形状创建一个接口。

    Shape.java

    public interface Shape {
        void draw();
    }
    

    步骤 2

    创建实现接口的实体类。

    Rectangle.java

    public class Rectangle implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Rectangle::draw() method.");
        }
    }
    

    Square.java

    public class Square implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Square::draw() method.");
        }
    }
    

    Circle.java

    public class Circle implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Circle::draw() method.");
        }
    }
    

    步骤 3

    为颜色创建一个接口。

    Color.java

    public interface Color {
        void fill();
    }
    

    步骤4

    创建实现接口的实体类。

    Red.java

    public class Red implements Color {
        @Override
        public void fill() {
            System.out.println("Inside Red::fille() method.");
        }
    }
    

    Green.java

    public class Green implements Color {
        @Override
        public void fill() {
            System.out.println("Inside Green::fille() method.");
        }
    }
    

    Blue.java

    public class Blue implements Color {
        @Override
        public void fill() {
            System.out.println("Inside Blue::fille() method.");
        }
    }
    

    步骤 5

    为 Color 和 Shape 对象创建抽象类来获取工厂。

    AbstractFactory.java

    public abstract class AbstractFactory {
        abstract Shape getShape(String shape);
        abstract Color getColor(String color);
    }
    

    步骤 6

    创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象。

    ShapeFactory.java

    public class ShapeFactory extends AbstractFactory {
    
        @Override
        Shape getShape(String shape) {
            if (shape == null) {
                return null;
            }
    
            shape = shape.toLowerCase();
    
            switch (shape) {
                case "circle":
                    return new Circle();
                case "rectangle":
                    return new Rectangle();
                case "square":
                    return new Square();
                default:
                    return null;
            }
    
        }
    
        @Override
        Color getColor(String color) {
            return null;
        }
    
    }
    

    ColorFactory.java

    public class ColorFactory extends AbstractFactory {
    
        @Override
        Shape getShape(String shape) {
            return null;
        }
    
        @Override
        Color getColor(String color) {
            if (color == null) {
                return null;
            }
    
            color = color.toLowerCase();
            switch (color) {
                case "red":
                    return new Red();
                case "blue":
                    return new Blue();
                case "green":
                    return new Green();
                default:
                    return null;
            }
        }
    
    }
    

    步骤 7

    创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。

    FactoryProducer.java

    public class FactoryProducer {
    
        public static AbstractFactory getFactory(String choice) {
            if (choice == null) {
                return null;
            }
    
            if ("shape".equalsIgnoreCase(choice)) {
                return new ShapeFactory();
            } else if ("color".equalsIgnoreCase(choice)) {
                return new ColorFactory();
            } else {
                return null;
            }
        }
    
    }
    

    步骤 8

    使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。

    AbstractFactoryPatternDemo.java

    public class AbstractFactoryDemo {
    
        public static void main(String[] args) {
            //获取形状工厂
            AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
    
            //获取形状为 Circle 的对象
            Shape shape1 = shapeFactory.getShape("CIRCLE");
            //调用 Circle 的 draw 方法
            shape1.draw();
    
            //获取形状为 Rectangle 的对象
            Shape shape2 = shapeFactory.getShape("RECTANGLE");
            //调用 Rectangle 的 draw 方法
            shape2.draw();
    
            //获取形状为 Square 的对象
            Shape shape3 = shapeFactory.getShape("SQUARE");
            shape3.draw();
    
            //获取颜色工厂
            AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
    
            //获取颜色为 Red 的对象
            Color color1 = colorFactory.getColor("RED");
            //调用 Red 的 fill 方法
            color1.fill();
    
            //获取颜色为 Green 的对象
            Color color2 = colorFactory.getColor("Green");
            //调用 Green 的 fill 方法
            color2.fill();
    
            //获取颜色为 Blue 的对象
            Color color3 = colorFactory.getColor("BLUE");
            //调用 Blue 的 fill 方法
            color3.fill();
        }
    
    }
    

    步骤 9

    验证输出。

    Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.
    Inside Red::fill() method.
    Inside Green::fill() method.
    Inside Blue::fill() method.
    
    展开全文
  • 抽象工厂模式概述  抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。抽象工厂模式定义如下:  抽象...

    抽象工厂模式概述

           抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。抽象工厂模式定义如下:

           抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,它是一种对象创建型模式。

           在抽象工厂模式中,每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品,这些产品构成了一个产品族,抽象工厂模式结构如图5所示:



    5  抽象工厂模式结构图

           在抽象工厂模式结构图中包含如下几个角色:

           ● AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品。

           ● ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中。

           ● AbstractProduct(抽象产品):它为每种产品声明接口,在抽象产品中声明了产品所具有的业务方法。

            ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象,实现抽象产品接口中声明的业务方法。

           在抽象工厂中声明了多个工厂方法,用于创建不同类型的产品,抽象工厂可以是接口,也可以是抽象类或者具体类,其典型代码如下所示:

    [java] view plain copy
    1. abstract class AbstractFactory {  
    2. public abstract AbstractProductA createProductA(); //工厂方法一  
    3. public abstract AbstractProductB createProductB(); //工厂方法二  
    4. ……  
    5. }  

           具体工厂实现了抽象工厂,每一个具体的工厂方法可以返回一个特定的产品对象,而同一个具体工厂所创建的产品对象构成了一个产品族。对于每一个具体工厂类,其典型代码如下所示:

    [java] view plain copy
    1. class ConcreteFactory1 extends AbstractFactory {  
    2.     //工厂方法一  
    3. public AbstractProductA createProductA() {  
    4.     return new ConcreteProductA1();  
    5. }  
    6.   
    7. //工厂方法二  
    8. public AbstractProductB createProductB() {  
    9.     return new ConcreteProductB1();  
    10. }  
    11.   
    12. ……  
    13. }  

           与工厂方法模式一样,抽象工厂模式也可为每一种产品提供一组重载的工厂方法,以不同的方式对产品对象进行创建。

    疑问

    思考

           抽象工厂模式是否符合“开闭原则”?【从增加新的产品等级结构和增加新的产品族两方面进行思考。】


    展开全文
  • 大话设计模式(七)抽象工厂模式

    万次阅读 2016-10-09 13:36:27
    大话设计模式(七)抽象工厂模式菜鸟程序员碰到问题,只会用时间来摆平。前言  今天主要讲解抽象工厂模式。抽象工厂模式(Abstract Factory Pattern)是工厂方法模式的进一步抽象,其英文原话”Provide an interface...
  • 工厂模式与抽象工厂模式

    万次阅读 2020-12-25 21:34:30
    抽象工厂模式 核心本质:  实例化对象不使用new,用工厂方法代替  将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。 三种模式: ◆简单工厂模式  用来生产同一等级结构中的任意产品(对于...
  • 简单工厂/工厂方法/抽象工厂

    万次阅读 2020-10-25 22:56:14
    1 简单工厂 根据参数由工厂类来创建对象 /** * 简单工厂 * 目的:根据参数获取对象 * 缺点:新增实现类时,需要修改代码,不好动态扩展(可参考工厂方法) */ public class SimpleFactoryDP { ... //抽象产品
  • 3 抽象工厂模式概述抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。抽象工厂模式定义如下:抽象工厂模式(Abstract Factory ...
  • 抽象工厂模式:我们现在要对mysql/oracle数据库中的User表进行操作,User表定义如下:public class User { private int uid; private String uname; public int getUid() { return uid; } public void set...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,411
精华内容 15,764
关键字:

抽象工厂