精华内容
下载资源
问答
  • 反射机制与抽象工厂结合多数据库模型源码 反射机制与抽象工厂结合多数据库模型源码
  • 抽象工厂模型demo

    2015-09-11 10:19:16
    抽象工厂类的使用,简单的demo,方便初学者理解,设计模式。
  • 抽象工厂模型

    2020-05-24 15:29:16
    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂其他工厂。其他工厂生成产品(工厂模型),这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 二、现实生活举例    &...

    抽象工厂模型

    一、什么是抽象工厂模型
            抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂其他工厂。其他工厂生成产品(工厂模型),这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    二、现实生活举例
            有一个厂商专门生成鼠标和键盘,其旗下有俩个公司,分别是戴尔和惠普俩个工厂,分别生产戴尔鼠标、戴尔键盘和惠普鼠标、惠普键盘。

    三、优缺点
    (1)当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
    (2)产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator(工厂类) 里加代码,又要在具体的里面加代码。

    四、实现方法
    步骤一:定义俩个接口

    //戴尔产品
    public interface Daleproduct {
       void daleproduct();
    }
    
    //惠普产品
    public interface Hpproduct {
       public void hpproduct();
    }
    
    

    步骤二:接口实现类

    public class Dale_Mouse implements Daleproduct{
    	public void daleproduct() {
    		 System.out.println("生产一个戴尔品牌鼠标");	
    	}
    }
    	
    public class Dale_Keyboard implements Daleproduct{
    	public void daleproduct() {
    		System.out.println("生产一个戴尔品牌键盘");	
    	}
    }
    
    public class Hp_Mouse implements Hpproduct {
    	public void hpproduct() {
    		System.out.println("生产一个惠普品牌鼠标");	
    	}
    }
    
    public class Hp_Keyboard implements Hpproduct {
    	public void hpproduct() {
    		System.out.println("生产一个惠普品牌键盘");	
    	}
    }
    
    

    步骤三:创建抽象工厂

    //为 Dale  和 Hp  对象创建抽象类来获取工厂。
    public abstract class AbstractFactory {
        public abstract Dale  getdale(String dale );
        public abstract Hp  gethp(String hp );
    }
    

    步骤四:创建戴尔和惠普工厂

    //戴尔工厂
    public class Dalefactory extends  AbstractFactory{
    	public Dale  getdale(String dale) {
    		if(dale==null){
    			return null;
    		}else if(dale.equalsIgnoreCase("DALE_MOUSE")){
    			return new Dale_Mouse(); 
    		}else if(dale.equalsIgnoreCase("DALE_KEYBOARD")){
    			return new Dale_Keyboard();
    		}
    		return null;
    	}
    	public Hp gethp(String hp) {
    		return null;
    	}
    }
    
    //惠普工厂
    public class Hpfactory extends  AbstractFactory{
    	public dale getdale(String dale) {
            return null;
            }
    	public Hp gethp(String hp) {
    		if(hp==null){
    			return null;
    		}else if(dale.equalsIgnoreCase("HP_MOUSE")){
    			return new Hp_Mouse(); 
    		}else if(dale.equalsIgnoreCase("HP_KEYBOARD")){
    			return new Hp_Keyboard();
    		}
    		return null;
    	   }
    	}
    

    步骤五:超级工厂(生产惠普和戴尔工厂)

    public class Supperfactory {
      public static AbstractFactory getfactory(String choice){
    	  if(choice.equalsIgnoreCase("DALEFACTORY")){
    		  return new Dalefactory ();
    	  }else if(choice.equalsIgnoreCase("HPFACTORY")){
    		  return new Hpfactory();
    	  }else if(choice==null){
    		  return null;
    	  }
    	  return null;
      }
    }
    

    步骤六:测试(生产产品)

    public class Demo {
       public static void main(String[] args) {
    	//获取戴尔工厂
    	AbstractFactory dale_factory=SupperProducer.getfactory("DALEFACTORY");
    	//生产戴尔产品
    	Dale_Mouse dmouse=dale_factory.getdale("DALE_MOUSE");
    	Dale_Keyboard dkeyboard=dale_factory.getdale("DALE_KEYBOARD");
    	dmouse.daleproduct();
    	dkeyboard.daleproduct();
    	
    	
    	//获取惠普工厂
    	AbstractFactory hp_factory=FactoryProducer.getfactory("HPFACTORY");
    	//生产惠普产品
    	Hp_Mouse hmouse=hp_factory.getdale("HP_MOUSE");
    	Hp_Keyboard hkeyboard=hp_factory.getdale("HP_KEYBOARD");
    	hmouse.hpproduct();
    	hkeyboard.hpproduct();
        }
    }
    

    输出结果:
    在这里插入图片描述

    欢迎访问我的个人博客

    展开全文
  • 什么是工厂模式? 工厂模式的设计思想就是建造一个工厂来创建和管理对象,用工厂创建来代替new对象。调用者不需要知道对象的具体创建过程。 传统思想:需要使用new()方法来实例化一个对象,这个可以适用于简单对象...

    什么是工厂模式?
    工厂模式的设计思想就是建造一个工厂来创建和管理对象,用工厂创建来代替new对象。调用者不需要知道对象的具体创建过程。

    • 传统思想:需要使用new()方法来实例化一个对象,这个可以适用于简单对象的创建,不适合复杂对象的创建,比如参数过多的话,调用者就会在实例化对象上耗时,而且容易出错。
    • 工厂设计模式:创建一个对象工厂,用来创建对象和管理对象,这样有利于对象的维护和解耦,而且调用者可以更加专注于业务的实现,不用在创建对象上耗时。

    工厂模式有以下几种
    **

    简单工厂

    **
    简单工厂如下图
    在这里插入图片描述
    对象工厂创建对象A和对象B,调用者只需要在对象工厂中获取到想要的对象即可。

    优点:对象工厂统一管理对象,易维护;易扩展,如果想添加一个对象C,只需要创建一个对象C具体类,然后在对象工厂中创建一个对象C即可.还有一个就是解耦.日常使用的简单工厂最多.

    缺点:不符合设计模式的开闭规则,像添加一个对象的时候需要在对象工厂中修改代码.

    代码详解:
    先创建一个手机的公共接口,也就是手机类都有的功能,比如电话,发信息子类的

    public interface mobilePart {
        //发信息
        void sendMessage();
        //打电话
        void phone();
    }
    

    然后创建每一类手机的具体类.也就是实现上面的公共接口方法

    //vivo手机
    public class vivoMobile implements mobilePart{
        @Override
        public void sendMessage() {
            System.out.println("vivo手机可以发信息");
        }
    
        @Override
        public void phone() {
            System.out.println("vivo手机可以打电话");
        }
    }
    
    
    //华为手机
    public class huaweiMobile implements mobilePart{
        @Override
        public void sendMessage() {
            System.out.println("华为手机可以发信息");
        }
    
        @Override
        public void phone() {
            System.out.println("华为手机可以打电话");
        }
    }
    

    创建手机的具体类之后就需要创建一个手机工厂来统一管理这些手机.

    public class mobileFactory {
        public static mobilePart factory(int Swi){
            if (Swi == 1) return new vivoMobile();
            if(Swi == 2) return new huaweiMobile();
            return null;
         }
    }
    

    创建手机工厂之后,用户就不需要自己去new一个手机出来了,用户要什么手机直接去手机工厂拿就行了.

    public class client {
        public static void main(String[] args) {
            mobilePart factory = mobileFactory.factory(1);
            factory.sendMessage();
            mobilePart factory1 = mobileFactory.factory(2);
            factory1.sendMessage();
        }
    }
    

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

    工厂方法模型

    工厂方法模型是对简单工厂的进阶,工厂方法模型满足oop设计原则,满足开闭原则. 工厂方法模型是每一个具体类都有一个对应的对象工厂.
    优点: 解耦,比简单工厂更加贴近业务方面和日常需求.

    **缺点:**当创建一个产品的话,需要创建其具体类和相对应的具体类对象管理工厂,当产品多的话,代码会显得复杂.

    简单工厂和工厂方法对比:

    • 简单工厂比工厂方法易维护,因为对象都在一个对象工厂中创建和维护.
    • 简单工厂比工厂方法易扩展,简单方法只需要创建一个具体类和在对象工厂声明对象就行了.而工厂方法需要创建一个具体类还需要创建一个声明具体类的工厂.
    • 简单工厂不遵循开闭原则,工厂方法遵循oop设计原则
    • 工厂方法的业务逻辑比简单工厂的强.
      在这里插入图片描述
      调用者如果需要对象A就去对象A工厂获取,如果需要对象B就去对象B工厂获取.

    工厂模型代码详解
    具体类没有变,只是每一个具体类都要其想对应对象创建工厂
    华为工厂

    public class huaweiFactory {
        public static mobilePart getHuaWei(){
            return new huaweiMobile();
        }
    }
    

    vivo工厂

    public class vivoFactory {
        public static mobilePart getViVo(){
            return new vivoMobile();
        }
    }
    

    抽象工厂模式

    抽象工厂模式也可以成为超级工厂,因为抽象工厂模式是管理工厂对象的.
    抽象工厂的使用场景:一般是固定的族产品, 抽象工厂的扩展性很差.
    声明是族产品,比如电子产品就是一个族,电子产品包括手机,路由器这些.
    在这里插入图片描述
    比如想要对象A,调用者就可以在超级工厂中找到对象A工厂的对象,然后获取到对象A. 抽象工厂设计模式一般用于不怎么变化的族产品.

    展开全文
  • 抽象工厂模式模型

    2020-06-19 10:25:28
  • 抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 举一个电脑产品的例子吧: IBM,Dell都是著名的计算机生产厂家,他们采用的主板、硬盘及CPU是不相同的,但是配件间、主板...

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

    举一个电脑产品的例子吧:

    IBMDell都是著名的计算机生产厂家,他们采用的主板、硬盘及CPU是不相同的,但是配件间、主板与CPU一定要相互兼容,例如下面例子中的微星MSIK7N2G配AMD的CPU;微星MSI865PE配Intel的CPU。

    如图中所示,ComputerFactory是抽象工厂,DellIBM是生产产品的工厂;CPU、HardDisk、MainBoard是抽象产品,CPU的型号又分许多种。具体实现见代码:

    //首先,定义CPU的接口:
    
    public interface CPU{
    
        public String getCPU();
    
    }
    
    //定义AMD类,实现CPU接口:
    
    public class AMD implements CPU{
    
        public String getCPU(){
    
            return “Athlon XP 2008+”;
    
        }
    
    //定义Intel类,实现CPU接口:
    
    public class Intel implements CPU{
    
        public String getCPU(){
    
            return “奔腾4 3.2C”;
    
        }
    
    }
    
    //定义硬盘接口:
    
    public interface HardDisk{
    
        public String getSize();
    
    }
    
    //定义Maxtor类,实现硬盘接口:
    
    public class Maxtor implements HardDisk{
    
        public String getSize(){
    
            return “MaXLine Plus II 200G”;
    
        }
    
    }
    
    //定义WestDigit,实现硬盘接口:
    
    public class WestDigit implements HardDisk{
    
        public String getSize(){
    
            return “WD2500JD 250G”;
    
        }
    
    }
    
    //定义主板的接口,包含参数为CPU的公共方法Attach():
    
    public interface MainBoard{
    
        public void Attach(CPU cpu) throws Exception;
    
    }
    
    //主板微星MSI865PE,支持Intel的CPU:
    
    public class MSI865PE implements MainBoard{
    
        public void Attach(CPU cpu) throws Exception{
    
            if(cpu.getClass ().toString ().endsWith(“Intel”)){
    
                System.out.println(“MSI865PE”);
    
            }
    
             else{
    
                throw new Exception(“主板MSI865PE只能配Intel的                                        CPU”);
    
            }
    
        }
    
    }
    
    //主板微星MSIK7N2G,支持AMD的CPU:
    
    public class MSIK7N2G implements MainBoard{
    
        public void Attach(CPU cpu) throws Exception{
    
            if(cpu.getClass ().toString ().endsWith(“AMD”)){
    
                System.out.println(“MSIK7N2G”);
    
            }
    
            else{
    
                throw new Exception(“主板MSIK7N2G只能配AMD的CPU”);
    
            }
    
        }
    
    }
    
    //定义抽象电脑工厂类:
    
    public abstract class ComputerFactory{
    
        CPU cpu;
    
        HardDisk hd;
    
        MainBoard mb;
    
    public void show(){
    
            try{
    
                System.out.println(this.getClass().getName() .toString () + (“生产的电脑配置”);
    
                System.out.println (“CPU:” + cpu.getCPU ());
    
                System.out.println (“HardDisk:” + hd.getSize ());
    
                System.out.print (“MainBoard:”);
    
                mb.Attach.(cpu);
    
            }
    
    catch(Exception e){
    
                System.err.println(e.getMessage());
    
            }
    
        }
    
    }
    
    //抽象电脑工厂类派生类IBM,定义其返回的系列配件产品:
    
    public class IBM extends ComputerFactory{
    
        IBM(){
    
            cpu = new Intel();
    
            hd = new WestDigit();
    
            mb = new MSI865PE();
    
        }
    
    }
    
    //抽象电脑工厂类派生类Dell,定义其返回的系列配件产品:
    
    public class Dell extends ComputerFactory{
    
        Dell(){
    
            cpu = new AMD();
    
            hd = new Maxtor();
    
            mb = new MSIK7N2G();
    
        }
    
    }
    
    //客户程序调用:
    
    Public class Client{
    
        public static void main(String argv[]){
    
            IBM ibm = new IBM();
    
            ibm.show();
    
            Dell dell = new Dell();
    
            dell.show();
    
        }
    
    }

     


    输出结果为:

    Computerworld.IBM生产的电脑配置

    CPU:奔腾4 3.2C

    HardDisk:WD2500JD 250G

    MainBoard:MSI865PE

    Computerworld.Dell生产的电脑配置

    CPU:Athlon XP 2800+

    HardDisk:MaXLine Plus II 200G

    MainBoard:MSIK7N2G

     

     

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

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

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

    转载于:https://www.cnblogs.com/cangqiongbingchen/p/4727999.html

    展开全文
  • 简单工厂、工厂方法、抽象工厂、策略模式、策略工厂的区别 结合简单示例和UML图,讲解工厂模式简单原理。   一、引子 话说十年前,有一个爆发户,他家有三辆汽车(Benz(奔驰)、Bmw(宝马)、Audi...
  • 工厂方法和抽象工厂区别

    千次阅读 2019-07-04 22:50:42
    抽象工厂 定义 :抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类 创建型 :创建型 适用场景: 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节 强调一系列相关的...
  • 抽象工厂,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。对于工厂方法来说,抽象工厂可实现一系列产品的生产,抽象工厂更注重产品的组合。 看代码: 7.1.解释 main(),女娲 IHuman,...
  • 工厂方法模式通过引入工厂等级结构,解决了简单工厂模式中工厂类职责太重的...此时,我们可以考虑将一些相关的产品组成一个“产品族,由同一个工厂来统一生产,这就是我们本文将要学习的抽象工厂模式的基本思想。 ...
  • 抽象工厂模式

    2016-10-28 19:21:02
    抽象工厂模式
  • 标签: 设计模式 1. 工厂模式  创建型模式,调用者新建对象时使用,不需要new具体对象,只需要先获取一个工厂,从工厂... 创建型模式,抽象工厂是一个生成工厂的工厂,一般是存在多种工厂时使用。调用者先获取一...
  • 抽象工厂模式(AbstractFactory) 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式...
  • (3)抽象工厂方法   UML设计图     核心实现代码 (1)抽象工厂类 public abstract class AbstractFactory { public abstract AbstractPhone getPhone(); public abstract AbstractWatch ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,385
精华内容 22,154
关键字:

抽象工厂与工厂模型的区别