设计模式之4 工厂模式

工厂模式的核心在于new. 也就是说，不让使用者直接new一个对象。而是通过一个getInstance来得到这个对象。

也就是说，在new的时候，要有权限检查怎么办，有没有这方面的资质？那么对于工厂生成这个对象的时候，不能随便new。

本文word格式下载：

http://wenku.baidu.com/view/f084e9360912a216147929ed.html?st=1

 

1.      单例模式

 

package com.bjsxt.dp.factory;

 

import java.util.ArrayList;

import java.util.List;

 

publicclass Carimplements Moveable{

    //单例模式，定义为private的方法

    privatestatic Carcar =new Car();

   

    //多例模式，就是用一个数组来存放好多car

    //private static List<Car> cars = newArrayList<Car>();

    //构造方法为静态

    private Car(){}

   

    //静态工厂模式

    publicstatic Car getInstance() {

      

       returncar;

    }

   

    publicvoid run() {

       System.out.println("冒着烟奔跑中car.......");

    }

}

 

2.      简单工厂模式

 

有抽象类VehicleFactory：

package com.bjsxt.dp.factory;

//交通工具的工厂，相当于一个interface，用来实现多态。

//在test当中为了灵活实现。

 

publicabstractclass VehicleFactory {

    //在这里同样定义了create方法，这个方法的返回值是Moveable类型。

    abstract Moveable create();

}

有具体实现类 CarFactory和PlaneFactory

package com.bjsxt.dp.factory;

 

//CarFactory 继承了VehicleFactory抽象类

publicclass CarFactoryextends VehicleFactory{

    public Moveable create() {

       returnnew Car();

    }

}

 

 

package com.bjsxt.dp.factory;

 

//飞机的工厂，用工厂来产生plane。

publicclass PlaneFactoryextends VehicleFactory{

    //创建方法

    public Moveable create() {

       //返回一个plane

       returnnew Plane();

    }

}

 

有接口Moveable

package com.bjsxt.dp.factory;

//可以移动的，各种交通工具。

publicinterface Moveable {

    void run();

}

 

 

 

具体的实现car和plane都实现了Moveable接口

package com.bjsxt.dp.factory;

 

import java.util.ArrayList;

import java.util.List;

 

publicclass CarimplementsMoveable{

    //单例模式，定义为private的方法

    publicstatic Carcar =new Car();

   

    //多例模式，就是用一个数组来存放好多car

    //private static List<Car> cars = newArrayList<Car>();

    //构造方法为静态

    public Car(){}

   

    //静态工厂模式

    publicstatic Car getInstance() {

      

       returncar;

    }

   

    publicvoidrun(){

       System.out.println("冒着烟奔跑中car.......");

    }

}

 

package com.bjsxt.dp.factory;

 

publicclass Planeimplements Moveable {

 

    @Override

    publicvoid run() {

       System.out.println("扇着翅膀前进中plane....");

    }

 

}                                                 

 

实现关系为： CarFactory和PlaneFactory都继承自VehicleFactory。

car 和plane都实现了moveable接口。

在VehicleFactory当中的create（）方法的返回值是moveable。

 

在这个例子中，可以控制1.生产过程，2,交通工具的生产。

使用者如下：

package com.bjsxt.dp.factory;

 

publicclass Test {

    publicstaticvoid main(String[] args) {

 

       //通过VehicleFactory父类的引用来指向子类对象。

       VehicleFactoryfactory =new BroomFactory();

       //返回的结果是对应子类的对象，目前为broom.也就是说，new什么就产生什么

       Moveable m = factory.create();

       m.run();

    }

}

 

3.      抽象工厂模式

是简单工厂模式的扩展，就是一口气封装很多项目。在简单工厂模式当中，只封装了一个项目，就是vehicle，而在抽象工厂模式，可以同时封装很多项目，比如本例中，vehicle，food，weapon。

 

 

抽象工厂AbstractFactory：

package com.bjsxt.dp.factory.abstractfactory;

 

publicabstractclass AbstractFactory {

    publicabstract Vehicle createVehicle();

    publicabstract Weapon createWeapon();

    publicabstract Food createFood();

   

}

 

