三种工厂模式(转)

资源:http://download.csdn.net/detail/zhangerqing/4835830

原文链接:http://blog.csdn.net/zhangerqing

工厂模式分为三种:普通工厂方法模式,静态工厂模式,抽象工厂模式;

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

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

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

[java] view plaincopy

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

其次,创建实现类:

[java] view plaincopy

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

[java] view plaincopy

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

最后,建工厂类:

[java] view plaincopy

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

我们来测试下:

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

输出:this is sms sender!

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

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

[java] view plaincopypublic class SendFactory {

public Sender produceMail(){

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

测试类如下:

[java] view plaincopy

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

输出:this is mailsender!

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

[java] view plaincopy

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

[java] view plaincopy

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

输出:this is mailsender!

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

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

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

请看例子:

[java] view plaincopy

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

两个实现类:

[java] view plaincopy

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

[java] view plaincopy

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

两个工厂类:

[java] view plaincopy

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

[java] view plaincopy

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

在提供一个接口:

[java] view plaincopy

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

测试类:

[java] view plaincopy

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

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

时间: 2024-08-30 01:24:31

三种工厂模式(转)的相关文章

设计模式看书笔记(5) - 三种工厂模式比较

先看三种工厂模式部分主要代码(完整代码在前三篇博客): 简单工厂模式: public class SampleFactory { public static Animal createAnimal(String animalName){ if("Tiger".equals(animalName))){ return new Triger(); }else if("Dolphin".equals(animalName)){ return new Dolphin();

设计模式:三种工厂模式

三种工厂模式 简单工厂实现 简单工厂模式(严格来说这不算一种Gof的设计模式,更像是一种编程习惯)属于类的创建型模式,又叫做静态工厂方法模式.通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有相同的父类,应用继承将决定工厂的生产什么产品的决定权直接交到了客户手中,然后客户在输入自己的需求,得到最终的结果. 运用简单工厂模式实现生产pizza的业务场景. /// <summary> /// pizza创建工厂 /// </summary> public class Pi

高级特性 三种工厂模式

简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现. 是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类. 我们从一个实例展开 现在有一道面试题:使用java实现一个计算机控制台程序,要求输入数的运算,得到结果. 这道题目最原始的写法: publi

C++ 三种工厂模式

工厂模式是将带有继承于基类的子类的创建过程交于一个工厂来创建,通过赋予不同的创建标识来创建不同的子类. 基于自己的理解和使用这里巩固一下工厂模式. 我们的项目目前使用最多的是简单工厂模式,不过其他两种模式:工厂模式和抽象工厂模式都是由简单工厂模式改进而来, 也很容易使用. 话不多说:见代码 一.简单工厂模式: 操作类: 接口类:CReadDocumentShowHandler,三个具体类:CReadWordShowHandler,CReadPdfShowHandler,CReadHtmlShow

三种工厂模式

一.简单工厂 对象的创建方式有很多,常用new来创建.但是这种做法在一些情况下,有很多不好的地方.比如创建操作散落在代码的多处.对象的创建职责和使用职责混合到一起等等.简单工厂可以一定程度上解决该问题.通常的做法是对被创建的多个类进行抽象,将公共成员和方法放到抽象类中.不同的类继承抽象类,对细节进行不同的实现.然后创建一个工厂类,将类实例化的操作封装到工厂类的静态工厂方法中,通过不同的参数来创建不同类的对象. 还有一种简化的做法是,将静态工厂方法放到实体类的公共抽象父类中. 优点: 对象的创建和

java三种工厂模式

适用场合: 7.3 工厂模式的适用场合 创建新对象最简单的办法是使用new关键字和具体类.只有在某些场合下,创建和维护对象工厂所带来的额外复杂性才是物有所值.本节概括了这些场合. 7.3.1 动态实现 如果需要像前面自行车的例子一样,创建一些用不同方式实现同一接口的对象,那么可以使用一个工厂方法或简单工厂对象来简化选择实现的过程.这种选择可以是明确进行的也可以是隐含的.前者如自行车那个例子,顾客可以选择需要的自行车型号:而下一节所讲的XHR工厂那个例子则属于后者,该例中所返回的连接对象的类型取决

java 三种工厂模式

一.简单工厂模式 一个栗子: 我喜欢吃面条,抽象一个面条基类,(接口也可以),这是产品的抽象类. public abstract class INoodles { /** * 描述每种面条啥样的 */ public abstract void desc(); } 先来一份兰州拉面(具体的产品类): public class LzNoodles extends INoodles { @Override public void desc() { System.out.println("兰州拉面 上海

深入理解Java的三种工厂模式

一.简单工厂模式 简单工厂的定义:提供一个创建对象实例的功能,而无须关心其具体实现.被创建实例的类型可以是接口.抽象类,也可以是具体的类 实现汽车接口 1 public interface Car { 2 String getName(); 3 } 奔驰类 1 public class Benz implements Car { 2 @Override 3 public String getName() { 4 return "Benz"; 5 } 6 } 宝马类 1 public c

Android 工厂模式,三种工厂模式的理解

工厂模式是一种创建者模式,在任何生成复杂对象的地方都可以使用工厂模式.理论来说在任何使用A a = new A()的方式都可以使用工厂模式,虽然使用工厂模式可能需要多做一些工作,但是在后续的开发和维护都带来了方便. 如果我们需要在构建对象的时候,需要做很多的处理工作,比如初始化工作,查询工作等一些耗时的工作,如果我们将这些操作全部放入到构造方法中去写,那么势必在后期维护的带来不方便,而且始化工作如果是很长一段代码,说明要做的工作很多,将很多工作装入一个方法中,相当于将很多鸡蛋放在一个篮子里,是很