工厂模式简述

代码的优化离不开设计模式的使用，今天主要介绍一下工厂模式：

工厂模式概念

　　实例化对象，用工厂方法代替new操作

 　工厂模式包括工厂方法模式、抽象工厂模式

什么情况用
有一组相似的对象要创建
编码时不能预见创建哪一些实例
考虑代码的拓展性
低耦合，一个对象的改变不影响以来他的对象

 

具体实例

模拟需求：需要生产宝马、奔驰、奥迪

原始的做法：存在BMW、AUDI个类，通过new的方式创建多个对象

public class BMW { 

　　public BMW(){
　　　　System.out.println("这是-->BMW");
　　}
}

public class AUDI {
　　public AUDI(){
　　　　System.out.println("这是-->AUDI");
　　}
}


public class {
public static void main(String[] args) {
　　BMW bmw = new BMW();
　　AUDI audi = new AUDI();
}
}

 

 

 

 

 

 

 

 

 

 

 

 

 

客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,

把创造车的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的车型号就行了,而不必去知道创建的细节.这就是工业革命了：

简单工厂模式

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

 

 产品类：

 

public interface Car {
　　public void carBrand();
}

public class AUDI implements Car {
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->AUDI");
　　}
}

public class BMW implements Car{
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->BMW");
　　}
}

 

 

 

 

 

 

 

 

 

 

 

 

工厂类

public class CarFactory {
public Car creatCar(String carType){
　　switch (carType ) {
　　case "bmw":
　　　　return new BMW();
　　case "audi":
　　　　return new AUDI();

　　default:
　　break;
　　}
　　return null;
　　}
}

 

 

 

 

 

 

 

 

 

 

客户端

public class Test {
CarFactory  factory = new CarFactory();

 　　factory.creatCar("bmw");

 　　 factory.creatCar("audi");
}

 

 

 

 

 

 

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 
      先来看看它的组成： 
         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。         
         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。 

 

 

下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当客户不再满足现有的车种类的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createCar(String carType)方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。 
        我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。
        于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。
五、工厂方法模式 
        工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 
工厂方法模式组成： 
       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！ 

代码如下： 

 产品类：

 

public interface Car {
　　public void carBrand();
}

public class AUDI implements Car {
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->AUDI");
　　}
}

public class BMW implements Car{
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->BMW");
　　}
}

 

 

 

 

 

 

 

 

 

 

 

 

工厂类

public interface CarFactory {
　　public Car creatCar();

}

 

public class BMWFactory implements CarFactory {
　　@Override
　　public Car creatCar() {
　　　　return new BMW();
　　}

　}

 public class AUDIFactory implements CarFactory{

　　@Override
　　public Car creatCar() {
　　　　return new AUDI();
　　}
　　}

 

 

 

 

 

 

 

 

 

 

 

 

 　　

 

 

客户端

public class Test {
public static void main(String[] args) {
　　BMWFactory bmwFactory = new BMWFactory();
　　Car bwm = bmwFactory.creatCar();
　　AUDIFactory audiFactory = new AUDIFactory();
　　　　Car audi = audiFactory.creatCar();
　　　　}
　　}

 

 

 

 

 

 

这里还可以使用家java的反射技术实现工厂模式

产品类：

 

public interface Car {
　　public void carBrand();
}

public class AUDI implements Car {
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->AUDI");
　　}
}

public class BMW implements Car{
　　@Override
　　public void carBrand() {
　　　　System.out.println("这是-->BMW");
　　}
}

 

 

 

 

 

 

 

 

 

 

 

 

工厂类

public class CarFactory {
public Car creatCar(String carType) throws IOException {
　　Car car = null;
　　　try {
　　　　PropertiesReader propertiesReader = new PropertiesReader();
　　　　Map<String, String> carClassMap = propertiesReader.getProperties();
　　　　String carClass = carClassMap.get(carType);
　　　　car = (Car) Class.forName(carClass).newInstance();
　　} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
　　}

　　　　return car;

}

 //读取配置java类文件信息

public class PropertiesReader {
　　　　public Map<String,String> getProperties() throws IOException{
　　　　Properties props= new Properties();
　　　　Map<String,String> map = new HashMap<String,String>();

　　InputStream in = getClass().getResourceAsStream("type.properties");
　　　　props.load(in);

　　Map<String, String> map1 = new HashMap<String, String>((Map) props);
　　　　return map1;
　　　　}
}

//配置文件内容

bmw=com.hand.car.BMW
audi=com.hand.car.AUDI

 

 

 

 

 

 

 

 

 

 

 

 　　

 

 

 

 

 

 

 

 

 

客户端

public class Test {

public static void main(String[] args) throws IOException {
　　　　CarFactory carFactory = new CarFactory();
　　　　Car bmw = carFactory.creatCar("bmw");
　　　　bmw.carBrand();
　　　　}
　　}

 

 

 

 

 

 

 

  

 

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

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

 以上就是简单工厂模式。