工厂模式 订阅
工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替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可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
收起全文
精华内容
下载资源
问答
  • 设计模式-工厂模式

    万次阅读 2019-12-02 22:40:03
    目录 知识点1:什么是工厂模式 知识点2:工厂模式好处 ...实现了创建者和调用者分离,工厂模式分为简单工厂、工厂方法、抽象工厂模式 知识点2:工厂模式好处 工厂模式是我们最常用的实例化对象模...

    目录

    知识点1:什么是工厂模式

    知识点2:工厂模式好处

    知识点3:工厂模式分类

    1、简单工厂模式

    2、工厂方法模式

    3、抽象工厂模式


    知识点1:什么是工厂模式

    实现了创建者和调用者分离,工厂模式分为简单工厂、工厂方法、抽象工厂模式


    知识点2:工厂模式好处

    工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式。

    利用工厂模式可以降低程序的耦合性,为后期的维护修改提供了很大的便利。

    将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。


    知识点3:工厂模式分类

    1、简单工厂模式

    简单工厂模式相当于是一个工厂中有各种产品,创建在一个类中,客户无需知道具体产品的名称,只需要知道产品类所对应的参数即可。但是工厂的职责过重,而且当类型过多时不利于系统的扩展维护。

    public interface Car {
    	public void run();
    }
    
    public class AoDi implements Car {
    	public void run() {
    		System.out.println("我是奥迪汽车..");
    	}
    }
    
    public class JiLi implements Car {
    
    	public void run() {
    		System.out.println("我是吉利汽车...");
    	}
    }
    
    public class CarFactory {
    
    	 public static Car createCar(String name) {
    		if (StringUtils.isEmpty(name)) {
                     return null;
    		}
    		if(name.equals("奥迪")){
    			return new AoDi();
    		}
    		if(name.equals("吉利")){
    			return new JiLi();
    		}
    		return null;
    	}
    }
    
    public class Client01 {
    
    	public static void main(String[] args) {
    		Car aodi  =CarFactory.createCar("奥迪");
    		Car jili  =CarFactory.createCar("吉利");
    		aodi.run();
    		jili.run();
    	}
    
    }
    

    (1)单工厂的优点/缺点

    优点:简单工厂模式能够根据外界给定的信息,决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力,有利于整个软件体系结构的优化。

    缺点:很明显工厂类集中了所有实例的创建逻辑,容易违反GRASPR的高内聚的责任分配原则


    2、工厂方法模式

    (1)什么是工厂方法模式

    工厂方法模式Factory Method,又称多态性工厂模式。在工厂方法模式中,核心的工厂类不再负责所有的产品的创建,而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色,仅负责给出具体工厂子类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。

    public interface Car {
    	public void run();
    }
    
    public class AoDi implements Car {
    	public void run() {
    		System.out.println("我是奥迪汽车..");
    	}
    }
    
    public class JiLi implements Car {
    
    	public void run() {
    		System.out.println("我是吉利汽车...");
    	}
    }
    
    public class JiLiFactory implements CarFactory {
    
    	public Car createCar() {
    
    		return new JiLi();
    	}
    
    }
    
    public class AoDiFactory implements CarFactory {
    
    	public Car createCar() {
    	
    		return new AoDi();
    	}
    }
    
    public class Client {
    
    	public static void main(String[] args) {
    		Car aodi = new AoDiFactory().createCar();
    		Car jili = new JiLiFactory().createCar();
    		aodi.run();
    		jili.run();
    	}
    
    }
    

    3、抽象工厂模式

    (1)什么是抽象工厂模式

    抽象工厂简单地说是工厂的工厂,抽象工厂可以创建具体工厂,由具体工厂来产生具体产品。

     

    //发动机
    public interface Engine {
    
    	void run();
    
    	void start();
    }
    
    class EngineA implements Engine {
    
    	public void run() {
          System.out.println("转的快!");
    	}
    
    	public void start() {
    		 System.out.println("启动快,自动档");
    	}
    
    }
    
    class EngineB implements Engine {
    
    	public void run() {
          System.out.println("转的慢!");
    	}
    
    	public void start() {
    		 System.out.println("启动快,手动档");
    	}
    
    }
    
    //座椅
    public interface Chair {
    	   void run();
    }
    
     class ChairA implements Chair{
    
    	public void run() {
    		System.out.println("可以自动加热!");
    	}
    	
    }
     class ChairB implements Chair{
    
    	public void run() {
    		System.out.println("不能加热!");
    	}
    	
    }
    
    public interface CarFactory {
    	// 创建发动机
    	Engine createEngine();
    	// 创建座椅
    	Chair createChair();
    }
    
    public class JiLiFactory implements CarFactory  {
    
    	public Engine createEngine() {
    	
    		return new EngineA();
    	}
    
    	public Chair createChair() {
    		
    		return new ChairA();
    	}
    
    }
    
    public class Client002 {
    
    	 public static void main(String[] args) {
    		CarFactory carFactory=new JiLiFactory();
    		Engine engine=carFactory.createEngine();
    		engine.run();
    		engine.start();
    
    	}
    	
    }
    

     

    展开全文
  • 在面向对象编程中, 最通常的方法是一个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 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.当系统需要比较好的延展性的时候。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,664
精华内容 35,065
关键字:

工厂模式