工厂模式：静态工厂模式、工厂方法模式、抽象工厂模式

一、简单工厂模式（静态工厂模式）

1、简单说明工厂模式：现在所谓的个性化定制就是一个很好的列子，比如你想买一辆与众不同的汽车， 你就去汽车生产厂家说你要什么样的汽车，之后他就会按你的要求给你生产你的车，而你无需关心这个生产过程，这就是工厂模式；

2、简单工厂模式中只有三个角色：工厂，产品抽象，具体产品类；具体产品实现抽象产品，工厂按照传入的产品类名称生产具体实例；工厂中使用java反射进行动态生产对象

3、简单工厂模式中如果不使用java的反射动态生产对象，则你如果要生产另一种汽车，就要修改工厂，而如果使用java的反射动态生成，则你只需要添加具体产品类就可以而不用在修改工厂。

4、简单工厂模式适合于生产产品比较少的 。  

二、工厂方法模式

1、这种模式相比简单工厂模式角色有所改变：抽象工厂角色，具体工厂角色，抽象产品角色， 具体产品角色，其中的抽象工厂角色中定义了一个抽象方法，该方法就是一个获取具体产品的抽象方法，当具体工厂实现抽象工厂的时候也就实现了这个获取具体产品的方法，个人感觉如果简单工厂模式使用java反射的话和工厂方法模式在本质上没什么区别，要说有区别就是在简单工厂模式中所有的产品都在工厂中生产，比如苹果，香蕉都由工厂角色生产，而在工厂方法模式中具体的产品由具体的工厂生产，比如苹果由苹果公司生产，香蕉由香蕉公司生产。

 

三、抽象工厂模式

1、抽象工厂模式是对工厂方法模式的再次扩展这里涉及到的角色有：抽象工厂角色 ，具体工厂角色，产品抽象角色（接口），产品抽象角色（抽象类），产品具体类， 这里的产品想比上面多了一层是因为这里涉及到了一个叫产品族的概念；

2、抽象工厂中定义了一个获取具体产品的抽象方法， 而具体工厂实现这个方法获取具体的产品；

3、产品抽象，就是一类产品的抽象， 而多余的这个抽象类就是实现这个接口，在使用具体类来描述具体的产品信息，就是这里多的这个抽象类实现了产品 族 ！！

具体代码如下：

一、简单工厂（静态工厂）：

/**
 *
 */
package com.reflect;

/**
 *@author WHD
 *2014-10-14
 */
public class StaticFactory {
public static void main(String []args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
    Apple apple= (Apple) ProductFactory.getProduce("com.reflect.Apple");
    Banana  banana=(Banana)ProductFactory.getProduce("com.reflect.Baner");
    apple.say();
    banana.say();
    
}
}

 class ProductFactory{
     public static Fruit getProduce(String name) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
         Fruit  f= (Fruit)Class.forName(name).newInstance();
         return f;
     }
 }
 
 interface Fruit{
     void say();
 }
 
 class Apple implements Fruit{
    @Override
    public void say() {
        System.out.println("i am  apple");
    }
    
 }
 
 class Banana implements Fruit{

    
    @Override
    public void say() {

   System.out.println("iam  Banana");
        
    }
    
 }

二、工厂方法模式：

/**
 *
 */
package com.reflect;

/**
 *@author WHD
 *2014-10-14
 */
public class MethodFactory {
public static void main(String []args){
    AppleFactory  appleFactory= new AppleFactory();
    BananaFactory  bananaFactory= new BananaFactory();
    Apples apple= appleFactory.getFruit();
    Banana1  banana=bananaFactory.getFruit();
    apple.say();
    banana.say();
    
}
}


interface Fruits{
    void say();
}

class Apples  implements Fruits{

    /* (non-Javadoc)
     * @see com.reflect.Fruits#say()
     */
    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("apple");
        
    }
    
}

class Banana1  implements Fruits{

    /* (non-Javadoc)
     * @see com.reflect.Fruits#say()
     */
    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("banan");
    }
    
}
interface FruitFactory{
    public Fruits getFruit();
    
}



class AppleFactory implements FruitFactory{

    
    @Override
    public Apples getFruit() {
        // TODO Auto-generated method stub
        return new Apples();
        
    }
    
}

class BananaFactory  implements FruitFactory{

    
    @Override
    public Banana1 getFruit() {
        // TODO Auto-generated method stub
        return new Banana1();
    }
    
}

三、抽象工厂模式：

/**
 *
 */
package com.reflect;

/**
 *@author WHD
 *2014-10-14
 */
public class InteFactory {
public static void  main(String []args){
    
    NorthFruitFac  nff= new NorthFruitFac();
    NorthApple  napp=(NorthApple)nff.getApple();
    NorthBanana  nban=(NorthBanana)nff.getBanana();
    napp.get();
    nban.get();
}
}

interface Fruit3{
    public void get();
}

 abstract class AppleFruit  implements Fruit3{
    @Override
     public abstract void get();
}
 
 abstract class BananaFruit implements Fruit3{
     @Override
     public abstract void get();
 }
 
 class SourApple extends AppleFruit{
    @Override
    public void get() {
        // TODO Auto-generated method stub
        System.out.println("南方苹果");
    }
    
 }
 
 class  NorthApple extends AppleFruit{
    @Override
    public void get() {
        // TODO Auto-generated method stub
        System.out.println("北方苹果");
    }
    
 }
 
 class SourBanana  extends BananaFruit{

    @Override
    public void get() {
        // TODO Auto-generated method stub
        System.out.println("南方句子");
    }
    
 }
 class NorthBanana extends  BananaFruit{

    @Override
    public void get() {
        // TODO Auto-generated method stub
    System.out.println("北方句子");    
    }
    
 }
 
 interface  Factory {
     AppleFruit  getApple();
     BananaFruit  getBanana();
 }
 
  class NorthFruitFac  implements Factory {

    @Override
    public AppleFruit getApple() {
        // TODO Auto-generated method stub
        return  new NorthApple();
    }

    
    @Override
    public BananaFruit getBanana() {
        // TODO Auto-generated method stub
        return  new NorthBanana();
    }
    
 }