工厂模式 订阅
工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑使用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改量。 展开全文
工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑使用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改量。
信息
本    质
工厂方法代替new操作
类    别
管理模式
俗    称
实例化对象模式
中文名
工厂模式
实    例
Jive论坛
外文名
Factory Method
工厂模式编程开发
工厂模式定义我们以类Sample为例, 如果我们要创建Sample的实例对象:Sample sample=new Sample();可是,实际情况是,通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。首先,我们想到的是,可以使用Sample的构造函数,这样生成实例就写成:Sample sample=new Sample(参数);但是,如果创建sample实例时所做的初始化工作不是像赋值这样简单的事,可能是很长一段代码,如果也写入构造函数中,那你的代码很难看了(就需要Refactor重构)。为什么说代码很难看,初学者可能没有这种感觉,我们分析如下,初始化工作如果是很长一段代码,说明要做的工作很多,将很多工作装入一个方法中,相当于将很多鸡蛋放在一个篮子里,是很危险的,这也是有悖于Java面向对象的原则,面向对象的封装(Encapsulation)和分派(Delegation)告诉我们,尽量将长的代码分派“切割”成每段,将每段再“封装”起来(减少段和段之间耦合联系性),这样,就会将风险分散,以后如果需要修改,只要更改每段,不会再发生牵一动百的事情。在本例中,首先,我们需要将创建实例的工作与使用实例的工作分开, 也就是说,让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。这时我们就需要Factory工厂模式来生成对象了,不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:ISample mysample=new MySample();ISample hissample=new HisSample();随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
收起全文
精华内容
参与话题
问答
  • 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你...

     在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况,新对象的建立就是一个 “过程”,不仅是一个操作,像一部大机器中的一个齿轮传动。

     

    模式的问题:你如何能轻松方便地构造对象实例,而不必关心构造对象实例的细节和复杂过程呢?

    解决方案:建立一个工厂来创建对象

    实现:

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

       4)抽象工厂模式时代:随着客户的要求越来越高,宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

       最终是客户只要对宝马的销售员说:我要523i空调车,销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.

       这就是工厂模式。

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

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

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

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

    三、区别 
    工厂方法模式:
    一个抽象产品类,可以派生出多个具体产品类。   
    一个抽象工厂类,可以派生出多个具体工厂类。   
    每个具体工厂类只能创建一个具体产品类的实例。
    抽象工厂模式:
    多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。   
    一个抽象工厂类,可以派生出多个具体工厂类。   
    每个具体工厂类可以创建多个具体产品类的实例。   
    区别:
    工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。   
    工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
    两者皆可。 

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

     

     

    public class BMW320 {
    	public BMW320(){
    		System.out.println("制造-->BMW320");
    	}
    }
    
    public class BMW523 {
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }
    
    public class Customer {
    	public static void main(String[] args) {
    		BMW320 bmw320 = new BMW320();
    		BMW523 bmw523 = new BMW523();
    	}
    }
    

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

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

    产品类:

    abstract class BMW {
    	public BMW(){
    		
    	}
    }
    
    public class BMW320 extends BMW {
    	public BMW320() {
    		System.out.println("制造-->BMW320");
    	}
    }
    public class BMW523 extends BMW{
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }
    

    工厂类:

    public class Factory {
    	public BMW createBMW(int type) {
    		switch (type) {
    		
    		case 320:
    			return new BMW320();
    
    		case 523:
    			return new BMW523();
    
    		default:
    			break;
    		}
    		return null;
    	}
    }


    客户类:

    public class Customer {
    	public static void main(String[] args) {
    		Factory factory = new 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 class BMW {
    	public BMW(){
    		
    	}
    }
    public class BMW320 extends BMW {
    	public BMW320() {
    		System.out.println("制造-->BMW320");
    	}
    }
    public class BMW523 extends BMW{
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }


    创建工厂类:

    interface FactoryBMW {
    	BMW createBMW();
    }
    
    public class FactoryBMW320 implements FactoryBMW{
    
    	@Override
    	public BMW320 createBMW() {
    
    		return new BMW320();
    	}
    
    }
    public class FactoryBMW523 implements FactoryBMW {
    	@Override
    	public BMW523 createBMW() {
    
    		return new BMW523();
    	}
    }
    


    客户类:

    public class Customer {
    	public static void main(String[] args) {
    		FactoryBMW320 factoryBMW320 = new FactoryBMW320();
    		BMW320 bmw320 = factoryBMW320.createBMW();
    
    		FactoryBMW523 factoryBMW523 = new FactoryBMW523();
    		BMW523 bmw523 = factoryBMW523.createBMW();
    	}
    }


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

    参考http://blog.csdn.net/hguisu/article/details/7505909

     

    以上就是简单工厂模式,工厂方法模式,抽象工厂模式在这里

     

    更多设计模式:23种设计模式系列

    作者:jason0539

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

     

    展开全文
  • 工厂方法模式、简单工厂模式、抽象工程模式

    千次阅读 多人点赞 2018-04-07 22:11:06
    工厂设计模式是一种创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 针对的问题:在面向对象编程中,最...

    1.概述

    工厂设计模式是一种创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象

    1.1. 针对的问题

    在面向对象编程中,最常用的方法是new一个操作符产生一个对象实例,new对象操作符就是用来构造对象实例的,但是在一些情况下,new操作符直接生成对象会带来一些问题,举例说,许多类型对象的创建都需要一系列的步骤,可能需要计算或取得对象的初始设置,选择生成哪个子对象实例,或者在生成需要的对象之前必须先生成一些辅助功能的对象,这些情况下,对象的建立就是一个过程,不仅是一个操作。

    1.2. 分析

    这里写图片描述
    上图就是没有工厂模式时,用户需要自己new一辆车,这样,车和人就耦合在了一起。
    那么怎么能够方便的构建对象实例,而不关心构造对象实例的细节和复杂过程呢,那就是建立一个工厂来创建对象。把创建的过程封装到工厂里。

    1.3. 工厂模式类型

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

    1. 简单工厂模式
    2. 工厂方法模式
    3. 抽象工厂模式

    一般将简单工厂模式看为工厂方法模式的一种特例,二者归为一类。

    2. 三种工厂模式特征及实现

    2.1 简单工厂模式

    2.1.1. 角色组成

    这里写图片描述

    1. 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑,用来创建产品

    2. 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。

    3. 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

    2.1.2. 实现
    //产品类
    abstract class BMW{
    	public BMW(){}
    }
    
    //具体产品类
    public class BMW100 extends BMW{
    	public BMW100(){
    	    System.out.println("this is BMW100");
    	}
    }
    public class BMW200 extends BMW{	
    	public BMW200(){
    		System.out.println("this is BMW200");
       }
    }
    
    //工厂类
    public class Factory{
    	public BMW CreateBMW(int type){
    		if(type ==100) return new BMW100();
    		if(type ==200) return new BMW200();
    		else return null;
        }
    }
    
    
    2.1.3. 分析

    在简单工厂中,当客户不再满足现有的车型号时,想要一种更快的车,只要这种车满足抽象产品指定的规则,只要通知工厂类增加相应的逻辑就好了,但是每增加一种车,都要在工厂类中增加相应的逻辑,工厂类十分被动,这样的工厂类成为全能类或者上帝类。

    2.2 工厂方法模式

    2.2.1. 角色构成

    1)抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

    2)具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

    3)抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

    4)具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

    工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的上帝类,分担了对象承受的压力。

    2.2.2. 实现
    //抽象产品类
    abstract class BMW()
    {
        public BMW();
    }
    
    // 具体产品类 四种车,宝马1系,(两种),2系(两种)
    public class BMW100 extends BMW
    {
    	public BMW100()
    	{
    		System.out.println("this is BMW100");
    	}
    }
    public class BMW109 extends BMW
    {
    	public BMW109()
    	{
    		System.out.println("this is BMW100");
    	}
    }
    public class BMW200 extends BMW
    {
    	public BMW200()
    	{
    		System.out.println("this is BMW200");
    	}
    }
    public class BMW209 extends BMW
    {
    	public BMW209()
    	{
    		System.out.println("this is BMW209");
    	}
    }
    
    
    //抽象工厂角色
    interface Factory
    {
        BMW createBMW();
    }
    
    //具体工厂角色
    public class FactoryBMW1 implements FactoryBMW{  
      
        @Override  
        public BMW100 createBMW() {  
            return new BMW100();  
        }  
      
    }  
    public class FactoryBMW2 implements FactoryBMW {  
        @Override  
        public BMW200 createBMW() {  
      
            return new BMW200();  
        }  
    }   //分为100的工厂和200的工厂(省略了两个工厂)。都实现了工厂的接口
    
    
    2.2.3. 分析

    想加一辆车,就单独加车的类,这个车的工厂,然后只修改客户端的代码即可。工厂方法模式实现时,客户端需要决定实例化哪一个工厂来创建对象,工厂方法把简单工厂的内部逻辑移到了客户端代码来执行。

    2.3. 抽象工厂模式

    抽象工厂模式是工厂方法模式的升级版本,它用来创建一组相关或者相互依赖的对象。

    抽象工厂模式提供一个创建一系列相关或者相互依赖对象的接口,而无需指定他们具体的类。就是一个工厂里放一些相关的类,使工厂数减少

    最大的好处便是易于交换产品系列,其次是让具体的创建实例过程与客户端分离,客户端通过他们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离。不会出现在客户代码中

    2.3.1. 角色

    这里写图片描述

    2.3.2. 实现

    抽象工厂方法就是一个工厂里生产不同等级结构中的一个(其中一种车)中的不同的配件(不同的车的属性)

    //抽象产品类1 发动机以及型号    
    public interface Engine {    
      
    }    
    //抽象产品类2 空调以及型号    
    public interface Aircondition {    
      
    }
    
    //具体产品类
    public class EngineA extends Engine{    
        public EngineA(){    
            System.out.println("制造-->EngineA");    
        }    
    }    
    public class EngineB extends Engine{    
        public EngineB(){    
            System.out.println("制造-->EngineB");    
        }    
    }  
        
    public class AirconditionA extends Aircondition{    
        public AirconditionA(){    
            System.out.println("制造-->AirconditionA");    
        }    
    }    
    public class AirconditionB extends Aircondition{    
        public AirconditionB(){    
            System.out.println("制造-->AirconditionB");    
        }    
    }
    
    //抽象工厂    
    public interface AbstractFactory {    
        //制造发动机  
        public Engine createEngine();  
        //制造空调   
        public Aircondition createAircondition();   
    }    
    
    
    //具体工厂类  
    public class 奔驰工厂 implements AbstractFactory{    
            
        @Override    
        public Engine createEngine() {      
            return new EngineA();    
        }    
        @Override    
        public Aircondition createAircondition() {    
            return new AirconditionA();    
        }    
    }    
    //为宝马车生产配件
    public class 宝马工厂 implements AbstractFactory {    
        
         @Override    
        public Engine createEngine() {      
            return new EngineB();    
        }    
        @Override    
        public Aircondition createAircondition() {    
            return new AirconditionB();    
        }    
    }
    
    2.3.3. 分析

    抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

    展开全文
  • 工厂模式

    千次阅读 2018-04-07 21:29:04
    一开始学工厂模式的时候一点也不明白,看了很多文章问了很多人为什么要使用工厂模式?为什么工厂模式就是解耦?看了几天有了点个人的理解,故写下来防止以后忘记。如果有什么不对或者理解不到位的地方,希望大神可以...

    一开始学工厂模式的时候一点也不明白,看了很多文章问了很多人为什么要使用工厂模式?为什么工厂模式就是解耦?看了几天有了点个人的理解,故写下来防止以后忘记。如果有什么不对或者理解不到位的地方,希望能告知。

    1.工厂模式的本质

    工厂模式又称为创建模式,它是建对象的一种最佳方式。工厂模式的本质就是用工厂方法代替new操作创建一种实例化对象的方式。一句话中总结就是方便创建 同种类型接口产品 的 复杂对象

    举例:实例化一个对象sample 一般会想到的方法是通过构造器来创建sample s=new sample();但是在实际情况下最好不要这样做,如果sample类的在实例化的时候需要初始化参数而这些参数需要别的类的信息,这样你new的话会增加你代码的耦合度,不利于维护。所以我们就需要将创建实例的工作和使用使用实例的工作分开,即:使用工厂方法创建实例的工作封装起来。这样我们在需要调用对象的时候就不需要关心那些复杂的实例化问题。
    接下来介绍具体有哪些工厂

    1.简单工厂模式(静态工厂模式)

    简单工厂模式中有抽象产品类:用来定义具体产品的共有属性,工厂类则负责生产具体产品。
    直接看代码:定义一个抽象产品类形状类Shape

    abstract class Shape(){
    public  abstract void shape();
    

    定义具体产品:

    class Circle extends Shape{
    	public void shape(){
    		System.out.println("圆形");
    	}
    }
    class Rectangle extends Shape{
    	public void shape(){
    		System.out.println("矩形");
    	}
    }
    class Triangle extends Shape{
    	public void shape(){
    		System.out.println("三角形");
    	}
    }
    

    定义一个工厂生产具体产品

    public class ShapeFactory{
    	public static Shape getshape(String sh){
    		if(sh.equals("圆形")){
    			return new Circle();
    		}else if(sh.equals("矩形")){
    			return new Rectangle();
    		}else if(sh.equals("三角形")){
    			return new Triangle();
    		}else {
    			return  null;
    		}
    	}
    	public static void main(String args[]){
    		ShapeFactory.getshape("圆形").shape();
    	}
    }
    output:圆形
    
    • 从简单工厂中我们可以看出使用一个静态方法将实例化的创建和使用分离开。我们只需要调用方法传递参数就可以获得我们需要的对象。
    • 缺点:我们不难看出如果我们想要增加一个形状类的产品不仅需要添加一个导出类而且我们必须要修改静态方法getshape,这样就违背了开闭原则(对于扩展是开放的,对于修改是封闭的)

    这时我们就可以想我们是不是可以将工厂也抽象出来?让具体工厂来负责创建具体产品对象,就上面的例子我们可以创建一个圆形的具体工厂让他只负责创建圆形产品对象,这样当我们想要增加一个产品的时候我们就只需要增加对应的工厂就行了,不需要修改其他东西。接下来我们说说工厂模式

    2.工厂模式

    就如上面所说的我们先了解工厂模式的具体概念:

    • 抽象工厂:工厂模式的核心,提供一个创建对象的接口,任何需要创建对象的具体工厂都要实现这个接口。
    • 具体工厂:实现抽象工厂接口的类,受到调用者的调用从而创建对象。
    • 抽象产品:工厂方法模式所创建的对象的超类。也就是所有具体产品的共同父类。
    • 具体产品:实现抽象工厂接口的类。工厂模式中所有创建的对象都是具体产品的实例。

    抽象产品Shape

    abstract class Shape {
    public  abstract void shape();
    }
    

    具体产品:

    class Circle extends Shape{
    	public void shape(){
    		System.out.println("圆形");
    	}
    }
    class Rectangle extends Shape{
    	public void shape(){
    		System.out.println("矩形");
    	}
    }
    class Triangle extends Shape{
    	public void shape(){
    		System.out.println("三角形");
    	}
    }
    

    抽象工厂:

    abstract class ShapeFactory{
    	public abstract Shape CreatShape();
    }
    

    具体工厂:

    class CircleFactory extends ShapeFactory{
    	public Shape CreatShape(){
    		return new Circle();
    	}
    }
    class RectangleFactory extends ShapeFactory{
    	public Shape CreatShape(){
    		return new Rectangle();
    	}
    }
    class TriangleFactory extends ShapeFactory{
    	public Shape CreatShape(){
    		return new Triangle();
    	}
    }
    

    测试:

    public class ShapeFactoryDemo{
    	public static void getshape(ShapeFactory sha){
    		sha.CreatShape().shape();
    	}
    	public static void main(String args[]){
    		getshape(new CircleFactory());
    	}
    }
    

    如上所示:即使我们增加一个新的形状类,我们也只需要增加相应的工厂类,不需要修改代码的任何方法。当我们需要这个新产品的时候我们只需要getshap(new 新的工厂类),其他的我们不用去关心,不需要了解方法的实现,对象是如何创建的,我们只需要调用方法就行了——良好的封装性。
    优点:

    1. 良好的封装性:如上面所说。
    2. 可以是代码结构变得清晰,有效的封装变化,通常new一个具体类是很复杂多变的,通过工厂方法将new的过程封装在具体工厂的方法中,调用者无须知道实例化的过程,只需要调用方法就可以得到自己想要的产品。

    有很多文章说工厂模式就是一种典型的解耦模式,对于这点我不是很清楚:抽象产品和抽象工厂之间是没有耦合问题,但是抽象工厂将耦合问题传给了具体工厂啊!具体工厂中的方法就是new出具体产品的实例,他们之间任然有耦合。这点我不是很明白,或许我的理解有问题。

    • 用到工厂模式的地方:

    1.创建对象的复杂度高。
    2.创建对象时需要增加依赖关系,就是说需要某些信息而这些信息不在复合类中。
    3.当系统需要比较好的延展性的时候。

    展开全文
  • 24种设计模式-工厂模式(3种)

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

    工厂方法模式(Factory Method)

    工厂方法模式分为三种:

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

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

    首先,创建二者的共同接口:
    public interface Sender {  
        public void Send();  
    }  
    
    其次,创建实现类:
    public class MailSender implements Sender {  
        @Override  
        public void Send() {  
            System.out.println("this is mailsender!");  
        }  
    }  
    public class SmsSender implements Sender {  
      
        @Override  
        public void Send() {  
            System.out.println("this is sms sender!");  
        }  
    }  
    
    
    最后,建工厂类:
    public class SendFactory {  
      
        public Sender produce(String type) {  
            if ("mail".equals(type)) {  
                return new MailSender();  
            } else if ("sms".equals(type)) {  
                return new SmsSender();  
            } else {  
                System.out.println("请输入正确的类型!");  
                return null;  
            }  
        }  
    }  
    
    
    我们来测试下:
    public class FactoryTest {  
      
        public static void main(String[] args) {  
            SendFactory factory = new SendFactory();  
            Sender sender = factory.produce("sms");  
            sender.Send();  
        }  
    }  
    输出:this is sms sender!

     

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

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

    public class SendFactory {  
       public Sender produceMail(){  
            return new MailSender();  
        }  
          
        public Sender produceSms(){  
            return new SmsSender();  
        }  
    }  
    
    测试类如下:
    public class FactoryTest {  
      
        public static void main(String[] args) {  
            SendFactory factory = new SendFactory();  
            Sender sender = factory.produceMail();  
            sender.Send();  
        }  
    }  
    
    输出:this is mailsender!

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

    public class SendFactory {  
          
        public static Sender produceMail(){  
            return new MailSender();  
        }  
          
        public static Sender produceSms(){  
            return new SmsSender();  
        }  
    }  
    
    public class FactoryTest {  
      
        public static void main(String[] args) {      
            Sender sender = SendFactory.produceMail();  
            sender.Send();  
        }  
    }  
    
    输出:this is mailsender!

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

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

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

    请看例子:

    public interface Sender {  
        public void Send();  
    }  
    
    
    两个实现类:
    public class MailSender implements Sender {  
        @Override  
        public void Send() {  
            System.out.println("this is mailsender!");  
        }  
    }  
    
    public class SmsSender implements Sender {  
      
        @Override  
        public void Send() {  
            System.out.println("this is sms sender!");  
        }  
    }  
    
    
    两个工厂类:
    public class SendMailFactory implements Provider {  
          
        @Override  
        public Sender produce(){  
            return new MailSender();  
        }  
    }  
    
    public class SendSmsFactory implements Provider{  
      
        @Override  
        public Sender produce() {  
            return new SmsSender();  
        }  
    }  
    
    
    在提供一个接口:
    public interface Provider {  
        public Sender produce();  
    }  
    
    
    测试类:
    public class Test {  
      
        public static void main(String[] args) {  
            Provider provider = new SendMailFactory();  
            Sender sender = provider.produce();  
            sender.Send();  
        }  
    }  
    


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

     

    原文地址:https://blog.csdn.net/llussize/article/details/80276627

     

    楼主这么辛苦,请扫一下楼主的支付宝红包推荐码吧。

    1、打开支付宝首页搜索“8282987” 立即领红包。

     

    展开全文
  • 抽象工厂模式:我们现在要对mysql/oracle数据库中的User表进行操作,User表定义如下:public class User { private int uid; private String uname; public int getUid() { return uid; } public void set...
  • 工厂方法模式

    千次阅读 2019-05-31 20:40:44
  • 工厂模式 五种写法总结

    千次阅读 2018-08-31 16:42:45
    属于创建型设计模式,需要生成的对象叫做产品 ,生成对象的地方叫做工厂 。 使用场景: 在任何需要生成复杂对象的地方,都可以使用工厂方法模式。 直接用new可以完成的不需要用工厂模式 个人理解,重点就是这个...
  • 工厂模式的简单demo

    2020-11-17 21:06:44
    工厂模式 在创建对象的同时隐藏创建逻辑的方式,而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。 工厂模式主要是为创建对象提供过渡接口,以便将创建对象的...
  • 工厂模式概述 工厂模式的主要解决的问题是,将原来分布在各个地方的对象创建过程单独抽离出来,交给工厂类负责创建。其他地方想要使用对象直接找工厂(即调用工厂的方法)获取对象。 工厂模式的三种类型 工厂模式...
  • java工厂模式三种详解(部分转载)

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

    千次阅读 2019-04-09 09:22:07
    1简单工厂: 用于没有产品族而且产品个数较少时   专门定义一个类(第三方)用来创建其他类实例,被创建的实例通常具有共同的父类。 例子:在这里我们相当于是创建生产电脑的工厂,客户需要购买什么样的电脑,只要...
  • 什么是工厂模式

    千次阅读 2018-08-31 12:14:27
    工厂模式是用来创建对象的一种最常用的设计模式。我们不暴露创建对象的具体逻辑,而是将逻辑封装在一个函数中,那么这个函数就可以被视为一个工厂工厂模式根据抽象程度的不同可以分为 简单工厂 工厂方法 抽象...
  • JAVA设计模式之抽象工厂模式

    万次阅读 多人点赞 2015-04-11 08:26:32
    本文属于23种设计模式系列。 继续前面简单工厂模式和工厂方法模式的例子,以汽车配件制造介绍抽象工厂模式。
  • 定义:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类。...工厂方法模式代码 [java]view plaincopy interfaceIProduct{ publicvoidproductMethod(); } c
  • PHP 设计模式 简单工厂工厂模式

    千次阅读 2018-01-02 18:37:19
    工厂模式是创建型模式的一种,分为简单工厂模式工厂模式,抽象工厂模式,简单工厂可以称之为工厂模式的一个特例 先用一段简单的代码说明一下,现在假设我们是顾客,需要苹果味饮料和香蕉味饮料 class ...
  • 设计模式(一) 工厂模式 五种写法总结

    万次阅读 多人点赞 2016-10-12 16:47:11
    http://blog.csdn.net/zxt0601/article/details/52703280本文出自:【张旭童的博客】系列开篇瞎BB设计模式相关的文章学习与总结,一直有意为之,一直又觉得时机不到。一 是怕自己代码经验还不够,学习了也不懂,强行...
  • 最近在学习spring源码,发现在IoC容器初始化的时候创建各种bean,然后在代码中看到各种beanFactory和factoryBean,很显然spring容器在创建bean的过程是使用了工厂设计模式,那么正好总结一下工厂设计模式。...
  • 工厂设计模式

    千次阅读 2018-10-10 14:50:10
    下面例子中鼠标,键盘,耳麦为产品,惠普,戴尔为工厂。 简单工厂模式 简单工厂模式不是 23 种里的一种,简而言之,就是有一个专门生产某个产品的类。...//简单工厂模式是属于创建型模式,又叫做静态工厂方法(s...
  • 史上最全设计模式导学目录(完整版)

    万次阅读 多人点赞 2013-12-24 23:15:16
    2012年-2013年,Sunny在CSDN技术博客中陆续发表了100多篇与设计模式相关的文章,涵盖了七个面向对象设计原则和24个设计模式(23个GoF设计模式 + 简单工厂模式),为了方便大家学习,现将所有与设计模式学习相关文章...
  • C#设计模式之0-简单工厂模式

    万次阅读 2018-07-19 12:23:17
    简单工厂模式属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GoF设计模式之一。学习简单工厂模式是学习其它工厂模式的前提条件。 简单工厂模式是由一个工厂对象决定创建出哪一种...
  • 简单工厂设计模式-设计模式(1)

    千次阅读 2006-03-24 10:40:00
    转载请注明出处,谢谢!using System;namespace iuhxq{ public abstract class DataProvider { public abstract string GetDataProvider(); } public class OleDbDataProvider : DataProvider { public ...
  • 本文我们通过实例的方式来简单描述一下简单工厂模式的由来及其作用,话说我们现在需要开发一个图形界面工具,然后将这个工具提供给一个客户去使用,系统初期我们只需要画一个圆(Circle)和一个三角形(Triangle)...
  • 首先是Operation抽象类: package yx.designpattern.simpleFactory; abstract class Operation { public double number1; public double number2; ... public double getNumber1() { ... public void
  • 设计模式: Java中的工厂设计模式

    千次阅读 2018-08-22 23:22:26
    工厂设计模式(Factory Design Pattern)属于创建模式之一,工厂设计模式在JDK,Spring,Stuts被广泛使用 当一个类或者接口有多个子类,并且基于输入返回特定的子类,此时会使用工厂设计模式。这种模式负责从客户端到...
  • 工厂方法模式引入工厂等级结构,解决了简单工厂模式工厂类职责过重的问题,但由于工厂方法模式中每个工厂只创建一类具体类的对象,这将会导致系统当中的工厂类过多,这势必会增加系统的开销。此时,我们可以考虑将...
  • 设计模式工厂模式

    2017-10-25 09:33:09
    工厂模式,创建型模式 顾名思义,工厂是用来生产批量货物的,比如你是4S店,你现在需要宝马、奔驰、保时捷车辆,你只需要把提货单交给工厂,然后工厂根据提货单将车辆送到你家4S店,你并不需要知道制作车的流程,这...
  • 设计模式之模板模式和工厂模式

    千次阅读 2019-06-15 16:02:49
    模板模式和工厂模式的类别分类为“交给子类”,即两种设计模式都是通过子类来实现具体的功能。主角是子类,而不像上次的适应设计模式,主角是连接器。这种差别着重体现在我们在工业设计中对需求的不同理解和实现。 ...
  • 本文概要性的讲述了工厂三兄弟(简单工厂工厂方法, 抽象工厂)的异同, 并给出了三者的生活实例的UML图,然后在UIKit框架下实现了这些设计模式, 并提供了相应的Demo
  • 设计模式-工厂模式-3种-以手机制造工厂为例

    千次阅读 多人点赞 2019-07-19 16:05:18
    超级链接: Java常用设计模式的实例学习系列-绪论 参考:《HeadFirst设计模式》 1.工厂模式存在的意义 工厂存在的意义是:高效的制造某一类产品。 工厂模式存在的意义是:高效的创建某一类对象。 工厂模式有很多种,...
  • Java设计模式——工厂模式

    万次阅读 多人点赞 2015-12-10 09:37:55
    工厂模式是一种比较常见的创建模式。有时,可能你使用了工厂模式而你却还不知道你已经使用了它。至少我感觉下面说的第一种简单工厂模式,你是已经很熟悉了。并且是经常使用的。不信,就继续向下看。 版权说明 ...

空空如也

1 2 3 4 5 ... 20
收藏数 860,323
精华内容 344,129
关键字:

工厂模式