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

    2015-09-28 19:59:06
    概念 抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,能够创建...抽象工厂模式的核心,包含对多个产品结构的声明,

    概念
    抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,能够创建多个产品族的产品对象。

    工厂模式:要么生产香蕉、要么生产苹果、要么生产西红柿;但是不能同时生产一个产品组。抽象工厂:能同时生产一个产品族。

    模式中包含的角色及其职责

    1. 抽象工厂(Creator)角色
      抽象工厂模式的核心,包含对多个产品结构的声明,任何工厂类都必须实现这个接口。
    2. 具体工厂( Concrete Creator)角色
      具体工厂类是抽象工厂的一个实现,负责实例化某个产品族中的产品对象。
    3. 抽象(Product)角色
      抽象模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。
    4. 具体产品(Concrete Product)角色
      抽象模式所创建的具体实例对象

    这里写图片描述

    案例

    class Fruit
    {
    public:
        virtual void sayname()
        {
            cout<<"fruit\n";
        }
    };
    
    class FruitFactory
    {
    public:
        virtual Fruit* getApple()
        {
            return new Fruit();
        }
        virtual Fruit* getBanana()
        {
            return new Fruit();
        }
    };
    
    //南方香蕉
    class SouthBanana : public Fruit
    {
    public:
        virtual void sayname()
        {
            cout<<"South Banana \n"<<endl;
        }
    };
    
    
    //南方苹果
    class SouthApple : public Fruit
    {
    public:
        virtual void sayname()
        {
            cout<<"South Apple \n"<<endl;
        }
    };
    
    
    //北方香蕉
    class NorthBanana : public Fruit
    {
    public:
        virtual void sayname()
        {
            cout<<"North Banana \n"<<endl;
        }
    };
    
    
    //北方苹果
    class NorthApple : public Fruit
    {
    public:
        virtual void sayname()
        {
            cout<<"North Apple \n"<<endl;
        }
    };
    
    class SourthFruitFactory : public FruitFactory
    {
    public:
        virtual Fruit* getApple()
        {
            return new SouthApple();
        }
        virtual Fruit* getBanana()
        {
            return new SouthBanana();
        }
    };
    
    class NorthFruitFactory : public FruitFactory
    {
    public:
        virtual Fruit* getApple()
        {
            return new NorthApple();
        }
        virtual Fruit* getBanana()
        {
            return new NorthBanana();
        }
    };
    
    void main()
    {   
        FruitFactory * ff  = NULL;
        Fruit *fruit = NULL;
    
        ff = new SourthFruitFactory();
        fruit = ff->getApple();
        fruit->sayname();
        fruit = ff->getBanana();
        fruit->sayname();
    
        delete fruit;
        delete ff;
    
        ff = new NorthFruitFactory();
        fruit = ff->getApple();
        fruit->sayname();
        fruit = ff->getBanana();
        fruit->sayname();
    
        delete fruit;
        delete ff;
    
        cout<<"hello....\n";
        system("pause");
    }
    
    展开全文
  • 抽象工厂模式

    2014-09-17 11:49:53
    前面我们介绍了简单工厂,工厂方法模式,这节来看看抽象工厂模式,抽象工厂模式(Abstract Factory)是工厂方法里面最为抽象和最具一般性的形态,是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向...

    前面我们介绍了简单工厂,工厂方法模式,这节来看看抽象工厂模式,抽象工厂模式(Abstract Factory)是工厂方法里面最为抽象和最具一般性的形态,是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象。抽象工厂模式和工厂方法模式的最大区别在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则需要面对多个产品族,从而使得产品具有二维性质。抽象工厂模式的一般示意类图如下:


    下面我们先看抽象工厂的角色都有哪些:
    抽象工厂(Creator)角色:是抽象工厂模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
    具体工厂(Concrete Creator)角色:这是实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建产品对象。
    抽象产品(Product)角色:工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。
    具体产品(Concrete Product)角色:这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建,它们之间往往一一对应。

    如果你很留心,你就发现 抽象工厂的角色和工厂方法的角色一样,其实抽象工厂就是在工厂方法的基础上进一步推广
    下面我们来举实例说明,我们还是延续车的例子,我们说我们原有的造车厂扩建,分东北重工厂和华北机械厂,这两个厂都可以造拖拉机,汽车,火车,但是他们在工艺和品牌上都有所不同,我们抽象出以下模型:

     
    通过上图,我们可以看出,我们系统模型中有个两个产品族,一个产品族是东北重工厂产出的所有产品,另一个产品族是华北机械厂生产出的所有产品。我们也可以看出有多少个实现工厂就有多少个产品族,在工厂角色中有多少工厂方法在同一个产品族类就有多少个具体产品。 
    展开全文
  • JAVA抽象工厂模式

    千次阅读 2016-04-23 16:56:59
    1.抽象工厂模式概念 抽象工厂模式是常用的创建模式之一。 定义:为创建一组相关或相互依赖的对象提供一个借口,无需指定它们的具体类。 核心: 特点:  (1)抽象工厂模式式工厂方法模式的进一步抽象,针对的是一族...

    1.抽象工厂模式概念

    抽象工厂模式是常用的创建模式之一。
    定义: 为创建一组相关或相互依赖的对象提供一个借口,无需指定它们的具体类。
    特点:
             (1)抽象工厂模式式工厂方法模式的进一步抽象,针对的是一族产品。每一个模式都是针对一定问题的解决方案,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式针对的是多个产品等级结构。
             (2)可用来生产不同产品族的全部产品。
             (3)实现了创建者和调用者的分离。
    适用情况:
           1. 一个系统要独立于它的产品的创建、组合和表示时。

           2.一个系统要由多个产品系列中的一个来配置时。

           3. 需要强调一系列相关的产品对象的设计以便进行联合使用时。

           4.提供一个产品类库,而只想显示它们的接口而不是实现时。

              它也是由四种角色组成,与工厂方法模式的角色类似(关系见下面的类图):抽象工厂(Creator)角色,具体工厂(Concrete Creator)角色抽象产品(Product)角色,具体产品(Concrete Product)角色,这里不重复了大家如果想了解可以看工厂方法模式关于角色的介绍,哈哈偷一下懒,下面我们就来看看抽象工厂模式吧,实例比理论来到更直白,最好看一下UML图先

    2.UML图(图比较大,浏览器看的话,拖一下下角的拉条)


    3.具体实例

    这里我用一个经典更直白的例子吧,可能大家之前也看过,不过觉得它挺清晰的(个人感觉)。

    (1)抽象工厂角色:AbstractFactory接口

    public interface AbstractFactory {
        //创建产品A
    	public ProductA factoryA();
        //创建产品B
    	public ProductB factoryB();
    	//更多创建产品.....
    }

    (2)具体工厂角色:

    具体工厂ConcreteFactory1类ConcreteFactory2类实现AastractFactory,用于创建相应的产品对象。
    等级为1的族产品:ConcreteFactory1类
    public class ConcreateFactory1 implements AbstractFactory {
    	//建造者
    	@Override
    	public ProductA factoryA() {
    		//生产等级为1的产品A,即A1
    		return new ProductA1();
    	}
    
    	@Override
    	public ProductB factoryB() {
    	    //生产等级为1的产品B,即B1
    		return new ProductB1();
    	}
        //更多代码逻辑......
    }
    等级为2的族产品:ConcreteFactory2类
    public class ConcreateFactory2 implements AbstractFactory {
    	@Override
    	public ProductA factoryA() {
    		//生产等级为2的产品A,即A2
    		return new ProductA2();
    	}
    	@Override
    	public ProductB factoryB() {
    	    //生产等级为2的产品B,即B2
    		return new ProductB2();
    	}
        //更多代码逻辑......
    }
    

    (3)抽象产品角色:

    抽象产品:ProductA接口
    public interface ProductA{
            //产品A公共方法
    	    public void method1();  
    	    public void method2();  
    	   //更多产品逻辑.....
    }<span style="color:#ff0000;">
    </span>
    抽象产品:ProductB接口
    public interface ProductB{
        //产品B公共方法
        public void method1();  
        public void method2();  
       //更多产品逻辑.....
    }

    (4)具体产品角色:

     具体产品A:

    产品A的两个具体产品 ProductA1ProductA2实现ProductA接口。
    具体产品A1:
    public class ProductA1 implements ProductA {
        //等级为1的产品A
    	@Override
    	public void method1() {
    		 System.out.println("等级为1的产品A的实现方法");
    	}
    	@Override
    	public void method2() {
    		//业务逻辑处理代码
    	}
    	//更多产品逻辑.....
    }
    具体产品A2:
    public class ProductA2 implements ProductA {
        //等级为2的产品A
    	@Override
    	public void method1() {
    		 System.out.println("等级为2的产品A的实现方法");
    	}
    	@Override
    	public void method2() {
    		//业务逻辑处理代码
    	}
    	//更多产品逻辑.....
    }

     具体产品B:

    产品B的两个具体产品ProductB1ProductB2实现ProductB接口。
    具体产品B1:
    public class ProductB1 implements ProductB {
        //等级为1的产品B
    	@Override
    	public void method1() {
    		 System.out.println("等级为1的产品B的实现方法");
    	}
    	@Override
    	public void method2() {
    		//业务逻辑处理代码
    	}
    	//更多产品逻辑.....
    }
    具体产品B2:
    public class ProductB2 implements ProductB {
        //等级为2的产品B
    	@Override
    	public void method1() {
    		 System.out.println("等级为2的产品B的实现方法");
    	}
    	@Override
    	public void method2() {
    		//业务逻辑处理代码
    	}
    	//更多产品逻辑.....
    }
    

    测试类:

    public class ClientAbstractFatory {
    	//客户端--调用者
         public static void main(String[] args) {
        	 //定义两个工厂,等级为1和等级为2
    		ConcreateFactory1 factory1=new ConcreateFactory1();
    		ConcreateFactory2 factory2=new ConcreateFactory2();
    		//定义A产品的不同系列产品
    		ProductA a1=factory1.factoryA();
    		ProductA a2=factory2.factoryA();
    		//定义A产品的不同系列产品
    	    ProductB b1=factory1.factoryB();
    		ProductB b2=factory2.factoryB();
    		//业务逻辑
    		a1.method1();
    		b1.method1();
    		a2.method1();
    		b2.method1();
    		//更多业务逻辑....
    	}
    }
    
    结果显示:
    等级为1的产品A的实现方法
    等级为1的产品B的实现方法
    等级为2的产品A的实现方法
    等级为2的产品B的实现方法

    4.小结

    抽象工厂的优点:

    • 具体产品从客户代码中被分离出来
    • 容易改变产品的系列
    • 将一个系列的产品族统一到一起创建

      抽象工厂的缺点:

      对于新增加的产品,无能为力,支持增加产品族, 在产品族中扩展新的产品是很困难的,它需要修改抽象工厂的接口
    PS:今天又周末了,时间过得真快,java模式有23个,总结,总结着,自己的进度真慢,真有点总结不下去了,最近的课程,也比较多,感觉时间不够用,不过写这个也挺好的,至少不会迷茫,算了,不BB了,雨后会有彩虹,睡个午觉先。






    展开全文
  • 设计模式——抽象工厂模式

    千次阅读 2018-04-06 17:11:06
    抽象工厂是对工厂模式的进一步抽象,可以说工厂生产的是对象,而抽象工厂生产的是工厂,比起工厂模式多了一个产品族的概念。...和工厂模式一样涉及到四个角色:抽象工厂角色:这是工厂方法模式的核心,它与...

    抽象工厂是对工厂模式的进一步抽象,可以说工厂生产的是对象,而抽象工厂生产的是工厂,比起工厂模式多了一个产品族的概念。产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。例如软件中选择MySql+PHP可以是一个产品,而选择MSSQL+.NET也是一种产品,这两者就是产品族的概念,不再单单是语言或者数据库(个人理解)。

    和工厂模式一样涉及到四个角色:

    抽象工厂角色:这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。

    具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

    抽象产品角色:它是具体产品继承的父类或者是实现的接口。

    具体产品角色:具体工厂角色所创建的对象就是此角色的实例。

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

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

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

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

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

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

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

    下边写一个关于数据库和语言选择的抽象工厂:

    <?php
    
    //创建第一个抽象类
    abstract class  DbConnection{
       abstract public function Connection();
    }
    
    //创建继承抽象类的实体类MSSQL/MySql/Oracle
    class MSSqlConnection extends DbConnection{
        function Connection()
         {
             echo 'MSSql Connection.';     
         }    
    }
    
    class MySqlConnection extends DbConnection{
        function Connection()
        {
            echo 'MySql Connection.';
        }
    }
    
    class OracleConnection extends DbConnection{
        function Connection()
        {
            echo 'Oracle Connection.';
        }
    }
    
    
    //创建第二个抽象类
    abstract class Language{
        abstract function LanguageType();
    }
    
    
    //创建继承抽象类的实体类PHP/NET/Java
    class PHP extends Language{
        function LanguageType()
        {
            echo 'PHP Program.';
        }
    }
    
    class NET extends Language{
        function LanguageType()
        {
            echo 'NET Program.';
        }
    }
    
    class Java extends Language{
        function LanguageType()
        {
            echo 'Java Program.';
        }
    }
    
    //对象创建抽象工厂,里边包含两个抽象对象的方法。
    abstract class ProgramFactory{
             abstract function GetDataBase();
             abstract function GetLanguage();
    }
    
    //实现工厂,生成基于给定信息的实体类的对象微软/开源/甲骨文
    class MicrosoftFactory extends ProgramFactory{
        public function GetDataBase()
        {
            return new MSSqlConnection(); 
        }    
        
        public function GetLanguage()
        {
            return new NET();
        }
    }
    
    class OpensourceFactory extends ProgramFactory{
        public function GetDataBase()
        {
            return new MySqlConnection();
        }
    
        public function GetLanguage()
        {
            return new PHP();
        }
    }
    
    
    class OracleFactory extends ProgramFactory{
        public function GetDataBase()
        {
            return new OracleConnection();
        }
    
        public function GetLanguage()
        {
            return new Java();
        }
    }
    
    
    //根据不同的工厂,生成不同的对象
    $Factory = new OracleFactory();
    $Factory->GetDataBase()->Connection();
    $Factory->GetLanguage()->LanguageType();
    
    ?>

    展开全文
  • 抽象工厂模式(Abstract Factory)  抽象出来一个基础接口定义了产品功能(对应抽象产品角色),每个实现此接口的子类就是具体产品(对应具体产品角色),然后定义一个工厂接口(对应抽象工厂角色),实现了工厂接口的...
  •  Sunny公司开发人员使用抽象工厂模式来重构界面皮肤库的设计,其基本结构如图6所示: 图6 界面皮肤库结构图  在图6中,SkinFactory接口充当抽象工厂,其子类SpringSkinFactory和SummerSkinFactory充当具体...
  •  2.1 抽象工厂(AbstractFactory):担任这个角色的是工厂方法模式的核心,它是与应用系统商业逻辑无关的。  2.2 具体工厂(ConcreteFactory):这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择...
  • 设计模式之抽象工厂

    2017-11-14 10:56:29
    概念: 抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向... 抽象工厂模式的核心,包含对多个产品结构的声明,任何工厂类都必须实现这个接口。 具体工厂( Concrete Creator)角色
  • 工厂方法模式的核心抽象工厂类Factory,各种具体工厂类继承抽象工厂类并实现在抽象工厂类中定义的工厂方法,从而让客户只关心抽象产品和抽象工厂,不用管具体返回的是哪一种具体产品,也不用关心它是如何被具体工厂...
  • 工厂模式与抽象工厂模式

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

    万次阅读 2016-05-19 19:40:32
    一、什么是抽象工厂模式 二、模式中包含的角色及其职责 三、抽象工厂模式的优缺点 一、什么是抽象工厂模式 抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的。抽象工厂模式可以向客户端提供一个接口,...
  • (三)抽象工厂模式

    2014-01-30 16:17:08
    抽象工厂模式 一、什么是抽象工厂模式 抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口,使得...抽象工厂模式的核心,包含对多个产品结构的声明,任何工厂类都
  • 3.抽象工厂模式

    千次阅读 2014-09-05 00:36:19
    1抽象工厂模式的核心内容是: A:消费者不同,可以任意创建 B:操作不同 C:根据不同的工厂创建不同的消费者和相应的操作。 2抽象工厂模式的作用:不同的人,不同的操作,通过工厂来满足这不同的人和创建不同的...
  • 工厂方法模式与抽象工厂模式

    千次阅读 2015-02-13 22:45:16
    抽象工厂模式与工厂方法模式的区别  可以这么说,工厂方法模式是一种极端情况的抽象工厂模式,而抽象工厂模式可以看成是工厂方法模式的一种推广。 (1)、其实工厂方法模式是用来创建一个产品的等级结构的,而抽象...
  • 文章目录抽象工厂抽象工厂的优点抽象工厂的缺点 抽象工厂 提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。 抽象工厂模式比工厂模式更为复杂,就像上面提到的缺点一样,工厂模式和简单工厂...
  • 工厂模式三部曲-抽象工厂模式

    千次阅读 2016-05-29 00:11:11
    工厂模式三部曲-抽象工厂模式 什么是抽象工厂模式 简单了解一下 按照惯例,我们先了解一下什么是抽象工厂模式。抽象工厂模式和工厂方法模式很相似,但是抽象工厂模式将抽象发挥的更加极致,是三种...
  • 工厂方法模式的核心是一个抽象工厂类,而简单工厂模式把核心放到了一个具体类上. 简单工厂是工厂方法模式的特例。 工厂方法模式和抽象工厂模式的最主要的区别在于对工厂的抽象程度上。 抽象工厂模式中一般是抽象出...
  • 设计模式之抽象工厂模式

    千次阅读 2013-11-18 23:08:32
    继续沿着前一篇文章的思路,我们在工厂方法模式中提到:为了增加新产品同时避免对整个系统产生影响,我们提出了将工厂类抽象化的方法。...抽象工厂模式包括四种角色,抽象工厂角色、具体工厂角色、抽象产品角色、具体产

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,910
精华内容 31,564
关键字:

抽象工厂核心