疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

工厂模式、工厂方法模式和抽象工厂模式


 

   

  工厂模式是最重要的模式,因为大多数模式都需要用到工厂模式。

  多数设计模式的内容讲解的都是如何设计接口。接口如何产生呢?如果在客户代码(类库的使用者称之为客户)中直接使用具体类,那么就失去了接口的意义。因为接口的使用目的,就是要降低客户对具体类的依赖程度。如果在客户代码中直接使用接口,那么就造成了客户对具体类名称的依赖。(客户最终需要以某种方式指明所需要的具体类,如配置文件或代码,但是只需要指出一次,所以说降低对具体类的依赖程度)。要使客户代码不依赖具体类,唯一的方法,就是让客户代码不依赖具体类的部分不知道具体类的名称。知道具体类名称的部分,仅仅是配置部分。(配置文件或者配置代码)。

  依赖不可能完全消除,除非二者毫无联系。但是可以将这种依赖的程度降到最低。

  既然不能直接创建具体类,那么就需要通过一个创建者类来创建接口的实现类。这样就产生了工厂类。

  抽象工厂是应对产品族概念的。比如说,每个农场可能要同时生产苹果,橘子,大米,玉米,那么每一个农场都要有创建苹果,橘子,大米,玉米的方法。

  简单工厂模式:又称静态工厂方法(Static Factory Methord)模式。一个抽象产品类,可以派生多个具体产品类。

  用来生产同一等级结构中的任意产品。(对于增加新的产品,无能为力)

  public class SimpleFactory {

  public static void main(String[] args) {

  Fruit f=FactoryTest.getInstance().newApple();

  if(f!=null)

  f.eat();

  Fruit o=FactoryTest.getInstance().newOrange();

  if(o!=null)

  o.eat();

  }

  }

  interface Fruit {

  public void eat();

  }

  class Apple implements Fruit {

  public void eat() {

  System.out.println("** 吃苹果。");

  }

  };

  class Orange implements Fruit {

  public void eat() {

  System.out.println("** 吃橘子。");

  }

  };

  class FactoryTest { // 定义工厂类

  private static FactoryTest factory;

  private FactoryTest(){}

  public static FactoryTest getInstance() {

  if(factory==null){

  factory=new FactoryTest();

  }

  return factory;

  }

  public Apple newApple(){

  return new Apple();

  }

  public Orange newOrange(){

  return new Orange();

  }

  };

  工厂方法模式:又称多态性工厂(Polymorphic Factory)模式或虚拟构造子(Virtual Constructor)模式。一个抽象产品类,可以派生出多个具体产品类。

  一个抽象工厂类,可以派生出多个具体工厂类。

  每个具体工厂类只能创建一个具体产品类的实例。

  用来生产同一等级结构中的固定产品。(支持增加任意产品)

  public class FactoryMethod {

  public static void main(String[] args) {

  FruFac af=new AppleFac();

  Fru f=af.getFru();

  f.eat();

  af=new OrangeFac();

  f=af.getFru();

  f.eat();

  }

  }

  abstract class Fru

  {

  String name;

  public abstract void eat();

  }

  class AppleFru extends Fru{

  public AppleFru(){

  name="apple";

  }

  @Override

  public void eat() {

  System.out.println("apple"+name);

  }

  }

  class OrangeFru extends Fru{

  public OrangeFru(){

  name="orange";

  }

  @Override

  public void eat() {

  System.out.println("orange"+name);

  }

  }

  abstract class FruFac{

  public FruFac(){

  System.out.println("what fruit:"+getFru());

  }

  public abstract Fru getFru();

  }

  class AppleFac extends FruFac{

  @Override

  public Fru getFru() {

  // TODO Auto-generated method stub

  return new AppleFru();

  }

  }

  class OrangeFac extends FruFac{

  @Override

  public Fru getFru() {

  // TODO Auto-generated method stub

  return new OrangeFru();

  }

  }

  抽象工厂模式:又称工具箱(Kit或Toolkit)模式。多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。

  一个抽象工厂类,可以派生出多个具体工厂类。

  每个具体工厂类可以创建多个具体产品类的实例。

  用来生产不同产品族的全部产品。(对于增加新的产品,无能为力;支持增加产品族)

  package model;

  public class AbstractFactory {

  public static void main(String[] args) {

  Fact f=new WuxiFact();

  Frui fr=f.getFru();

  fr.eat();

  Food fo=f.getFood();

  fo.cook();

  }

  }

  abstract class Frui

  {

  String name;

  public abstract void eat();

  }

  abstract class Food

  {

  String name;

  public abstract void cook();

  }

  class AppleFrui extends Frui{

  public AppleFrui(){

  name="apple";

  }

  @Override

  public void eat() {

  System.out.println("Fruit:"+name);

  }

  }

  class OrangeFrui extends Frui{

  public OrangeFrui(){

  name="orange";

  }

  @Override

  public void eat() {

  System.out.println("Fruit:"+name);

  }

  }

  class Rice extends Food{

  public Rice(){

  name="rice";

  }

  @Override

  public void cook() {

  System.out.println("Food:"+name);

  }

  }

  class Corn extends Food{

  public Corn(){

  name="corn";

  }

  @Override

  public void cook() {

  System.out.println("Food:"+name);

  }

  }

  abstract class Fact{

  public Fact(){

  System.out.println("what fruit:"+getFru());

  System.out.println("what food:"+getFood());

  }

  public abstract Frui getFru();

  public abstract Food getFood();

  }

  class WuxiFact extends Fact{

  @Override

  public Frui getFru() {

  // TODO Auto-generated method stub

  return new AppleFrui();

  }

  @Override

  public Food getFood() {

  // TODO Auto-generated method stub

  return new Rice();

  }

  }

  class NanjinFact extends Fact{

  @Override

  public Frui getFru() {

  // TODO Auto-generated method stub

  return new OrangeFrui();

  }

  @Override

  public Food getFood() {

  // TODO Auto-generated method stub

  return new Corn();

  }

  }

  区别:简单工厂模式和工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。

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