java工厂设计模式

Java工厂模式
看了这么多关于工厂模式的讲解，仍是以为这篇文章讲的好理解，贴出来和你们分享分享。
1、引子
            话说十年前，有一个****户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，****户坐车时老是怪怪的：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你必定说：这人有病！直接说开车不就好了？！
             而当把这个****户的行为放到咱们程序设计中来时，会发现这是一个广泛存在的现象。幸运的是，这种有病的现象在OO（面向对象）语言中能够避免了。下面就以Java语言为基础来引入咱们本文的主题：工厂模式。

2、分类
           工厂模式主要是为建立对象提供过渡接口，以便将建立对象的具体过程屏蔽隔离起来，达到提升灵活性的目的。

工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
这三种模式从上到下逐步抽象，而且更具通常性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（FactoryMethod）与抽象工厂模式（Abstract Factory）。将简单工厂模式（SimpleFactory）看为工厂方法模式的一种特例，二者归为一类。

二者皆可，在本文使用《Java与模式》的分类方法。下面来看看这些工厂模式是怎么来“治病”的。

3、简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就能够看出这个模式必定很简单。它存在的目的很简单：定义一个用于建立对象的接口。
       先来看看它的组成：

         1) 工厂类角色：这是本模式的核心，含有必定的商业逻辑和判断逻辑。在java中它每每由一个具体类实现。

         2) 抽象产品角色：它通常是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

         3) 具体产品角色：工厂类所建立的对象就是此角色的实例。在java中由一个具体类实现。
那么简单工厂模式怎么来使用呢？咱们就以简单工厂模式来改造****户坐车的方式——如今****户只须要坐在车里对司机说句：“开车”就能够了。

代码：//抽象产品角色
public interface Car{
     public void drive();
}

//具体产品角色
public class Benz implements Car{
     public void drive() {
         System.out.println("Driving Benz ");
     }
}

public class Bmw implements Car{
     public void drive() {
       System.out.println("Driving Bmw ");
     }
}
。。。（奥迪我就不写了:P）

