精华内容
下载资源
问答
  • Java 工厂模式

    万次阅读 多人点赞 2020-03-26 14:06:10
    Java 简单工厂模式


    小故事引入

    自上篇继续讲故事

    学姐要带我去吃饭,并且还要帮我找酒店,心里莫名其妙的爽快!哦,天哪,桃花运?

    我便答应了学姐,和她一起去吃饭。大概晚上七点半左右,学姐给我打电话了,让我出去吃饭,我刚收拾完东西,下宿舍楼,就觉得天气有点不好!阴沉沉的,哪里管得了那么多,便去找学姐了。

    “嗨!我在这儿…”,原来学姐已经在校门口等我了!接着我们俩像小兔子似的,走了出去,这一路上,学姐给我讲了许多关于她的事!她原来姓汪,别人都叫她铁锤妹妹,她还有很多好朋友,有记得诚扬帆向海小兔神 我们彼此了解,她知道我叫 程忆难

    “你看,那里有家西餐厅,我们去那里吧!”,我说道,我们便进去这家西餐厅,点了两份牛排,喝点红酒什么的!吃完饭后,唉,真是天公不作美,突然下起了雨,我们便一起坐着等雨停下,一直等到晚上十点,可是,老天爷似乎没有罢休!我说:“就在对面就有家酒店,我们一起先过去吧!”,我和学姐便一起奔跑过去,一路上感觉没有淋多少雨,但是我们俩已经从上到下湿透了!更倒霉的是,现在只剩下一间房了!我俩只能委屈一下了,将就一晚上!“咦!啊-----,怎么是一张大床?”,我的天!学姐低声说道:“没关系!先这样吧,我要先去洗澡了,你待会儿帮我把衣服晾一下!”!

    学姐走进了洗浴间,开门对我说,帮我把衣服晾起来,我还没来得及反应,直接把衣服递给了我,紧接着听到了水落到肌肤、地上的声音。帮她晾好衣服后,坐在椅子上,好难受!全身湿透了,真的很不舒服… …

    "喂该你了!"这一次,我又呆住了,披着浴巾的学姐更加有诱惑力,学姐说我好奇怪,更气人的是,最近上火,突然流鼻血了!此时此刻,我也不知如何是好,往洗澡间跑去…

    我洗完澡后,学姐说:“帮我吹下头发吧,我头发还没有干!”我便坐到床边,帮学姐吹起了头发,学姐温润的体香里,夹杂着我的好奇!吹完头发后,我问学姐为什么对我这么好!她说:“不告诉你,关灯睡觉吧”…

    可是,被子只有一条,我对学姐说:“你盖吧,晚上应该不冷!”,学姐点点头。我们俩便在床边躺下,漆黑的夜里夹杂着一丝丝尴尬的气氛!忽然有点凉,我突然好冷,我对学姐说:“我能盖点被子吗?有点冷”,“嗯,可以!”。她便把被子给我盖上,并且抱住了我…

    下一篇故事,此处变颜色 Java 建造者模式——学姐夸我的“手法”很好很专业,学姐感到很是欣慰和愉悦…让你以最难忘的例子记住建造者模式》!!!请订阅我的专栏!!!


    漂亮学姐的 Java 简单工厂模式

    故事中提到,学姐和学弟共进晚餐,帮学弟找酒店,这些都是学姐的想法!
    都是要帮助学弟,创建这个帮手接口:

    /**
     * 学姐的简单工厂助手
     */
    public interface SisterHelper {
    
        /**
         * 学姐帮助学弟
         */
        void helpBrother();
    
    
    }
    
    

    再来创建两个类帮助学弟的类:

    • 学姐和程忆难共进晚餐类
    /**
     * 学姐和学弟一起吃晚饭
     */
    public class EatDinner implements SisterHelper {
    
        @Override
        public void helpBrother() {
            System.out.println("学姐 和 学弟程忆难 吃晚饭");
        }
    }
    
    
    • 学姐帮程忆难找酒店类
    /**
     * 学姐帮学弟找酒店
     */
    public class FindHotel implements SisterHelper {
        
        @Override
        public void helpBrother() {
            System.out.println("学姐 帮 学弟程忆难 找酒店");
        }
    }
    
    

    创建好了,接下来我们要构建学姐的小脑袋瓜,让学姐做出判断:

    /**
     * 学姐的糊涂小脑袋瓜在想什么?
     * 想和学弟共进晚餐?
     * 想帮学弟找酒店?
     */
    public class BeautifulSisterFactory {
    
        public SisterHelper helpBrother(String help) {
            switch (help) {
                case "eatDinner":
                    return new EatDinner();
                case "findHotel":
                    return new FindHotel();
            }
    
            return null;
        }
    
    }
    
    

    好了,接下来我们来实现学姐的作为:

    
    /**
     * 学姐的简单工厂
     *
     * @author CSDN程忆难
     * @link https://myhub.blog.csdn.net
     */
    public class Simple {
    
        public static void main(String[] args) {
    
            //初始化学姐的小脑袋瓜
            BeautifulSisterFactory beautifulSisterFactory = new BeautifulSisterFactory();
    
            //学姐和学弟程忆难共进晚餐
            beautifulSisterFactory.helpBrother("eatDinner").helpBrother();
    
            //学姐帮学弟找酒店
            beautifulSisterFactory.helpBrother("findHotel").helpBrother();
    
        }
    }
    
    

    现在的程序结构是这样的:
    在这里插入图片描述

    运行看下结果:
    在这里插入图片描述
    可以看到,学姐和学弟发生了了两件事!但是学姐和学弟发生的不只是这两件事,还有和学弟一起等雨、一起在雨中奔跑…

    难道还要接着写判断和创建帮学弟的类吗?这显然很麻烦!解耦性不高!请继续往下看!


    漂亮学姐的 Java 工厂方法模式

    一想法,一作为,先想和学弟一起吃晚饭,接下来行动实现和学弟一起吃晚饭,和学弟找酒店亦是如此!先想再做和实现!

    首先写好学姐具体的作为:

    /**
     * 学姐要给学弟做的事情
     */
    abstract class SisterIdea {
    
        public SisterIdea() {
    
        }
    }
    
    /**
     * 实现小想法:学姐和学弟共进晚餐
     */
    class EatDinner extends SisterIdea {
    
        public EatDinner() {
            System.out.println("学姐 和 学弟程忆难 共进晚餐");
        }
    }
    
    /**
     * 实现小想法:学姐帮学弟找酒店
     */
    class FindHotel extends SisterIdea {
        public FindHotel() {
            System.out.println("学姐 帮 学弟程忆难 找酒店");
        }
    }
    
    /**
     * 实现小想法:学姐和学弟在雨中奔跑
     */
    class Running extends SisterIdea {
        public Running() {
            System.out.println("学姐 和 学弟程忆难 在雨中奔跑");
        }
    }
    

    之后写出学姐的小心思、小想法!

    /**
     * 学姐的小脑袋瓜
     */
    interface SisterBrain {
        SisterIdea createIdea();
    }
    
    /**
     * 学姐的小想法:和学弟共进晚餐
     */
    class IdeaEatDinner implements SisterBrain {
        @Override
        public EatDinner createIdea() {
            return new EatDinner();
        }
    }
    
    /**
     * 学姐的小想法:帮学弟找酒店
     */
    class IdeaFindHotel implements SisterBrain {
    
        @Override
        public FindHotel createIdea() {
            return new FindHotel();
        }
    }
    
    /**
     * 学姐的小想法:和学弟一起在雨中奔跑
     */
    class IdeaRunning implements SisterBrain {
    
        @Override
        public Running createIdea() {
            return new Running();
        }
    }
    

    接下来学姐要实现她的小想法

    
    /**
     * 学姐的工厂方法
     *
     * @author CSDN程忆难
     * @link https://myhub.blog.csdn.net
     */
    public class Simple {
    
        public static void main(String[] args) {
    
            //初始化学姐想和学弟共进晚餐的小想法
            IdeaEatDinner ideaEatDinner = new IdeaEatDinner();
    
            //实现学姐的小想法
            ideaEatDinner.createIdea();
    
            //======================================================
    
            //初始化学姐想帮学弟找酒店的小想法
            IdeaFindHotel ideaFindHotel = new IdeaFindHotel();
    
            //实现学姐的小想法
            ideaFindHotel.createIdea();
    
            //======================================================
    
            //初始化学姐想和学弟在雨中奔跑的小想法
            IdeaRunning ideaRunning = new IdeaRunning();
    
            //实现学姐的小想法
            ideaRunning.createIdea();
    
        }
    }
    

    现在结构是这样的:

    在这里插入图片描述

    运行起来看一下:
    在这里插入图片描述
    现在,学姐只要多一个想法,便写一个方法和一个实现!

    随着学姐对学弟的好感度提高!学弟可能猜到了学姐不同的想法!请往下看!


    漂亮学姐的 Java 抽象工厂模式

    构建学姐的大脑,学弟看到学姐或了解到学姐什么,会做出什么反应?

    /**
     * 构建学弟的大脑(工厂)
     * 大脑来构建想法
     */
    public interface MyBrain {
    
        public MyIdea getIdea();
    
    }
    
    class UnderstandSister implements MyBrain {
    
        @Override
        public MyIdea getIdea() {
            System.out.println("学姐 让 学弟了解她");
            return new Kindly();
        }
    }
    
    class TowelSister implements MyBrain {
    
        @Override
        public MyIdea getIdea() {
            System.out.println("学姐 让 学弟 看到了她披着浴巾");
            return new Beautiful();
        }
    }
    
    

    构建学弟的想法,看到或了解学姐后,学弟会认为什么?

    /**
     * 学弟的想法
     */
    public interface MyIdea {
        public void think();
    }
    
    /**
     * 学弟想到了学姐很和蔼
     */
    class Kindly implements MyIdea {
    
        @Override
        public void think() {
            System.out.println("学弟 想到了 学姐 很和蔼");
        }
    }
    
    /**
     * 学弟想到了学姐很漂亮
     */
    class Beautiful implements MyIdea {
    
        @Override
        public void think() {
            System.out.println("学弟 想到了 学姐 很漂亮");
        }
    }
    

    接下来,完成这一过程,来运行

    
    /**
     * 学姐的抽象工厂
     *
     * @author CSDN程忆难
     * @link https://myhub.blog.csdn.net
     */
    public class Abstract {
    
        public static void main(String[] args) {
    
            //构建学弟的大脑 让学弟了解学姐
            MyBrain myBrain1 = new UnderstandSister();
    
            //了解后 学弟的大脑做出处理
            MyIdea idea1 = myBrain1.getIdea();
    
            //然后学弟认为学姐很和蔼
            idea1.think();
    
            System.out.println("===================================");
    
            //构建学弟的大脑 让学弟看到了学姐披着浴巾
            MyBrain myBrain2 = new TowelSister();
    
            //看到后 学弟的大脑做出处理
            MyIdea idea2 = myBrain2.getIdea();
    
            //然后学弟认为学姐很漂亮
            idea2.think();
    
        }
    }
    

    结构是这样的
    在这里插入图片描述


    看到运行结果
    在这里插入图片描述

    学姐对学弟的好感度提升了!!!!!!!!!

    展开全文
  • Java工厂模式

    2020-05-11 14:16:45
    Java工厂模式简介一、简单工厂模式二、工厂方法模式三、抽象工厂模式 简介 Java工厂模式大体分为简单工厂、工厂方法、抽象工厂等三种模式。工厂方法模式也可称为工厂模式,与抽象模式都是属于23种设计模式中的之一。...

    简介

    Java工厂模式大体分为简单工厂、工厂方法、抽象工厂等三种模式。工厂方法模式也可称为工厂模式,与抽象模式都是属于23种设计模式中的之一。简单工厂进阶变成了工厂方法,然后再进阶成了抽象工厂。难度逐步增加,也越来越抽象。

    一、简单工厂模式

    一个栗子:
    我喜欢吃面食,抽象一个面食基类,(接口也可以),这是产品的抽象类。

    public abstract class pasta {
        /**
         * 描述每种面食啥样的
         */
        public abstract void desc();
    }
    

    先来一份韭菜饺子(具体的产品类):

    public class Leeks extends pasta {
        @Override
        public void desc() {
            System.out.println("味道有点大!");
        }
    }
    

    营养的虾仁饺子(具体的产品类):

    public class Shrimp extends pasta {
        @Override
        public void desc() {
            System.out.println("味道好极了!");
        }
    }
    

    菜单如下:

    public class SimpleFactory {
        public static final int TYPE_L = 1;//韭菜
        public static final int TYPE_S = 2;//虾仁
    
        public static Dumplings create(int type) {
            switch (type) {
                case TYPE_Leeks:
                    return new Leeks();
                case TYPE_Shrimp:
                    return new Shrimp();
            }
        }
    }
    

    来到面馆,点了一份虾仁的:

    pasta simple = SimpleFactory.create(SimpleFactory.TYPE_S);
     simple.desc();
    

    输出:

    味道好极了!
    

    优点:将创建使用工作分开,不必关心类对象如何创建,实现了解耦;
    缺点:违背“开放 - 关闭原则”,一旦添加新产品就不得不修改工厂类的逻辑,这样就会造成工厂逻辑过于复杂。

    二、工厂方法模式

    又称工厂模式、多态工厂模式和虚拟构造器模式,通过定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象。一种常用的对象创建型设计模式,此模式的核心精神是封装 类中不变的部分。

    举个简单易懂的例子:
    产品:还是上边的饺子
    工厂:Factory.java、FactoryL.java 、FactoryS.java
    Factory.java

    abstract class Factory {
        //生产产品
        abstract Product makeDumplings();
    }
    

    FactoryL.java

    public class FactoryL extends Factory{
        @Override
        Product makeDumplings() {
            return new Leeks();
        }
    }
    

    FactoryS.java

    public class FactoryS extends Factory{
        @Override
        Product makeDumplings() {
            return new Shrimp();
        }
    }
    

    测试:Test.java

    public class Test {
        public static void main(String[] args) {
            //创建具体的工厂
            FactoryL factoryL = new FactoryL();
            //生产相对应的产品
            factoryA.makeDumplings().desc();
            FactoryS factoryS = new FactoryS();
            factoryS.makeDumplings().desc();
        }
    }
    

    优点:
    1.符合开-闭原则:新增一种产品时,只需要增加相应的具体产品类和相应的工厂子类即可
    2.符合单一职责原则:每个具体工厂类只负责创建对应的产品

    缺点:
    1.增加了系统的复杂度:类的个数将成对增加
    2.增加了系统的抽象性和理解难度
    3.一个具体工厂只能创建一种具体产品

    三、抽象工厂模式

    提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类;具体的工厂负责实现具体的产品实例。
    Factory.java(抽象工厂)

    abstract class Factory {
        //生产饺子
        abstract Factory getDumplings();
        //生产面条
        abstract Factory getNoodles();
    }
    

    FactoryD.java(抽象饺子工厂)

    abstract class FactoryD extends Factory{
         @Override
        abstract void intro();
    }
    

    FactoryN.java(抽象面条工厂)

    abstract class FactoryN extends Factory{
         @Override
        abstract void intro();
    }
    

    Dumplings.java(具体的面条工厂)

    public  class Dumplings extends FactoryD{
        @Override
        void intro() {
            System.out.println("牛肉饺子");
        }
    }
    

    Noodles.java(具体的面条工厂)

    public  class Noodles extends FactoryN{
        @Override
        void intro() {
            System.out.println("三鲜面");
        }
    }
    

    饭店:

    public class Restaurant extends Factory{
        @Override
        Product getDumplings() {
            //生产饺子
            return new Dumplings();
        }
        @Override
        Product getNoodles() {
            //生产面条
            return new Noodles();
        }
    }
    

    Test.java

    public class Test {
        public static void main(String[] args) {
            
            Restaurant restaurant = new Restaurant();
            restaurant.getDumplings().intro();
            restaurant.getNoodles().intro();
        }
    }
    

    优点:
    1.降低耦合
    2.符合开-闭原则
    3.符合单一职责原则
    4.不使用静态工厂方法,可以形成基于继承的等级结构。

    缺点:难以扩展新种类产品

    展开全文
  • java 工厂模式

    2019-08-04 20:55:46
    Java工厂模式 看了这么多关于工厂模式的讲解,还是觉得这篇文章讲的好理解,贴出来和大家分享分享。 一、引子 话说十年前,有一个****户,他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪,还雇了司机为他开车。不过...

    今天看了一篇文章,是讲java的开发模式
    于是转载了一下
    Java工厂模式
    看了这么多关于工厂模式的讲解,还是觉得这篇文章讲的好理解,贴出来和大家分享分享。
    一、引子
    话说十年前,有一个****户,他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪,还雇了司机为他开车。不过,户坐车时总是怪怪的:上Benz车后跟司机说“开奔驰车!”,坐上Bmw后他说“开宝马车!”,坐上Audi说“开奥迪车!”。你一定说:这人有病!直接说开车不就行了?!
    而当把这个
    户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象。幸运的是,这种有病的现象在OO(面向对象)语言中可以避免了。下面就以Java语言为基础来引入我们本文的主题:工厂模式。

    二、分类
    工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。

    工厂模式在《Java与模式》中分为三类:
    1)简单工厂模式(Simple Factory)

    2)工厂方法模式(Factory Method)

    3)抽象工厂模式(Abstract Factory)
    这三种模式从上到下逐步抽象,并且更具一般性。
    GOF在《设计模式》一书中将工厂模式分为两类:工厂方法模式(FactoryMethod)与抽象工厂模式(Abstract Factory)。将简单工厂模式(SimpleFactory)看为工厂方法模式的一种特例,两者归为一类。

    两者皆可,在本文使用《Java与模式》的分类方法。下面来看看这些工厂模式是怎么来“治病”的。

    三、简单工厂模式

    简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。
    先来看看它的组成:

         1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。 
    
         2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。 
    
         3) 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 
    

    那么简单工厂模式怎么来使用呢?我们就以简单工厂模式来改造户坐车的方式——现在户只需要坐在车里对司机说句:“开车”就可以了。

    代码://抽象产品角色
    public interface Car{
    public void drive();
    }

    //具体产品角色
    public class Benz implements Car{
    public void drive() {
    System.out.println("Driving Benz ");
    }
    }

    public class Bmw implements Car{
    public void drive() {
    System.out.println("Driving Bmw ");
    }
    }
    。。。(奥迪我就不写了:P)

    //工厂类角色
    public class Driver{
    //工厂方法.注意 返回类型为抽象产品角色
    public static Car driverCar(String s)throws Exception{
    //判断逻辑,返回具体的产品角色给Client
    if(s.equalsIgnoreCase(“Benz”))
    return new Benz();
    else if(s.equalsIgnoreCase(“Bmw”))
    return new Bmw();

    else throw new Exception();
    。。。

    //欢迎****户出场…
    public class Magnate{
    public static void main(String[] args){
    try{
    //告诉司机我今天坐奔驰
    Car car = Driver.driverCar(“benz”);
    //下命令:开车
    car.drive();
    。。。

         将本程序空缺的其他信息填充完整后即可运行。如果你将所有的类放在一个文件中,请不要忘记只能有一个类被声明为public。本程序在jdk1.4 下运行通过。 
    

    这便是简单工厂模式了。怎么样,使用起来很简单吧?那么它带来了什么好处呢?
    首先,使用了简单工厂模式后,我们的程序不在“有病”,更加符合现实中的情况;而且客户端免除了直接创建产品对象的责任,而仅仅负责“消费”产品(正如****户所为)。

          下面我们从开闭原则(对扩展开放;对修改封闭)上来分析下简单工厂模式。当****户增加了一辆车的时候,只要符合抽象产品制定的合同,那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说,它是符合开闭原则的;但是工厂部分好像不太理想,因为每增加一辆车,都要在工厂类中增加相应的业务逻辑或者判断逻辑,这显然是违背开闭原则的。可想而知对于新产品的加入,工厂类是很被动的。对于这样的工厂类(在我们的例子中是为司机师傅),我们称它为全能类或者上帝类。 
             我们举的例子是最简单的情况,而在实际应用中,很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品,所以这可能会把我们的上帝累坏了,也累坏了我们这些程序员:( 
           于是工厂方法模式作为救世主出现了。 
    

    四、工厂方法模式
    工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

    你应该大致猜出了工厂方法模式的结构,来看下它的组成:

       1)抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
    
       2)具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
    
       3)抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
    
       4)具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
      工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说,这样便分担了对象承受的压力;而且这样使得结构变得灵活起来——当有新的产品(即****户的汽车)产生时,只要按照抽象产品角色、抽象工厂角色提供的合同来生成,那么就可以被客户使用,而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的! 
    
      我们还是老规矩,使用一个完整的例子来看看工厂模式各个角色之间是如何来协调的。话说****户生意越做越大,自己的爱车也越来越多。这可苦了那位司机师傅了,什么车它都要记得,维护,都要经过他来使用!于是****户同情他说:看你跟我这么多年的份上,以后你不用这么辛苦了,我给你分配几个人手,你只管管好他们就行了!于是,工厂方法模式的管理出现了。代码如下: 
    

    代码:
    //抽象产品角色,具体产品角色与简单工厂模式类似,只是变得复杂了些,这里略。
    //抽象工厂角色
    public interface Driver{
    public Car driverCar();
    }
    public class BenzDriver implements Driver{
    public Car driverCar(){
    return new Benz();
    }
    }
    public class BmwDriver implements Driver{
    public Car driverCar(){
    return new Bmw();
    }
    }

    //应该和具体产品形成对应关系…
    //有请****户先生
    public class Magnate{
    public static void main(String[] args){
    try{
    Driver driver = new BenzDriver();
    Car car = driver.driverCar();
    car.drive();
    }
    ……
    }

    可以看出工厂方法的加入,使得对象的数量成倍增长。当产品种类非常多时,会出现大量的与之对应的工厂对象,这不是我们所希望的。因为如果不能避免这种情况,可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类:即对于产品树上类似的种类(一般是树的叶子中互为兄弟的)使用简单工厂模式来实现。

    五、小结

    工厂方法模式仿佛已经很完美的对对象的创建进行了包装,使得客户程序中仅仅处理抽象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢?大可不必。也许在下面情况下你可以考虑使用工厂方法模式:

     1)当客户程序不需要知道要使用对象的创建过程。 
    
     2)客户程序使用的对象存在变动的可能,或者根本就不知道使用哪一个具体的对象。 
    

    简单工厂模式与工厂方法模式真正的避免了代码的改动了?没有。在简单工厂模式中,新产品的加入要修改工厂角色中的判断语句;而在工厂方法模式中,要么将判断逻辑留在抽象工厂角色中,要么在客户程序中将具体工厂角色写死(就象上面的例子一样)。而且产品对象创建条件的改变必然会引起工厂角色的修改。
    面对这种情况,Java的反射机制与配置文件的巧妙结合突破了限制——这在Spring中完美的体现了出来。
    六、抽象工厂模式

           先来认识下什么是产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。还是让我们用一个例子来形象地说明一下吧。 
    

    回到抽象工厂模式的话题上。
    可以说,抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。
    抽象工厂模式的用意为:给客户端提供一个接口,可以创建多个产品族中的产品对象

    而且使用抽象工厂模式还要满足一下条件:
    1)系统中有多个产品族,而系统一次只可能消费其中一族产品。
    2)同属于同一个产品族的产品以其使用。
    来看看抽象工厂模式的各个角色(和工厂方法的如出一辙):
    1)抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

     2)具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。 
    
     3)抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
    
     4)具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
    

    看过了前两个模式,对这个模式各个角色之间的协调情况应该心里有个数了,我就不举具体的例子了。只是一定要注意满足使用抽象工厂模式的条件哦。
    转载链接:
    https://blog.csdn.net/zxl0016/article/details/7922384

    展开全文
  • JAVA 工厂模式

    千次阅读 2018-09-05 15:43:53
    JAVA 工厂模式 使用场景 在具体介绍工厂模式之前,首先应该先对其使用场景有个了解,网上的例子虽然介绍了工厂模式的概念,但是看完之后,并没有感觉好在哪里,反而有点绕圈子的感觉。 场景1:比如类A,用到...

    JAVA 工厂模式

     

    使用场景

    在具体介绍工厂模式之前,首先应该先对其使用场景有个了解,网上的例子虽然介绍了工厂模式的概念,但是看完之后,并没有感觉好在哪里,反而有点绕圈子的感觉。

     

    场景1:比如类A,用到的地方很多,每个地方都需要new一个实例。如果此时对A做了修改(比如修改了构造函数的参数类型,或者需求变更,需要将A修改为A的子类),就需要修改所有引用的地方,这时将创建实例的过程放入工厂类中,如果类A有任何修改,只需修改工厂即可。

     

    场景2:降低代码重复。如果创建对象B的过程都很复杂,需要一定的代码量,而且很多地方都要用到,那么就会有很多的重复代码。我们可以这些创建对象B的代码放到工厂里统一管理。既减少了重复代码,也方便以后对B的创建过程的修改维护。(当然,也可以把这些创建过程的代码放到类的构造函数里,同样可以降低重复率,而且构造函数本身的作用也是初始化对象。不过,这样也会导致构造函数过于复杂,做的事太多,不符合java 的设计原则。)

     

    场景3:如果一个抽象类有很多子类,比如抽象类为UserDAO,子类为JDBCUserDAO和HibernateUserDAO,不同的情况下要调用不同子类,调用灵活,如果不使用工厂模式,则需要在业务逻辑中的类中,分别创建实例UserDAO udao = new JDBCUserDAO,UserDAO udao = new HibernateUserDAO,当需要更改需求,调用其他子类时,则需要修改业务逻辑的类,这样不符合一般的设计原则,通过工厂模式创建,则将创建和引用解耦,只需要修改创建部分就可以

     

    以下大部分内容转自博客:http://blog.csdn.net/jason0539,对部分内容做了修改

    引言

    1)还没有工厂时代:假如还没有工业革命,如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车,然后拿来用。
    2)简单工厂模式:后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车,这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。
    3)工厂方法模式时代:为了满足客户,宝马车系列越来越多,如320i523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。

    4)抽象工厂模式时代:随着客户的要求越来越高,宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。最终是客户只要对宝马的销售员说:我要523i空调车,销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车这就是工厂模式

    分类 
            工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。 这里就不用产品族和等级结构等概念来说了,用不熟悉的词汇,来解释不熟悉的概念,反而将简单的东西,给搞复杂了。
    工厂模式可以分为三类: 

    1)简单工厂模式(Simple Factory 
    2
    )工厂方法模式(Factory Method 
    3
    )抽象工厂模式(Abstract Factory 

     这三种模式从上到下逐步抽象,并且更具一般性。 
            GOF
    在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。

            将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。 

     

     

    区别 
    1 工厂方法模式:
    一个抽象产品类,可以派生出多个具体产品类。

    一个抽象工厂类,可以派生出多个具体工厂类。

    每个具体工厂类只能创建一个具体产品类的实例。
    2 抽象工厂模式:
    多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。   
    一个抽象工厂类,可以派生出多个具体工厂类。   
    每个具体工厂类可以创建多个具体产品类的实例。   
    3 区别:

    工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。   
    工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
     

     

     简单工厂模式 


    建立一个工厂(一个函数或一个类方法)来制造新的对象。
    分布说明引子:从无到有。客户自己创建宝马车,然后拿来用。

    下例为不实用工厂模式:

         BMW320(){  

            System.out.println() }  

         BMW523(){  

            System.out.println() }  

      Customer {  

           main(String[] args) {  

            BMW320 bmw320 =  BMW320();  

           BMW523 bmw523 =  BMW523();  

       }  

    }

     

    客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了:简单工厂模式

    即我们建立一个工厂类方法来制造新的对象。如图:

    产品类:

    abstract BMW {  

         BMW(){  

        }  

    }  

      BMW320 extends  BMW {  

         BMW320() {  

            System.out.println() }  

      BMW523 extends   BMW{  

         BMW523(){  

            System.out.println( )   }  

    }  

    工厂类(伪代码)

    public Factory {  

         BMW createBMW( type) {  

             (type) {  

                 Type=320  new BMW320();  

                  Type=523  new BMW523();  

            }  

        }  

    }  


    客户类:

    public Customer {  

           main(String[] args) {  

            Factory factory =  Factory();  

            BMW bmw320 = factory.createBMW(320);  

            BMW bmw523 = factory.createBMW(523);  

        }  

    }  

          简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。 
          
    先来看看它的组成: 
               1)
    工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑,用来创建产品
                  2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。         
                 3)
    具体产品角色:工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。 

     

             下面我们从开闭原则(对扩展开放;对修改封闭)上来分析下简单工厂模式。当客户不再满足现有的车型号的时候,想要一种速度快的新型车,只要这种车符合抽象产品制定的合同,那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说,它是符合开闭原则的;但是工厂部分好像不太理想,因为每增加一种新型车,都要在工厂类中增加相应的创建业务逻辑(createBMW(int type)方法需要新增case),这显然是违背开闭原则的。可想而知对于新产品的加入,工厂类是很被动的。对于这样的工厂类,我们称它为全能类或者上帝类。 
            我们举的例子是最简单的情况,而在实际应用中,很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品,所以这可能会把我们的上帝累坏了,也累坏了我们这些程序员。
            于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码

     

    工厂方法模式 


            工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 
    工厂方法模式组成: 
           1)
    抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
           2)
    具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
           3)
    抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
           4)
    具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
           
    工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的上帝类。正如上面所说,这样便分担了对象承受的压力;而且这样使得结构变得灵活 起来——当有新的产品产生时,只要按照抽象产品角色、抽象工厂角色提供的合同来生成,那么就可以被客户使用,而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的! 

    代码如下: 

    产品类:

    abstract BMW {  

         BMW(){  

        }  

    }  

      BMW320 extends  BMW {  

         BMW320() {  

            System.out.println(    }  

    }  

      BMW523 extends   BMW{  

         BMW523(){  

            System.out.println( }  

    }
    创建工厂类:

    Interface FactoryBMW }  

      

      FactoryBMW320 implements  FactoryBMW{  

      

          

         BMW320 createBMW() {  

      

              New BMW320();  

        }  

      

    }  

      FactoryBMW523 implements  FactoryBMW {  

         BMW523 createBMW() {  

              New BMW523();  

       }  

    }  


    客户类:

    public Customer {  

           main(String[] args) {  

            FactoryBMW320 factoryBMW320 =  FactoryBMW320();  

            BMW320 bmw320 = factoryBMW320.createBMW();  

            FactoryBMW523 factoryBMW523 =  FactoryBMW523();  

            BMW523 bmw523 = factoryBMW523.createBMW();  

        }  

    }  


           工厂方法模式仿佛已经很完美的对对象的创建进行了包装,使得客户程序中仅仅处理抽象产品角色提供的接口,但使得对象的数量成倍增长。当产品种类非常多时,会出现大量的与之对应的工厂对象,这不是我们所希望的。

    以上就是简单工厂模式,工厂方法模式

     

    抽象工厂模式

     

    例子背景:

    随着客户的要求越来越高,宝马车需要不同配置的空调和发动机等配件。于是这个工厂开始生产空调和发动机,用来组装汽车。这时候工厂有两个系列的产品:空调和发动机。宝马320系列配置A型号空调和A型号发动机,宝马523系列配置B型号空调和B型号发动机。

     

    概念:

          抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。比如宝马320系列使用空调型号A和发动机型号A,而宝马523系列使用空调型号B和发动机型号B,那么使用抽象工厂模式,在为320系列生产相关配件时,就无需制定配件的型号,它会自动根据车型生产对应的配件型号A

     

    当每个抽象产品都有多于一个的具体子类的时候(空调有型号AB两种,发动机也有型号AB两种),工厂角色怎么知道实例化哪一个子类呢?

    比如每个抽象产品角色都有两个具体产品(产品空调有两个具体产品空调A和空调B)。

    抽象工厂模式提供两个具体工厂角色(宝马320系列工厂和宝马523系列工厂),分别对应于这两个具体产品角色,每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

     

    抽象工厂模式代码

     

     产品类: 

    //发动机以及型号   

    public Engine {    

    }    

      EngineA  extends  Engine{    

         EngineA(){    

            System.out.println() }    

    }

      EngineB extends Engine{    

         EngineB(){    

            System.out.println()    }    

    }    

     

      Aircondition {    

    }    

      AirconditionA extends   Aircondition{    

         AirconditionA(){    

            System.out.println()    }    

    }    

      AirconditionB extends    Aircondition{    

         AirconditionB(){    

            System.out.println() }   

    }


    创建工厂类:

    //创建工厂的接口   

    public AbstractFactory {    

         Engine createEngine();  

         Aircondition createAircondition();   

    }    

      FactoryBMW320 extends  AbstractFactory{    

         Engine createEngine() {      

              EngineA();    

        }    

         Aircondition createAircondition() {    

              AirconditionA();    

        }    

    }    

      

      FactoryBMW523 extends  AbstractFactory {    

         Engine createEngine() {      

              EngineB();    

        }    

            

         Aircondition createAircondition() {    

              AirconditionB();    

        }    

    }   

     

    客户:

    public Customer {    

           main(String[] args){    

            FactoryBMW320 factoryBMW320 =  FactoryBMW320();    

            factoryBMW320.createEngine();  

            factoryBMW320.createAircondition();  

            FactoryBMW523 factoryBMW523 =  FactoryBMW523();    

            factoryBMW320.createEngine();  

            factoryBMW320.createAircondition();  

        }    

    }  

     

     

    整理一波

     

     

    无论是简单工厂模式,工厂方法模式,还是抽象工厂模式,他们都属于工厂模式,在形式和特点上也是极为相似的,他们的最终目的都是为了解耦。在使用时,我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式,因为他们之间的演变常常是令人琢磨不透的。经常你会发现,明明使用的工厂方法模式,当新需求来临,稍加修改,加入了一个新方法后,由于类中的产品构成了不同等级结构中的产品族,它就变成抽象工厂模式了;而对于抽象工厂模式,当减少一个方法使的提供的产品不再构成产品族之后,它就演变成了工厂方法模式。

           所以,在使用工厂模式时,只需要关心降低耦合度的目的是否达到了

     

    展开全文
  • java工厂模式

    千次阅读 2012-08-21 11:53:06
    Java工厂模式看了这么多关于工厂模式的讲解,还是觉得这篇文章讲的好理解,贴出来和大家分享分享。 一、引子 话说十年前,有一个****户,他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪,还雇了司机为他开车。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,985
精华内容 8,794
关键字:

java工厂模式

java 订阅