第一个工厂，系列1叫DefaultFactory。

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass DefaultFactoryextends AbstractFactory{

 

    @Override

    public Food createFood() {

       //TODO Auto-generatedmethod stub

       returnnew Apple();

    }

 

    @Override

    public Vehicle createVehicle() {

       //TODO Auto-generatedmethod stub

       returnnew Car();

    }

 

    @Override

    public Weapon createWeapon() {

       //TODO Auto-generatedmethod stub

       returnnew AK47();

    }

   

}

 

第二个工厂，系列2叫MagicFactory

 

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass MagicFactoryextends AbstractFactory {

 

    @Override

    public Food createFood() {

       //TODO Auto-generatedmethod stub

       returnnew MushRoom();

    }

 

    @Override

    public Vehicle createVehicle() {

       //TODO Auto-generatedmethod stub

       returnnew Broom();

    }

 

    @Override

    public Weapon createWeapon() {

       //TODO Auto-generatedmethod stub

       returnnew MagicStick();

    }

   

}

 

DefaultFactory和MagicFactory都从AbstractFactory当中继承。

 

 

抽象概念 vehicle， weapon， food：

package com.bjsxt.dp.factory.abstractfactory;

 

publicabstractclass Vehicle {

    publicabstractvoid run();

}

 

package com.bjsxt.dp.factory.abstractfactory;

 

publicabstractclass Weapon {

    publicabstractvoid shoot();

}

 

package com.bjsxt.dp.factory.abstractfactory;

 

publicabstractclass Food {

    publicabstractvoid printName();

}

 

 

系列1实现这些抽象概念：

car对应vehicle：

 

package com.bjsxt.dp.factory.abstractfactory;

 

 

publicclass Carextends Vehicle {

   

   

    publicvoid run() {

       System.out.println("冒着烟奔跑中car.......");

    }

}

 

ak47对应weapon：

 

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass AK47extends Weapon{

    publicvoid shoot() {

       System.out.println("哒哒哒...");

    }

}

 

apple对应food：

 

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass Appleextends Food {

    publicvoid printName() {

       System.out.println("apple");

    }

}

 

 

同样，系列2 也实现这些抽象概念:

broom对应vehicle：

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass Broom extends Vehicle{

 

 

    publicvoid run() {

       System.out.println("一路沙尘暴飞奔而来broom.....");

    }

 

}

 

MagicStick对应weapon：

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass MagicStickextends Weapon {

 

    @Override

    publicvoid shoot() {

       System.out.println("fire hu huhu ...");

    }

 

}

 

MushRoom对应food：

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass MushRoomextends Food {

 

    @Override

    publicvoid printName() {

       //TODO Auto-generatedmethod stub

       System.out.println("mushroom");

    }

 

}

 

那么在使用者：

 

package com.bjsxt.dp.factory.abstractfactory;

 

publicclass Test {

    publicstaticvoid main(String[] args) {

       AbstractFactory f = new DefaultFactory();

       AbstractFactory f = new MagicFactory();

       Vehicle v = f.createVehicle();

       v.run();

       Weapon w = f.createWeapon();

       w.shoot();

       Food a = f.createFood();

       a.printName();

    }

}

只需要替换一条语句，可以替换掉一系列产品。比如本例当中直接把DefaultFactory可以替换到MagicFactory。就是非常的方便。

还有一个好处，就是可以自由的添加属于自己的系列产品。比如，产生自己的工厂，然后可以选择vehicle， weapon，food，之类的。

 

一个典型的应用，就是换皮肤的软件。

 

工厂的长处和短处：

普通工厂的短处：工厂泛滥。也就是说，工厂类太多了。

 

抽象工厂的短处：没有办法添加新的项目。也就是说本例当中，只有vehicle， weapon，food当我需要加入新的项目的时候，要动接口。

 

为了解决这两者的短处，spring提出了BeanFactory

 

4.      模拟spring的beanfactory

new不写在java程序当中，而是去配置文件当中读。

这里比较复杂，回头专门找个贴子来写。