精华内容
下载资源
问答
  • 简单工厂/工厂方法/抽象工厂

    万次阅读 2020-10-25 22:56:14
    1 简单工厂 根据参数由工厂类来创建对象 /** * 简单工厂 * 目的:根据参数获取对象 * 缺点:新增实现类时,需要修改代码,不好动态扩展(可参考工厂方法) */ public class SimpleFactoryDP { public final...

    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();
        }
    
    }
    

     

    展开全文
  • 不会工厂模式怎么进大厂? 文章目录 简单工厂 工厂方法 抽象工厂 使用抽象工厂模式,设计一个monopoly游戏地图,地图由十二个地块组成,地块可能是:空地、游乐园和监狱。也可能是由魔法地块组成,每个地块可能是:...

    简单工厂


    简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式是由一
    个工厂对象决定创建出哪一种产品类的实例
    。定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码)。当我们会用到大量的创建某种、某类或者某批对象时,就会使用到工厂模式。
    由于创建实例的方法通常为静态(static)方法,因此简单工厂模式又被成为静态工厂方法模式(Static Factory Method)。

    在这里插入图片描述

    • Product表示产品接口,也可用抽象类实现,封装产品间共有的属性。
    • ConcreteProduct*表示具体的实际产品。
    • Factory表示工厂,工厂根据需要来创建相应的产品。

    这样一来,当添加新的产品C时,只需要修改工厂部分代码即可,而传统方法需要在每一个创建产品的地方都进行修改。可以理解为把具体的产品创建封装成一个工厂类。

    举个例子,大富翁的地图创建:

    • AbstractBlock是接口,表示抽象的地块,包括方法printBlock()打印地块。
    • Empty、Prison、Park实现上述接口,表示空地(*)、监狱(&)和公园(#)。
    • SimpleFactory是创建地块的简单工厂。

    类图:
    在这里插入图片描述

    代码:

    1. 产品接口
    public interface AbstractBlock {
        public void printBlock();
    }
    
    1. 产品接口实现子类
    public class Empty implements AbstractBlock{
        @Override
        public void printBlock() {
            System.out.print("* ");
        }
    }
    
    public class Park implements AbstractBlock{
        @Override
        public void printBlock() {
            System.out.print("# ");
        }
    }
    
    public class Prison implements AbstractBlock{
        @Override
        public void printBlock() {
            System.out.print("& ");
        }
    }
    
    1. 简单工厂类
    public class SimpleFactory {
        public AbstractBlock getBlock(String type){ //根据传参创建不同的地块
            if(type.equalsIgnoreCase("Empty")){
                return new Empty();
            } else if(type.equalsIgnoreCase("Park")){
                return new Park();
            } else if(type.equalsIgnoreCase("Prison")){
                return new Prison();
            }
            return null;
        }
    }
    
    1. 调用工厂
    public class Map {
        public void getMap(){
            SimpleFactory simpleFactory=new SimpleFactory();  //实例化工厂
            ArrayList<AbstractBlock> map=new ArrayList<AbstractBlock>();  //地块集合
    
            String []types=new String[3];
            types[0]="Empty";
            types[1]="park";
            types[2]="Prison";
            Random rd = new Random();
            for(int i=1;i<=12;i++){  //随机用工厂创建地块并放入集合
                int tt = rd.nextInt(types.length);
                map.add(simpleFactory.getBlock(types[tt]));
            }
            //地图大小写死了,不是重点
            for(int i=0;i<12;i++){
                map.get(i).printBlock();
                if(i==3||i==5||i==7)
                    System.out.println();
                if(i==4||i==6)
                    System.out.print("    ");
            }
        }
    }
    
    1. 测试
    public class MonoPoly {
        public static void main(String[] args) {
            Map map=new Map();
            map.getMap();
        }
    }
    
    1. 运行结果
      在这里插入图片描述

    工厂方法


    不难发现,当增加新的产品时需要对简单工厂类修改,或创建多个简单工厂。(比如增加一个法院地块)
    工厂方法进一步解耦合,把工厂类抽象,不再负责所有实例的创建,而是把具体的创建工作交给了子类去完成,实例化延迟到子类加载,由子类来决定要实例化的类。

    在这里插入图片描述
    抽象化工厂类,把具体实例化工作交给其子类实现。

    代码:

    1. 工厂接口
    public interface AbstractFactory {
        public AbstractBlock createBlock();
    }
    
    1. 工厂实现子类
    public class EmptyFactory implements AbstractFactory {
        @Override
        public AbstractBlock createBlock() {
            return new Empty();
        }
    }
    
    public class ParkFactory implements AbstractFactory {
        @Override
        public AbstractBlock createBlock() {
            return new Park();
        }
    }
    
    public class PrisonFactory implements AbstractFactory {
        @Override
        public AbstractBlock createBlock() {
            return new Prison();
        }
    }
    

    插播反爬信息 )博主CSDN地址:https://wzlodq.blog.csdn.net/

    1. 产品接口
    public interface AbstractBlock {
        public void printBlock();
    }
    
    1. 产品实现子类
    public class Empty implements AbstractBlock {
        @Override
        public void printBlock() {
            System.out.print("* ");
        }
    }
    
    public class Park implements AbstractBlock {
        @Override
        public void printBlock() {
            System.out.print("# ");
        }
    }
    
    public class Prison implements AbstractBlock {
        @Override
        public void printBlock() {
            System.out.print("& ");
        }
    }
    
    1. 调用
    public class Map {
        public void getMap() {
            ArrayList<AbstractBlock> map=new ArrayList<AbstractBlock>();  //地块集合
            AbstractFactory abstractFactory;
    
            Random rd = new Random();
            for(int i=1;i<=12;i++){  //随机用工厂创建地块并放入集合
                int tt = rd.nextInt(3);
                if(tt==0)abstractFactory=new EmptyFactory();
                else if(tt==1)abstractFactory=new ParkFactory();
                else abstractFactory=new PrisonFactory();
                map.add(abstractFactory.createBlock());
            }
            //地图大小写死了,不是重点
            for(int i=0;i<12;i++){
                map.get(i).printBlock();
                if(i==3||i==5||i==7)
                    System.out.println();
                if(i==4||i==6)
                    System.out.print("    ");
            }
        }
    }
    
    1. 测试
    public class MonoPoly {
        public static void main(String[] args) {
            Map map=new Map();
            map.getMap();
        }
    }
    

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

    抽象工厂


    不难发现当创建新的产品接口时,也需要对工厂方法修改,或创建多个工厂方法。(比如增加魔法地块簇,对应组产品魔法公园、魔法空地、魔法监狱等)
    抽象工厂将工厂方法进一步抽象。定义了一个接口用于创建相关或有依赖关系的对象簇,而无需指明具体的类。可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。

    在这里插入图片描述
    把工厂类抽象后,对应不同子类工厂(普通/魔法),生产对应的一组产品。最后调用时统一调用抽象接口即可,不必知道具体对象,面向接口编程。

    1. 产品接口
    public interface AbstractBlock {
        void printBlock();
    }
    
    1. 产品抽象子类-普通产品
    public abstract class NormalAbstractBlock implements AbstractBlock {
        public abstract void printBlock();
    }
    

    2.2普通空地

    public class NormalEmpty extends NormalAbstractBlock {
        public void printBlock() {
            System.out.print("* ");
        }
    }
    

    2.3普通公园

    public class NormalPark  extends NormalAbstractBlock {
        public void printBlock() {
            System.out.print("# ");
        }
    }
    

    2.4普通监狱

    public class NormalPrison extends NormalAbstractBlock {
        public void printBlock() {
            System.out.print("& ");
        }
    }
    
    1. 产品抽象子类-魔法产品
    public abstract class MagicAbstractBlock implements AbstractBlock {
        public abstract void printBlock();
    }
    

    3.2魔法空地

    public class MagicEmpty  extends MagicAbstractBlock {
        public void printBlock() {
            System.out.print("e ");
        }
    }
    

    3.3魔法公园

    public class MagicPark extends MagicAbstractBlock {
        public void printBlock() {
            System.out.print("g ");
        }
    }
    

    3.4魔法监狱

    public class MagicPrison extends MagicAbstractBlock {
        public void printBlock() {
            System.out.print("p ");
        }
    }
    
    1. 工厂接口
    public interface AbstractFactory {
        AbstractBlock getEmpty();
        AbstractBlock getPrison();
        AbstractBlock getPark();
    }
    
    1. 工厂实现子类-普通工厂
    public class NormalFactory implements  AbstractFactory {
        public AbstractBlock getEmpty() { return new NormalEmpty(); }
        public AbstractBlock getPrison() { return new NormalPrison(); }
        public AbstractBlock getPark() { return new NormalPark(); }
    }
    
    1. 工厂实现子类-魔法工厂
    public class MagicFactory implements AbstractFactory {
        public AbstractBlock getEmpty() { return new MagicEmpty(); }
        public AbstractBlock getPrison() {return new MagicPrison(); }
        public AbstractBlock getPark() { return new MagicPark(); }
    }
    
    1. 调用
    public class Map {
        public void getMap(AbstractFactory af){
            ArrayList<AbstractBlock> map=new ArrayList<AbstractBlock>();
            map.add(af.getEmpty());
            map.add(af.getPrison());
            map.add(af.getPark());
            Random rd = new Random(3);
            int col=12;
            for(int i=1;i<=col;i++){
                int tt = rd.nextInt(3);
                map.get(tt).printBlock();
                if(i==4||i==6||i==8)
                    System.out.println();
                if(i==5||i==7)
                    System.out.print("    ");
            }
        }
    }
    
    1. 测试
    public class Monopoly {
        public void play(){
            Map map=new Map();
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入指令(1输出普通地图,2输出魔法地图)");
            int order;
            order  = scan.nextInt();
            if(order == 1){
                map.getMap(new NormalFactory());
            }else{
                map.getMap(new MagicFactory());
            }
        }
    }
    

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

    原创不易,请勿转载本不富裕的访问量雪上加霜
    博主首页:https://wzlodq.blog.csdn.net/
    微信公众号:吾仄lo咚锵
    如果文章对你有帮助,记得一键三连❤

    展开全文
  • 工厂模式,也叫做说虚构造器,在简单工厂中间插入了一个具体产品工厂,这个工厂知道产品构造时候的具体细节,而简单工厂模式的产品具体构造细节是在一个个if/else分支,或者在switch/case分支里面的。工厂模式的好处...

    工厂模式,简单工厂模式,抽象工厂模式三者有什么区别

    工厂模式,也叫做说虚构造器,在简单工厂中间插入了一个具体产品工厂,这个工厂知道产品构造时候的具体细节,而简单工厂模式的产品具体构造细节是在一个个if/else分支,或者在switch/case分支里面的。工厂模式的好处就在于将工厂和产品之间的耦合降低,将具体产品的构造过程放在了具体工厂类里面。在以后扩展产品的时候方便很多,只需要添加一个工厂类,一个产品类,就能方便的添加产品,而不需要修改原有的代码。而在简单工厂中,如果要增加一个产品,则需要修改工厂类,增加if/else分支,或者增加一个case分支,工厂模式符合软件开发中的OCP原则(open close principle),对扩展开放,对修改关闭。
    抽象工厂模式:这个模式我总是感觉和builder模式非常相似。
    工厂方法模式提供的是对一个产品的等级模式,,而抽象工厂方法提供的是对多个产品的等级模式,注意,这里的多个具体产品之间是相互耦合的,也就是说这里的抽象工厂提供的产品之间是存在某种联系的。
    有人做如下的比较:
    工厂方法模式:一个抽象产品类,可以派生出多个具体产品类。
    一个抽象工厂类,可以派生出多个具体工厂类。
    每个具体工厂类只能创建一个具体产品类的实例。
    抽象工厂模式:多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
    一个抽象工厂类,可以派生出多个具体工厂类。
    每个具体工厂类可以创建多个具体产品类的实例。
    区别:工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
    工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
    下面是一个形象的比喻:
    无论是简单工厂模式、工厂模式还是抽象工厂模式,它们本质上都是将不变的部分提取出来,将可变的部分留作接口,以达到最大程度上的复用。拿一个生产水杯(cup)的工厂举例:起初,不用工厂模式,我必须在生产水杯之前知道水杯的材料和形状等水杯的所有特征才能生产,这就是我们的new Cup();这个Cup必须是具体的。厂主发现同一形状的被子,只是材料不同,如一个是玻璃(glass)的,一个是瓷(china)的,但是确要两条生产线,显然有资源浪费的嫌疑。现在厂主生产杯子时先不让生产线知道我要产的是玻璃的还是瓷的,而是让它在不知道具体材料的情况下先做它能做的,等到它把模具做好,只需要向其中填充玻璃原料或者瓷原料就可以造出同一形状的具体杯子了。但是很可惜,java并不能new一个抽象的Cup,所以就有了简单工厂模式。原来是Cup cup=new Cup;现在是SimpleCupFactory.createCup(String cupName),根据cup的名字生产Cup,而createCup返回的是一个实现了 Cup接口或抽象类的具体Cup。简单抽象工厂模式有一个问题,就是当我现在想生产一个同样形状的铁杯时,工厂里并没有定义相应的处理流程,只能更改createCup方法,这就不合理了。我现在只是想生产铁杯,你只要在最后的时候把玻璃原料换成铁的不就行了吗,干嘛还要更改整条生产线呢?于是就有了工厂模式。原来生产线在生产模具的时候还要考虑是为玻璃杯生产的模具还是为铁杯生产的模具,现在它不用管了。CupFactory.createCup()创建Cup.CupFactory是接口或抽象类。实现它的具体子类会创建符合Cup接口的具体Cup。那么现在厂主想要生产水壶(kettle),用工厂模式就不得不再造一条水壶生产线,能不能在水杯生产线同时生产水壶呢?这就是抽象工厂模式。在原CupFactory中加一个createKettle()方法,用来生产水壶

    展开全文
  • java工厂模式三种详解(部分转载)

    万次阅读 多人点赞 2018-05-11 09:04:37
    工厂方法模式(Factory Method) 工厂方法模式分为三种: 1、普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。首先看下关系图: 举例如下:(我们举一个发送邮件和短信的例子) ...

    本文转载截取,原文内容更丰富。想详细了解的小伙伴可以去原创作者:

    https://blog.csdn.net/zhangerqing/article/details/8194653

    工厂方法模式(Factory Method)

    工厂方法模式分为三种:

    1、普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。首先看下关系图:

    举例如下:(我们举一个发送邮件和短信的例子)

    首先,创建二者的共同接口:

    1. public interface Sender {  
    2.     public void Send();  
    3. }  

    其次,创建实现类:

    1. public class MailSender implements Sender {  
    2.     @Override  
    3.     public void Send() {  
    4.         System.out.println("this is mailsender!");  
    5.     }  
    6. }  
    1. public class SmsSender implements Sender {  
    2.   
    3.     @Override  
    4.     public void Send() {  
    5.         System.out.println("this is sms sender!");  
    6.     }  
    7. }  

    最后,建工厂类:

    1. public class SendFactory {  
    2.   
    3.     public Sender produce(String type) {  
    4.         if ("mail".equals(type)) {  
    5.             return new MailSender();  
    6.         } else if ("sms".equals(type)) {  
    7.             return new SmsSender();  
    8.         } else {  
    9.             System.out.println("请输入正确的类型!");  
    10.             return null;  
    11.         }  
    12.     }  
    13. }  

    我们来测试下:

    1. public class FactoryTest {  
    2.   
    3.     public static void main(String[] args) {  
    4.         SendFactory factory = new SendFactory();  
    5.         Sender sender = factory.produce("sms");  
    6.         sender.Send();  
    7.     }  
    8. }  

    输出:this is sms sender!

    2、多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。关系图:

    将上面的代码做下修改,改动下SendFactory类就行,如下:

    public class SendFactory {  
       public Sender produceMail(){  
    1.         return new MailSender();  
    2.     }  
    3.       
    4.     public Sender produceSms(){  
    5.         return new SmsSender();  
    6.     }  
    7. }  

    测试类如下:

    1. public class FactoryTest {  
    2.   
    3.     public static void main(String[] args) {  
    4.         SendFactory factory = new SendFactory();  
    5.         Sender sender = factory.produceMail();  
    6.         sender.Send();  
    7.     }  
    8. }  

    输出:this is mailsender!

    3、静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。

    1. public class SendFactory {  
    2.       
    3.     public static Sender produceMail(){  
    4.         return new MailSender();  
    5.     }  
    6.       
    7.     public static Sender produceSms(){  
    8.         return new SmsSender();  
    9.     }  
    10. }  
    1. public class FactoryTest {  
    2.   
    3.     public static void main(String[] args) {      
    4.         Sender sender = SendFactory.produceMail();  
    5.         sender.Send();  
    6.     }  
    7. }  

    输出:this is mailsender!

    总体来说,工厂模式适合:凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。在以上的三种模式中,第一种如果传入的字符串有误,不能正确创建对象,第三种相对于第二种,不需要实例化工厂类,所以,大多数情况下,我们会选用第三种——静态工厂方法模式。

    4、抽象工厂模式(Abstract Factory)

    工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题,如何解决?就用到抽象工厂模式,创建多个工厂类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。因为抽象工厂不太好理解,我们先看看图,然后就和代码,就比较容易理解。

    请看例子:

    1. public interface Sender {  
    2.     public void Send();  
    3. }  

    两个实现类:

    1. public class MailSender implements Sender {  
    2.     @Override  
    3.     public void Send() {  
    4.         System.out.println("this is mailsender!");  
    5.     }  
    6. }  
    1. public class SmsSender implements Sender {  
    2.   
    3.     @Override  
    4.     public void Send() {  
    5.         System.out.println("this is sms sender!");  
    6.     }  
    7. }  

    两个工厂类:

    1. public class SendMailFactory implements Provider {  
    2.       
    3.     @Override  
    4.     public Sender produce(){  
    5.         return new MailSender();  
    6.     }  
    7. }  
    1. public class SendSmsFactory implements Provider{  
    2.   
    3.     @Override  
    4.     public Sender produce() {  
    5.         return new SmsSender();  
    6.     }  
    7. }  

    在提供一个接口:

    1. public interface Provider {  
    2.     public Sender produce();  
    3. }  

    测试类:

    1. public class Test {  
    2.   
    3.     public static void main(String[] args) {  
    4.         Provider provider = new SendMailFactory();  
    5.         Sender sender = provider.produce();  
    6.         sender.Send();  
    7.     }  
    8. }  

    其实这个模式的好处就是,如果你现在想增加一个功能:发及时信息,则只需做一个实现类,实现Sender接口,同时做一个工厂类,实现Provider接口,就OK了,无需去改动现成的代码。这样做,拓展性较好!

    展开全文
  • 工厂模式,优缺点以及存在的意义1.简单工厂模式(静态工厂模式)1.工厂方法模式 工厂模式的本质 实例化对象不使用new,用工厂方法代替 将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现解耦 - ...
  • 设计模式-JDK工厂模式

    万次阅读 2020-11-23 16:35:25
    工厂方法模式(Factory Method),定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。 二、优缺点 1、优点 (1)良好的封装性、代码结构清晰。 如一个调用者想...
  • 工厂模式与抽象工厂模式

    万次阅读 2020-12-25 21:34:30
    工厂模式 模式定义: 定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类 作用:实现了创建者和调用者的分离 详细分类:  简单工厂模式  工厂方法模式  抽象工厂...
  • Java 工厂模式

    万次阅读 多人点赞 2020-03-26 14:06:10
    Java 简单工厂模式
  • 设计模式——总结简单工厂工厂方法和抽象工厂

    千次阅读 热门讨论 2020-03-31 21:47:36
    前言 简单总结为什么会出现工厂工厂方法与简单工厂还有抽象工厂之间有啥区别。
  • 简单工厂模式最大的优点在于实现对象的创建和对象的使用分离,将对象的创建交给专门的工厂类负责,但是其最大的缺点在于工厂类不够灵活,增加新的具体产品需要修改工厂类的判断逻辑代码,而且产品较多时,工厂方法...
  • 1.简单工厂 所谓简单工厂方法模式,就是为目标类创建一个工厂,当有多个目标实现的时候,在这个工厂内部进行逻辑判断来根据条件创建不同的目标实例。 /** * 桌子接口 */ public interface Desk { String ...
  • 抽象工厂模式:我们现在要对mysql/oracle数据库中的User表进行操作,User表定义如下:public class User { private int uid; private String uname; public int getUid() { return uid; } public void set...
  • 任何可以产生对象的方法或类,都可以称之为工厂 单例也是一种工厂 为什么有了new之后,还要有工厂 灵活控制生产过程 权限、修饰、日志等等 任意的定义交通工具 继承Moveable 任意定制生产过程 Moveable XXXFactory....
  • 一、简单工厂模式 概述   简单工厂模式:定义一个工厂类,它可以根据参数的不同返回不同类的 实例,被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法,因此简单工厂...
  • 为什么会出现简单工厂工厂方法与简单工厂还有抽象工厂到底有啥区别,什么时候能用到这些呢,如果你对于这些不是很清晰,那么你可以看看小编的这篇博客,透析式挖掘三者的区别!不要错过哟! 这里所有的类图均用...
  • 工厂模式

    千次阅读 2019-09-25 20:18:24
    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个...
  • java设计模式,工厂模式、简单工程、工厂方法、抽象工厂
  • 简单工厂和抽象工厂有什么区别?

    万次阅读 2019-07-09 09:40:09
    简单工厂和抽象工厂有什么区别? 简单工厂模式 是由一个工厂对象创建产品实例,简单工厂模式的工厂类一般是使用静态方法,通过不同的参数的创建不同的对象实例 可以生产结构中的任意产品,不能增加新的产品 ...
  • 简单工厂工厂方法、抽象工厂

    千次阅读 2017-05-24 22:34:09
    简单工作:由静态工厂方法通过输入的参数创建不同的产品 工厂方法:由工厂实例方法创建具体某个产品 抽象工厂:由工厂示例方法创建多个产品
  • 工厂模式一般分为简单工厂模式,工厂方法模式,抽象工厂模式。各有优缺点,今天这里还加入了简单工厂模式的另一种实现,添加反射实现简单工厂。 例子  一个很简单的例子:有个富豪想买奔驰,宝马,福特汽车,开...
  • 常用设计模式-抽象工厂

    万次阅读 2020-11-19 17:18:48
    模式简介 工厂模式主要是为创建对象提供了接口。...抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂工厂。 在抽象工厂模式中,接口是负责创建一
  • 深入理解工厂模式——由对象工厂生成对象

    万次阅读 多人点赞 2018-05-27 20:12:45
    工厂模式介绍 1.1 工厂模式的定义 1.2 工厂模式的分类: 1.3 在开源框架中的使用 1.4 为什么要用工厂模式 二 简单工厂模式 2.1 介绍 2.2 适用场景 2.3 简单工厂模式角色分配: 2.4 简单工厂实例 2.5 使用反射...
  • 常用设计模式-工厂方法

    万次阅读 2020-11-19 14:12:05
    模式简介 工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法...与简单工厂模式相比,简单工厂模式使得工厂的负担过重,而且每次添加新产品,都需要修改工厂,不符合开闭原则。 工厂方法模式
  • 文章目录简单工厂(非模式,像编程习惯)工厂方法模式抽象工厂模式 除了使用new操作符之外,还有更多制造对象的方法。你将了解到实例化这个活动不应该总是公开的进行,也会认识到初始化经常造成“耦合”问题。 简单...
  • 抽象工厂中产品有产品族的概念,比如车辆类型族(运动型、舒适型),车辆品牌族(宝马、奔驰),族和族可以互相组合,所以抽象工厂中具体工厂可以以侧重点命名SportDriver和BusinessDriver,然后在Sport里面用方法...
  • 简单工厂方法、工厂方法以及抽象工厂方法的区别
  • 设计模式(二):几种工厂模式详解

    万次阅读 2020-05-10 21:07:43
    工厂顾名思义就是创建产品,根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式,根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建,是一种创建型模式。 工厂...
  • 简单工厂模式、工厂模式和抽象工厂模式 1. 简单工厂模式 简单工厂模式属于创建型模式,是工厂模式的一种。简单工厂模式定义了一个创建对象的类,由这个类来封装实例化对象的行为。它是由一个工厂对象决定创建出哪一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,028
精华内容 66,011
关键字:

工厂