精华内容
下载资源
问答
  • 工厂模式的定义:定义一个创建对象的工厂接口,将对象的实际创建工作推迟到具体子工厂类当中。 这满足创建型模式中所要求的“创建与使用相分离”的特点。 按实际业务场景划分,工厂模式有 3 种不同的实现方式,分别...

    工厂模式的定义:定义一个创建对象的工厂接口,将对象的实际创建工作推迟到具体子工厂类当中。

                                 这满足创建型模式中所要求的“创建与使用相分离”的特点。

    按实际业务场景划分,工厂模式有 3 种不同的实现方式,分别是简单工厂模式、工厂方法模式和抽象工厂模式。

    简单工厂模式:一个具体的工厂类,可以生成多个不同的产品对象。简单工厂模式不属于23种设计模式。

                             在简单工厂模式中创建实例的方法通常为静态方法,因此简单工厂模式又叫作静态工厂方法模式。

    简单工厂模式的实现:

    //产品接口
    public interface Tea {
        void show();
    }
    
    //红茶
    public class RedTea implements Tea{
         @Override
         public void show() {
             System.out.println("制作红茶!!!");
         }
    }
    
    //绿茶
    public class GreenTea implements Tea{
        @Override
        public void show() {
            System.out.println("制作绿茶!!!");
        }
    }
    
    //工厂类
    public class SimpleFactory {
        public static Tea makeTea(int type){
            if(type == 1){
                return new RedTea();
            }else if(type ==2){
                return new GreenTea();
            }else{
                System.out.println("制作失败!!!");
                return null;
            }
        }
    }
    
    //测试类
    public class Test {
        public static void main(String[] args) {
            Tea tea = SimpleFactory.makeTea(1);
            tea.show();
        }
    }

    简单工厂模式结构图:

    简单工厂模式的优点:1、工厂类包含必要的逻辑判断,可以决定在什么时候创建哪一个产品的实例。

                                        2、客户端无需知道所创建具体产品的类名,只需知道参数即可。

                                        3、也可以引入配置文件,在不修改客户端代码的情况下更换和添加新的具体产品类。

    简单工厂模式的缺点:1、简单工厂模式的工厂类单一,负责所有产品的创建,职责过重。

                                         2、工厂类代码会非常臃肿,违背高聚合原则。

                                        3、使用简单工厂模式会增加系统中类的个数,增加系统的复杂度和理解难度。

                                        4、系统扩展困难,增加新产品需要修改工厂逻辑,在产品类型较多时,可能造成逻辑过于复杂。

                                        5、简单工厂模式使用了 static 工厂方法,造成工厂角色无法形成基于继承的等级结构。

    工厂方法模式:定义一个创建对象的接口,让实现这个接口的类决定创建哪个对象。

                             工厂方法是对简单工厂的进一步抽象化,可以在不修改原代码的情况下引进新的产品,满足开闭原则。

    工厂方法模式的实现:

    //产品接口
    public interface Tea {
        void make();
    }
    
    //红茶
    public class RedTea implements Tea{
        @Override
        public void make() {
            System.out.println("制作红茶!!!");
        }
    }
    
    //绿茶
    public class GreenTea implements Tea{
        @Override
        public void make() {
            System.out.println("制作绿茶!!!");
        }
    }
    
    //工厂接口
    public interface Factory {
        Tea create();
    }
    
    //红茶工厂
    public class RedTeaFactory implements Factory{
        @Override
        public Tea create() {
            return new RedTea();
        }
    }
    
    //绿茶工厂
    public class GreenTeaFactory implements Factory{
        @Override
        public Tea create() {
            return new GreenTea();
        }
    }
    
    //测试类
    public class FactoryMethodTest {
        public static void main(String[] args) {
            Factory redTeaFactory = new RedTeaFactory();
            Tea redTea = redTeaFactory.create();
            redTea.make();
    
            Factory greenTeaFactory = new GreenTeaFactory();
            Tea greenTea = greenTeaFactory.create();
            greenTea.make();
        }
    }
    

    工厂方法模式结构图:

    工厂方法模式的优点:1、用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程。

                                        2、灵活性增强,对于新产品的创建,只需多写一个相应的工厂类。

                                        3、典型的解耦框架。高层模块只需要知道产品的抽象类,无须关心其他实现类。

    工厂方法模式的缺点:1、类的个数容易过多,增加复杂度。

                                        2、增加了系统的抽象性和理解难度。

                                        3、抽象产品只能生产一种产品。

    抽象工厂模式:为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定对象的具体类就能得到

                             同一产品族的产品。抽象工厂模式是工厂方法模式的升级版,工厂方法模式只生产一个等级的产品,

                             而抽象工厂模式可生产多个等级的产品。

    产品族:同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。

    产品等级:同一种类型的产品称为一个产品等级。

    抽象工厂模式的实现:

    //茶接口
    public interface Tea {
        void make();
    }
    
    //红茶
    public class RedTea implements Tea{
        @Override
        public void make() {
            System.out.println("制作红茶!!!");
        }
    }
    
    //绿茶
    public class GreenTea implements Tea{
        @Override
        public void make() {
            System.out.println("制作绿茶!!!");
        }
    }
    
    //奶接口
    public interface Milk {
        void make();
    }
    
    //牛奶
    public class NiuNai implements Milk{
        @Override
        public void make() {
            System.out.println("制作牛奶!!!");
        }
    }
    
    //羊奶
    public class YangNai implements Milk{
        @Override
        public void make() {
            System.out.println("制作羊奶!!!");
        }
    }
    
    //工厂接口
    public interface Factory {
        Tea create();
    
        Milk produce();
    }
    
    //工厂1
    public class Factory1 implements Factory{
        @Override
        public Tea create() {
            return new RedTea();
        }
    
        @Override
        public Milk produce() {
            return new NiuNai();
        }
    }
    
    //工厂2
    public class Factory2 implements Factory{
        @Override
        public Tea create() {
            return new GreenTea();
        }
    
        @Override
        public Milk produce() {
            return new YangNai();
        }
    }
    
    //测试类
    public class AbstractFactoryTest {
        public static void main(String[] args) {
            Factory factory = new Factory1();
            Tea tea = factory.create();
            Milk milk = factory.produce();
            tea.make();
            milk.make();
        }
    }
    

    抽象工厂模式结构图:

    抽象工厂模式的优点:1、用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程。

                                        2、典型的解耦框架。高层模块只需要知道产品的抽象类,无须关心其他实现类。

                                        3、可以在类的内部对产品族中相关联的多等级产品共同管理。

                                        4、当需要产品族时,抽象工厂可以保证客户端只使用一个工厂。

                                        5、增强了程序的可扩展性,当增加新的产品族时,不需要修改原代码,满足开闭原则。

    抽象工厂模式的缺点:1、在产品族中需要增加新的产品时,所有的工厂类都需要进行修改。

                                        2、增加了系统的抽象性和理解难度。

    展开全文
  • 松耦合 & 简单工厂模式业务封装 假如让你设计一个控制台版的计算器,当你写好后。现在让你设计一个有界面的计算器,你之前所写的代码能直接复用吗?当我们写控制台版的计算器时就应该想到将业务逻辑与界面逻辑分开...

    业务封装 & 紧耦合 vs. 松耦合 & 简单工厂模式

    业务封装

    假如让你设计一个控制台版的计算器,当你写好后。现在让你设计一个有界面的计算器,你之前所写的代码能直接复用吗?当我们写控制台版的计算器时就应该想到将业务逻辑与界面逻辑分开,让它们的耦合度降低,只有分离开才容易达到维护或扩展。

    紧耦合 vs. 松耦合

    如果要在计算器的业务逻辑加上其他操作符运算,能否不影响原来的业务逻辑?这时可以用继承、多态的面向对象思想方法把各种操作符分开不同的类,如果要改动或增加删除某一个操作符,都不会影响其他操作符,这就进一步降低了耦合度。

    简单工厂模式

    比如我们设计好不同操作类,如果让用户来创建这些操作类呢?这时我们可以创建一个简单工厂类。工厂类是整个模式的关键。客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心。包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象。通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的。明确了各自的职责和权利,有利于整个软件体系结构的优化。

    展开全文
  • 抽象工厂(Abstract Factory)模式看起来和前面的工厂方法很相似,只是它使用若干工厂方法(Factory Method)模式。 每个工厂方法模式创建一个不同类型的对象。用户界面当创建一个工厂对象时,要决定将如何使用那个...

    抽象工厂(Abstract Factory)模式看起来和前面的工厂方法很相似,只是它使用若干工厂方法(Factory Method)模式。

    每个工厂方法模式创建一个不同类型的对象。用户界面当创建一个工厂对象时,要决定将如何使用那个工厂创建的所有对象。


    实现各种图形(GUI)的可移植性:创建一个合适于正在使用的GUI的工厂对象,然后它将根据对它发出的对一个菜单、按钮或者滚动条等的请求自动创建合适

    该GUI的项目版本。这样就能够在一个地方隔离从一个GUI转变到另一个GUI的作用。


    //举个例子。假设要创建一个通用的游戏环境,并且希望他能支持不同类型的游戏。

    //a gaming environment
    
    #include <iostream>
    using namespace std;
    
    class Obstacle
    {
    public:
        virtual void action() = 0;
    };
    
    class Player
    {
    public:
        virtual void interactWith(Obstacle*)=0;
    };
    
    class Kitty:public Player
    {
        virtual void interactWith(Obstacle* ob) 
        {   
            cout<< "Kitty has encountered a " ;
            ob->action();
        }   
    };
    
    class KungFuGuy:public Player
    {
        virtual void interactWith(Obstacle* ob) 
        {   
            cout<< "KungFuGuy now battles agsinst  a " ;
            ob->action();
        }   
    };
    
    class Puzzle:public Obstacle
    {
    public:
        void action(){cout << "Puzzle"<<endl;}
    };
    
    class NastyWeapon:public Obstacle
    {
    public:
            void action(){cout << "NastyWeapon"<<endl;}
    };

    //the abstract factory:
    class GameElementFactory
    {
    public:
        virtual Player* makePlayer()=0;
        virtual Obstacle* makeObstacle()=0;
    };
    
    //concrete factories:
    class KittiesAndPuzzles:public GameElementFactory
    {
    public:
        virtual  Player* makePlayer(){return new Kitty;}
        virtual Obstacle* makeObstacle(){return new Puzzle;}
    };
    
    class KillAndDismember:public GameElementFactory
    {
    public:
        virtual  Player* makePlayer(){return new KungFuGuy;}
        virtual Obstacle* makeObstacle(){return new NastyWeapon;}
    };
    
    class GameEnvironment
    {
        GameElementFactory* gef;
        Player* p;
        Obstacle* ob;
    public:
        GameEnvironment(GameElementFactory* factory):gef(factory),p(factory->makePlayer()),ob(factory->makeObstacle()){}
    
        void play() {p->interactWith(ob);}
        ~GameEnvironment()
        {
            delete p;
            delete ob;
            delete gef;
        }
    };
    
    
    int main()
    {
        GameEnvironment g1(new KittiesAndPuzzles) ,g2(new KillAndDismember);
        g1.play();
        g2.play();
    }
    
    在此环境中,Player 对象与Obstacle对象交互,但是Player 和Obstacle 类型依赖于具体的游戏。

    可以选择特定GameElementFactory 来决定游戏的类型,然后GameEnvironment 控制游戏的设置和进行。

    本例中,游戏的设置和进行很简单,但是那些动作(初始条件(initial condition)和状态变化(state change))在很大程度上决定了游戏的结果

    展开全文
  • 线程池封装。代理模式工厂模式

    通过线程池代理类和线程池工厂完成对线程池操作的解耦。
    简单的代理模式和简单的工厂模式

    1.创建一个代理类

    public class ThreadPoolProxy {
        ThreadPoolExecutor  mExecutor;          // 只需创建一次
        int                 mCorePoolSize;
        int                 mMaximumPoolSize;
        long                mKeepAliveTime;
    
        public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
            super();
            mCorePoolSize = corePoolSize;
            mMaximumPoolSize = maximumPoolSize;
            mKeepAliveTime = keepAliveTime;
        }
    
        private ThreadPoolExecutor initThreadPoolExecutor() {//双重检查加锁
            if (mExecutor == null) {
                synchronized (ThreadPoolProxy.class) {
                    if (mExecutor == null) {
                        TimeUnit unit = TimeUnit.MILLISECONDS;
                        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();// 无界队列
                        ThreadFactory threadFactory = Executors.defaultThreadFactory();
                        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();// 丢弃任务并抛出RejectedExecutionException异常。
                        mExecutor = new ThreadPoolExecutor(//
                                mCorePoolSize,// 核心的线程数
                                mMaximumPoolSize,// 最大的线程数
                                mKeepAliveTime, // 保持时间
                                unit, // 保持时间对应的单位
                                workQueue,// 缓存队列/阻塞队列
                                threadFactory, // 线程工厂
                                handler// 异常捕获器
                        );
                    }
                }
            }
            return mExecutor;
        }
    
        /**执行任务*/
        public void execute(Runnable task) {
            initThreadPoolExecutor();
            mExecutor.execute(task);
        }
    
        /**提交任务*/
        public Future<?> submit(Runnable task) {
            initThreadPoolExecutor();
            return mExecutor.submit(task);
        }
    
        /**移除任务*/
        public void removeTask(Runnable task) {
            initThreadPoolExecutor();
            mExecutor.remove(task);
        }
    }

    代理类将线程池单例化。并提供了几个核心的操作方法。属于将线程池构建的放法进行抽取。
    2.创建工厂类

    public class ThreadPoolFactory {
        static ThreadPoolProxy  mNormalPool;
        static ThreadPoolProxy  mDownLoadPool;
    
        /**得到一个普通的线程池*/
        public static ThreadPoolProxy getNormalPool() {
            if (mNormalPool == null) {
                synchronized (ThreadPoolProxy.class) {
                    if (mNormalPool == null) {
                        mNormalPool = new ThreadPoolProxy(5, 5, 3000);
                    }
                }
            }
            return mNormalPool;
        }
        /**得到一个下载的线程池*/
        public static ThreadPoolProxy getDownLoadPool() {
            if (mDownLoadPool == null) {
                synchronized (ThreadPoolProxy.class) {
                    if (mDownLoadPool == null) {
                        mDownLoadPool = new ThreadPoolProxy(3, 3, 3000);
                    }
                }
            }
            return mDownLoadPool;
        }
    }

    3.使用

    ThreadPoolFactory.getDownLoadPool().execute(task);

    希望能对开源框架的封装有一些启发。

    展开全文
  • 轮播图封装工厂模式
  • 由于这段时间比较轻松,于是想到很多的企业网站,新闻网站需要将页面静态化,于是写了个封装类来实现静态文件的生成,思路比较简单,但未完善,网友可根据自己的思路将此类扩展,运用了简单工厂模式,先来看看静态类...
  • 小成是一个刚毕业的大... 小成的注塑厂刚刚起步,推出了三款产品,作为一名程序猿,恰好学习到了简单工厂模式,小成就用代码展现了他的三款产品的生产流程:简单工厂模式介绍: 简单工厂模式,又称为静态工厂方法(St
  • c++ 数据封装模式之一: 简单工厂模式时间:2009-12-03 21:53:06来源:网络 作者:未知 点击:212次// SimpleFactory.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include ...
  • 工厂模式:一个接口封装更多接口//工厂模式 ​ //某类操作接口 interface Sender{    public void Send(); } ​ //实现接口 class MailSender implements Sender{ ​    @Override &...
  • 一、举例 特别喜欢王宝强主演的电视剧“士兵突击”,他那样老实憨厚一根筋,却凭着那份执着,成就了自己的不平凡。 其中有一段,许三多刚调到...联系到设计模式: 抽象类:烟 具体实现类:塔山、红河、春城 工...
  • 设计模式中的策略模式,同时兼容简单工厂模式,商场收银模式,易懂可用。
  • 在项目中,常见的 BaseActivity 的封装就用到了设计模式中的模板方法模式和抽象工厂模式,本文重点介绍模板方法模式是什么、Android源码中如何体现、以及我们在项目中是如何使用封装成BaseActivity的。
  • 工厂方法模式、简单工厂模式、抽象工程模式

    千次阅读 多人点赞 2018-04-07 22:11:06
    工厂设计模式是一种创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 针对的问题:在面向对象编程中,最...
  • 简单工厂模式定义了一个创建对象的类,由这个类来封装实例化对象的行为。它是由一个工厂对象决定创建出哪一种产品类的实例。 简单工厂模式工厂模式中最简单使用的模式。 简单工厂模式的三个角色 Factory(工厂...
  • 二次封装图片第三方框架——简单工厂模式的运用 Android 二次封装网络加载框架 java 代理模式详解 最后的最后,卖一下广告,欢迎大家关注我的微信公众号,扫一扫下方二维码或搜索微信号 stormjun,即可...
  • 工厂模式是一种常见的设计模式,将我们创建对象的行为封装(因为创建对象的行为往往是重复的)然后直接调用工厂所给出的方法创建对象即可。 工厂模式有三种: 1. 简单工厂模式 2. 工厂方法模式 3. 抽象工厂模式 ...
  • 简单工厂模式工厂方法模式和抽象工厂模式都是属于创建型设计模式,这三种创建型模式都不需要知道具体类。我们掌握一种思想,就是在创建一个对象时,需要把容易发生变化的地方给封装起来,来控制变化(哪里变化,...
  • 工厂模式

    2015-04-21 18:41:26
    工厂模式是为了封装抽象产品生成过程先说最简单的工厂模式吧,也就是简单工厂模式。简单工厂模式的基本思路是,使产品都继承于同一超类,或者同一个接口。然后构建工厂类,以后就是用工厂来生成对象而抽象工厂模式则...
  • Android设计模式之Activity基类封装

    千次阅读 2017-05-09 16:37:52
    说到设计模式,反正只要做过开发的就能说出一大堆设计模式,像最常用的单例设计模式工厂设计模式、MVC设计模式等等。但是我们每个人知道这么多设计模式,那么运用的实际开发中的又有多少呢,所以用实践检验真理才...
  • 于是,使用Facade模式和反射技术模拟Hibernate框架技术演示怎样书封装数据库的操作。 环境:Windows XP Professional, JDK 1.6, Eclipse 3.3 Europa, SQL Server 2000 使用步骤: 1. 下载解压之后,使用Eclipse导入...
  • 设计模式(二):几种工厂模式详解

    万次阅读 2020-05-10 21:07:43
    工厂顾名思义就是创建产品,根据产品是具体产品还是具体工厂可分为简单工厂模式工厂方法模式,根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建,是一种创建型模式工厂...
  • 简单工厂模式工厂方法模式和抽象工厂模式的异同  简单工厂模式工厂方法模式和抽象工厂模式都是属于创建型设计模式,这三种创建型模式都不需要知道具体类。我们掌握一种思想,就是在创建一个对象时,需要把容易...
  • 简单工厂,主要用生产对象不能抽象为一个类,或者是面向较小的群体没有必要进行抽象封装。说白了就是通过简单的方法就能搞定,何必要大费周章呢。能见但就简单,在允许的情况下尽可能的简单,方便。工厂方法模式,...
  • 工厂模式,简单的说就是把创建对象的过程封装起来,封装到一个所谓的工厂中。根据封装程度分为:简单工厂模式工厂方法模式、抽象工厂模式。 为了避免文章过于冗长,这篇主要讲解前两种模式,第三种留到下一篇...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 237,914
精华内容 95,165
关键字:

工厂模式进行封装