一、簡單工廠模式（靜態工廠模式）

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();
    }
    
 }