//工厂类角色
public class Driver{
           //工厂方法.注意 返回类型为抽象产品角色
             public static Car driverCar(String s)throws Exception{
                   //判断逻辑，返回具体的产品角色给Client
                   if(s.equalsIgnoreCase("Benz"))
                       return new Benz();
                   else if(s.equalsIgnoreCase("Bmw"))
                           return new Bmw();
                                 ......    
                           else throw new Exception();
             。。。

//欢迎****户出场......
public class Magnate{
             public static void main(String[] args){
                       try{
                             //告诉司机我今天坐奔驰                    
                                 Car car = Driver.driverCar("benz");
                             //下命令：开车                            
                                 car.drive();
                       。。。

         将本程序空缺的其余信息填充完整后便可运行。若是你将全部的类放在一个文件中，请不要忘记只能有一个类被声明为public。本程序在jdk1.4 下运行经过。
这即是简单工厂模式了。怎么样，使用起来很简单吧？那么它带来了什么好处呢？
           首先，使用了简单工厂模式后，咱们的程序不在“有病”，更加符合现实中的状况；并且客户端免除了直接建立产品对象的责任，而仅仅负责“消费”产品（正如****户所为）。

          下面咱们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当****户增长了一辆车的时候，只要符合抽象产品制定的合同，那么只要通知工厂类知道就能够被客户使用了。因此对产品部分来讲，它是符合开闭原则的；可是工厂部分好像不太理想，由于每增长一辆车，都要在工厂类中增长相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类（在咱们的例子中是为司机师傅），咱们称它为全能类或者上帝类。
             咱们举的例子是最简单的状况，而在实际应用中，极可能产品是一个多层次的树状结构。因为简单工厂模式中只有一个工厂类来对应这些产品，因此这可能会把咱们的上帝累坏了，也累坏了咱们这些程序员:(
           因而工厂方法模式做为救世主出现了。
4、工厂方法模式
             工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它能够被子类继承。这样在简单工厂模式里集中在工厂方法上的压力能够由工厂方法模式里不一样的工厂子类来分担。

你应该大体猜出了工厂方法模式的结构，来看下它的组成：

       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以建立对应的具体产品的对象。

       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中通常有抽象类或者接口来实现。

       4)具体产品角色：具体工厂角色所建立的对象就是此角色的实例。在java中由具体的类来实现。
      工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；并且这样使得结构变得灵活起来——当有新的产品（即****户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就能够被客户使用，而没必要去修改任何已有的代码。能够看出工厂角色的结构也是符合开闭原则的！

      咱们仍是老规矩，使用一个完整的例子来看看工厂模式各个角色之间是如何来协调的。话说****户生意越作越大，本身的爱车也愈来愈多。这可苦了那位司机师傅了，什么车它都要记得，维护，都要通过他来使用！因而****户同情他说：看你跟我这么多年的份上，之后你不用这么辛苦了，我给你分配几我的手，你只管管好他们就好了！因而，工厂方法模式的管理出现了。代码以下：

代码：
//抽象产品角色，具体产品角色与简单工厂模式相似，只是变得复杂了些，这里略。
//抽象工厂角色
public interface Driver{
       public Car driverCar();
}
public class BenzDriver implements Driver{
         public Car driverCar(){
               return new Benz();
         }
}
public class BmwDriver implements Driver{
         public Car driverCar(){
           return new Bmw();
         }
}

//应该和具体产品造成对应关系...
//有请****户先生
public class Magnate{
         public static void main(String[] args){
                     try{
                       Driver driver = new BenzDriver();
                       Car car = driver.driverCar();
                       car.drive();
                     }
             ……
}

能够看出工厂方法的加入，使得对象的数量成倍增加。当产品种类很是多时，会出现大量的与之对应的工厂对象，这不是咱们所但愿的。由于若是不能避免这种状况，能够考虑使用简单工厂模式与工厂方法模式相结合的方式来减小工厂类：即对于产品树上相似的种类（通常是树的叶子中互为兄弟的）使用简单工厂模式来实现。

 

用反射的方式：

interface Car{
    public void run();
    public void stop();
}

class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}

class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}

class Toyota implements Car{
    public void run(){
        System.out.println("Toyota开始启动了。。。");
    }
    public void stop(){
        System.out.println("Toyota停车了。。。。");
    }
}

class Factory{
    public static Car getCarInstance(String type){
        Car c=null;
        try {
            c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射获得汽车类型　
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
   
        return c;
    }
}
public class FactoryDemo03 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance("Toyota");
        if(c!=null){
            c.run();
            c.stop();
        }else{
            System.out.println("造不了这种汽车。。。");
        }
       

    }

}
5、小结

工厂方法模式仿佛已经很完美的对对象的建立进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。那咱们是否必定要在代码中遍及工厂呢？大可没必要。也许在下面状况下你能够考虑使用工厂方法模式：

     1)当客户程序不须要知道要使用对象的建立过程。

     2)客户程序使用的对象存在变更的可能，或者根本就不知道使用哪个具体的对象。

简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子同样）。并且产品对象建立条件的改变必然会引发工厂角色的修改。
       面对这种状况，Java的反射机制与配置文件的巧妙结合突破了限制——这在Spring中完美的体现了出来。
6、抽象工厂模式

      先来认识下什么是产品族： 位于不一样产品等级结构中，功能相关联的产品组成的家族。仍是让咱们用一个例子来形象地说明一下吧。
回到抽象工厂模式的话题上。
能够说，抽象工厂模式和工厂方法模式的区别就在于须要建立对象的复杂程度上。并且抽象工厂模式是三个里面最为抽象、最具通常性的。
抽象工厂模式的用意为：给客户端提供一个接口，能够建立多个产品族中的产品对象

并且使用抽象工厂模式还要知足一下条件：
     1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
     2)同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色（和工厂方法的一模一样）：
     1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

     2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以建立对应的具体产品的对象。在java中它由具体的类来实现。

     3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中通常有抽象类或者接口来实现。

     4)具体产品角色：具体工厂角色所建立的对象就是此角色的实例。在java中由具体的类来实现。 看过了前两个模式，对这个模式各个角色之间的协调状况应该内心有个数了，我就不举具体的例子了。只是必定要注意知足使用抽象工厂模式的条件哦。