精华内容
下载资源
问答
  • 工厂方法

    千次阅读 2019-08-05 20:41:04
    1.首先给出工厂方法的****定义: 定义一个创建对象的接口,让子类决定实例化哪一类,使一个类的实例化延迟到其子类。因为每一个具体产品类对应着一个具体的工厂类,故增加具体产品时只需要增加一个具体工厂类.。工厂...

    1.首先给出工厂方法的****定义
    定义一个创建对象的接口,让子类决定实例化哪一类,使一个类的实例化延迟到其子类。因为每一个具体产品类对应着一个具体的工厂类,故增加具体产品时只需要增加一个具体工厂类.。工厂方法模式是简单工厂模式的进一步抽象和推广,克服了简单工厂的违背开放-封闭原则的缺点,又保持了封装对象创建过程的优点。
    2.为什么要用工厂方法模式
    工厂方法模式与简单工厂模式的区别在于工厂方法模式比简单工厂模式多出一个抽象工厂接口,每一个具体工厂实现某个具体产品的实现。比如生成每本书都需要许多信息,书名,出版社,生成时间和生成顺序,但是不同的书籍信息要求不确定。
    3.简单工厂模式与工厂方法模式的区别
    工厂方法模式与简单工厂模式的区别在于工厂方法模式比简单工厂模式多出一个抽象工厂接口,每一个具体工厂实现某个具体产品的实现

    4.简单的举个例子:
    我们将水果园比作一个工厂,在简单工厂模式下,水果园是一个具体的工厂,直接用来生产各种各样的水果。那么在工厂方法模式下,水果园是一个抽象工厂,那么苹果树,香蕉树等就相当于是具体工厂,生产苹果、香蕉等水果。每有一种新的水果要生产,则需要种植生产这种水果植物,即创建生产具体水果的工厂。
    如下图:
    在这里插入图片描述
    苹果和香蕉的都实现水果接口类中的get()方法,负责生产苹果和香蕉的具体工厂实现水果这个抽象工厂接口。在工厂方法模式下如果想要生产新的水果,即创建新的类。比如生产梨子,需要新建一个梨子类实现水果类的get()方法,创建梨子工厂实现水果工厂来生产梨子。

    在这里插入图片描述
    接下来我们用代码来解释一下:
    首先顶一个水果类:
    Fruit(interface):

    //水果类
    public interface Fruit {
        public void get();
    }
    

    Apple类:

    //苹果类
    public class Apple implements Fruit{
        //实现并重写父类的get()方法
        public void get() {
            System.out.println("采集苹果");
        }
    }
    

    4.创建FruitFactory接口、AppleFactory类等

    FruitFactory(interface):
    
    public interface FruitFactory {
        public Fruit getFruit();
    }
    

    AppleFactory类:

    public class AppleFactory implements FruitFactory {
        @Override
        public Fruit getFruit() {
            return new Apple();
        }
    }
    

    5.生产水果
    MainClass:

    public class MainClass {
        public static void main(String[] args){
            //创建苹果工厂
            FruitFactory appleFactory = new AppleFactory();
            //通过苹果工厂生产苹果实例
            Fruit apple = appleFactory.getFruit();
            apple.get();
    
        //创建香蕉工厂
        FruitFactory bananaFactory = new BananaFactory();
        //通过香蕉工厂生产香蕉实例
        Fruit banana = bananaFactory.getFruit();
        banana.get();
        
        //新添加的梨子工厂
        FruitFactory pearFactory = new PearFactory();
        Fruit pear = pearFactory.getFruit();
        pear.get();
    }
    

    }
      这里用到Java面向对象的三大特性之一–多态。在新建工厂时,由FruitFactory接口指向具体的工厂(AppleFactory)。通过具体的工厂生产水果时,由Fruit接口指向具体的实例对象(Apple)。

    展开全文
  • 简单工厂/工厂方法/抽象工厂

    万次阅读 2020-10-25 22:56:14
    * 缺点:新增实现类时,需要修改代码,不好动态扩展(可参考工厂方法) */ public class SimpleFactoryDP { public final class Const { static final int PRODUCT_A = 0; static final int PRODUCT_B = 1; }...

    1 简单工厂

    根据参数由工厂类来创建对象

    /**
     * 简单工厂
     * 目的:根据参数获取对象
     * 缺点:新增实现类时,需要修改代码,不好动态扩展(可参考工厂方法)
     */
    public class SimpleFactoryDP {
    
        public final class Const {
            static final int PRODUCT_A = 0;
            static final int PRODUCT_B = 1;
        }
    
        //抽象产品
        public interface Product {
            void show();
        }
    
        //具体产品:ProductA
        static class ConcreteProduct1 implements Product {
            public void show() {
                System.out.println("具体产品1显示...");
            }
        }
    
        //具体产品:ProductB
        static class ConcreteProduct2 implements Product {
            public void show() {
                System.out.println("具体产品2显示...");
            }
        }
    
        public static class SimpleFactory {
            public static Product makeProduct(int kind) {
                switch (kind) {
                    case Const.PRODUCT_A:
                        return new ConcreteProduct1();
                    case Const.PRODUCT_B:
                        return new ConcreteProduct2();
                }
                return null;
            }
        }
    
        void test(){
            Product product = SimpleFactory.makeProduct(1);
            product.show();
        }
    
    }
    

    2 工厂方法

    解决简单工厂不能动态扩展实现类(开闭原则)

    /**
     *  工厂方法
     *  单个工厂提供单个实现类,方便扩展更多实现类
     *  目的:优化简单工厂不好扩展新的类。这里只需要新增工厂类既能扩展
     *  缺点:有时需要工厂类能够同时提供多个不同对象(可参考抽象工厂)
     */
    public class FactoryMethodDP {
        //抽象产品:提供了产品的接口
        interface Product {
            public void show();
        }
        //具体产品1:实现抽象产品中的抽象方法
        class ConcreteProduct1 implements Product {
            public void show() {
                System.out.println("具体产品1显示...");
            }
        }
        //具体产品2:实现抽象产品中的抽象方法
        class ConcreteProduct2 implements Product {
            public void show() {
                System.out.println("具体产品2显示...");
            }
        }
    
        //抽象工厂:提供了厂品的生成方法
        interface AbstractFactory {
            public Product newProduct();
        }
        //具体工厂1:实现了厂品的生成方法
        class ConcreteFactory1 implements AbstractFactory {
            public Product newProduct() {
                System.out.println("具体工厂1生成-->具体产品1...");
                return new ConcreteProduct1();
            }
        }
        //具体工厂2:实现了厂品的生成方法
        class ConcreteFactory2 implements AbstractFactory {
            public Product newProduct() {
                System.out.println("具体工厂2生成-->具体产品2...");
                return new ConcreteProduct2();
            }
        }
    
        void test() {
            AbstractFactory abstractFactory = new  ConcreteFactory1();
            abstractFactory.newProduct().show();
        }
    
    
    }
    

    3 抽象工厂

    解决工厂方法 单个工厂不能同时创建多个不同的实现类

    /**
     * 抽象工厂
     * 工厂可以产生多个不同对象,实现对象可以扩展,工厂类也可以动态组装
     */
    public class AbstractFactoryDP {
    
        interface ProductA{
            void aEat();
        }
        class Aimpl1 implements ProductA{
            @Override
            public void aEat() {
                System.out.println("class is Aimpl1");
            }
        }
        class Aimpl2 implements ProductA{
            @Override
            public void aEat() {
                System.out.println("class is Aimpl2");
            }
        }
    
        interface ProductB{
            void bUse();
        }
        class Bimpl1 implements ProductB{
            @Override
            public void bUse() {
                System.out.println("class is Bimpl1");
            }
        }
        class Bimpl2 implements ProductB{
            @Override
            public void bUse() {
                System.out.println("class is Bimpl2");
            }
        }
    
        interface AbstractProductFactory{
            ProductA createA();
            ProductB createB();
        }
    
        class ProductFactoryImplA implements  AbstractProductFactory{
            @Override
            public ProductA createA() {
                return new Aimpl1();
            }
            @Override
            public ProductB createB() {
                return new Bimpl1();
            }
        }
    
        class ProductFactoryImplB implements  AbstractProductFactory{
            @Override
            public ProductA createA() {
                return new Aimpl2();
            }
            @Override
            public ProductB createB() {
                return new Bimpl2();
            }
        }
    
        void test(){
            AbstractProductFactory productFactory = new ProductFactoryImplA();
            ProductA productA = productFactory.createA();
            productA.aEat();
            ProductB productB = productFactory.createB();
            productB.bUse();
        }
    
    }
    

     

    展开全文
  • 简单工厂方法工厂方法以及抽象工厂方法的区别

    1、定义


    工厂模式:定义一个用于创建对象的接口,让子类决定实例化哪个类

    抽象工厂模式:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类

    2、工厂方法与抽象工厂方法的区别



    3、简单工厂方法、工厂方法以及抽象工厂方法的区别

    这里以一个种菜的例子来说明:
    刚开始,规模小,只种植一种根茎类蔬菜,所以采用简单工厂模式,在简单工厂模式下,考虑的是种植萝卜还是土豆


    随着种植厂的发展以及市场的需求,需要增加一种叶子类型的蔬菜进行种植,由于根茎类和叶子类的种植方式不同,需要两个专门的种植工厂来管理,这时候就采用工厂模式,一个工厂负责一种作物的种植,这个时候产品可以理解为仍然在一个层次。在工厂模式下,考虑的是种植根茎类蔬菜还是叶子类蔬菜
    但是随着科技的发展,我们逐步要种植转基因与非转基因食品了,在以前的蔬菜种类上又增加了一个层次,这个时候无法将其作为一个层次来解决,所以必须采用抽象工厂的方式来解决。在抽象工厂模式下,考虑的是种植转基因蔬菜还是非转基因蔬菜
    具体选用哪种工厂模式,需要仔细分析产品的层次等级结构

    展开全文
  • 常用设计模式-工厂方法

    万次阅读 2020-11-19 14:12:05
    2. 工厂方法模式(Factory Method) 3. 抽象工厂模式(Abstract Factory) 工厂方法模式是对简单工厂模式的抽象升级,定义一个用于创建对象的接口,让子类决定实例哪个类。工厂方法使一个类实例化延迟到其子类。 与...


    模式简介

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


    工厂方法模式是对简单工厂模式的抽象升级,定义一个用于创建对象的接口,让子类决定实例哪个类。工厂方法使一个类实例化延迟到其子类。

    简单工厂模式相比,简单工厂模式使得工厂的负担过重,而且每次添加新产品,都需要修改工厂,不符合开闭原则。

    工厂方法模式的重点就在这个工厂接口了。目标可以无限扩展,工厂类也要随之扩展,一对一存在,满足了开闭原则,但如果目标实现较多,工厂实现类也会增多,不简洁。

    实际应用场景

    MyBatis中使用的比较多,事务模块和数据源模块都使用了工厂方法模式。


    UML类图

    案例:汽车生产

    Car
    /**
     * @Author l'amour solitaire
     * @Description 汽车
     * @Date 2020/11/19 下午1:58
     **/
    public interface Car {
    
        /**
         * 汽车品牌
         **/
        String carName();
    }
    BenzCar
    /**
     * @Author l'amour solitaire
     * @Description 奔驰
     * @Date 2020/11/19 下午2:09
     **/
    public class BenzCar implements Car {
    
        @Override
        public String carName() {
            return "Benz";
        }
    }
    BmwCar
    /**
     * @Author l'amour solitaire
     * @Description 宝马
     * @Date 2020/11/19 下午2:09
     **/
    public class BmwCar implements Car {
    
        @Override
        public String carName() {
            return "BMW";
        }
    }
    CarFactory
    /**
     * @Author l'amour solitaire
     * @Description 汽车工厂
     * @Date 2020/11/19 下午2:02
     **/
    public interface CarFactory {
    
        /**
         *
         **/
        Car createCar();
    }
    BeezCarFactory
    /**
     * @Author l'amour solitaire
     * @Description 奔驰汽车工厂
     * @Date 2020/11/19 下午2:03
     **/
    public class BeezCarFactory implements CarFactory {
    
        @Override
        public Car createCar() {
            return new BenzCar();
        }
    }
    BmwCarFactory
    /**
     * @Author l'amour solitaire
     * @Description 宝马汽车工厂
     * @Date 2020/11/19 下午2:03
     **/
    public class BmwCarFactory implements CarFactory {
        
        @Override
        public Car createCar() {
            return new BmwCar();
        }
    }

     

    测试

    @SpringBootTest
    class DesignApplicationTests {
    
        @Test
        void test() {
            CarFactory carFactory = new BeezCarFactory();
            System.out.println(carFactory.createCar().carName());
            carFactory = new BmwCarFactory();
            System.out.println(carFactory.createCar().carName());
        }
    
    }

     

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

    展开全文
  • 静态工厂方法和实例工厂方法区别

    千次阅读 2019-12-26 17:55:13
    在学习Spring bean的实例化方式的时候遇到的一个问题,Spring bean实例化有3种方法 1、构造器生成 2、静态工厂方法 3、实例工厂方法 那么问题来了,什么是静态工厂方法,什么是实例工厂方法? 1、静态工厂方法 就是...
  • 静态工厂方法和实例工厂方法

    千次阅读 2017-02-05 11:56:26
    在学习Spring bean的实例化方式的时候遇到的一个问题,Spring bean实例化有3种方法 1、构造器生成 2、静态工厂方法 3、实例工厂方法 那么问题来了,什么是静态工厂方法,什么是实例工厂方法? 静态工厂方法: ...
  • 工厂方法模式 工厂模式的本质 实例化对象不使用new,用工厂方法代替 将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现解耦 - oop七大原则 开闭原则:一个软件的实体应当对扩展开放,对修改关闭 ...
  • 工厂方法 抽象工厂 使用抽象工厂模式,设计一个monopoly游戏地图,地图由十二个地块组成,地块可能是:空地、游乐园和监狱。也可能是由魔法地块组成,每个地块可能是:魔法空地、魔法游乐园和魔法监狱。 请用控制台...
  • 工厂方法模式

    万次阅读 2019-12-12 01:11:39
    抽象工厂(AbstractFactory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法newProduct()来创建产品。 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。 抽象产品...
  • 在学习Spring bean的实例化方式的时候遇到的一个问题,Spring bean实例化有3种方法 1、构造器生成 2、静态工厂方法 3、实例工厂方法 那么问题来了,什么是静态工厂方法,什么是实例工厂方法? 静态工厂方法 ...
  • 一、静态工厂方法注入bean利用静态工厂方法可以把bean注入到IOC容器中。在XML文件中配置bean时,要指定class的属性为工厂的类;factory-method属性指定工厂类中工厂方法,用于创建bean;constrctor-arg用于给工厂...
  • 大话设计模式(六)工厂方法模式

    万次阅读 2016-10-09 11:23:17
    大话设计模式(六)工厂方法模式前言  今天主要讲解工厂方法模式。工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。工厂方法模式是简单工厂模式的进一步抽象和...
  • 设计模式——总结简单工厂,工厂方法和抽象工厂

    千次阅读 热门讨论 2020-03-31 21:47:36
    前言 简单总结为什么会出现工厂,工厂方法与简单工厂还有抽象工厂之间有啥区别。
  • 简单工厂、工厂方法、抽象工厂

    千次阅读 2017-05-24 22:34:09
    简单工作:由静态工厂方法通过输入的参数创建不同的产品 工厂方法:由工厂实例方法创建具体某个产品 抽象工厂:由工厂示例方法创建多个产品
  • 通过调用静态工厂方法创建Bean调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中。当客户端需要对象时,只需要简单地调用静态方法,而不关心创建对象的细节。要声明通过静态方法创建的Bean,需要在Bean的...
  • Spring的实例工厂方法和静态工厂方法  静态工厂方法:直接调用静态方法可以返回Bean的实例 package com.zhu.string.factory; import java.util.HashMap; import java.util.Map; public class StaticCarFactory {...
  • 一、静态工厂方法注入bean 利用静态工厂方法可以把bean注入到IOC容器中。在XML文件中配置bean时,要指定class的属性为工厂的类;factory-method属性指定工厂类中工厂方法,用于创建bean;constrctor-arg用于给工厂...
  • 工厂方法模式与抽象工厂模式

    千次阅读 2017-04-18 15:26:29
    工厂方法模式与抽象工厂模式
  • 为什么会出现简单工厂,工厂方法与简单工厂还有抽象工厂到底有啥区别,什么时候能用到这些呢,如果你对于这些不是很清晰,那么你可以看看小编的这篇博客,透析式挖掘三者的区别!不要错过哟! 这里所有的类图均用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,380
精华内容 23,352
关键字:

工厂方法