java 设计模式－－简单工厂模式,工厂方法模式，抽象工厂模式

简单工厂模式：又称静态工厂模式，它是用来实例化目标类的静态类。

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到一个子类

抽象工厂模式：提供一个创建一系列相关或依赖对象的接串口，而无需指定它们具体的类

两者都是工厂模式，其目的都是对子类实例化的一个封装。但区别就在于一个是静态的，即实例化对象方法是固定的，而下面的实例化对象是由使用者来定义的。

下面我们通过例子来加强理解。

就拿现在的手机来说吧，现在手机的种类有很多很多，而且各式各样的，如果一个代工工厂代工生产有三种手机，比如诺基来的lumia920，三星的galaxy sIII，iphone 5的（此入打个比方）。三个手机运行着不同的操作系统，一个是wp8，一个android，一个ios，那么我们定义三个类

首先我们通过简单工厂模式来实现。

1‘、定义三者的通用接口

public interface  Product()

{

    public void showInfo();

}

2、三个实现

public class LumiaProduct implements Product

{

   public void showInfo()

 {

    System.out.Println("Lumia920 使用微软最新的windows 8操作系统");

 }

}

public class GalaxyProduct implements Product

{

 public void showInfo()

 {

   System.out.println("三星Galaxy SIII 是三星最新的旗舰机，运行着Android 操作系统");

 }

}

public class IphoneProduct implements Product

{

  public void showInfo()

  {

     System.out.println("iphone 5 是苹果工司最新的手机，运行着ios操作系统");

  }

}

以上三个类分别表示了三种手机的基本信息。如果就这样让客户端调用的话，完全不符合面向对象的思想了。所以我们对其进行封装。以提高代码的重用性，以及代码的易用性

所以我们利用简单工厂模式对上述对象进行封装

public class ProductFactory   //工厂类

{

   Product product;

 public Product createProduct(String pro)

 {

    switch(pro)

     {

        case  "lumia" :

        product=new LumiaProduct();

       break;

         case  "galaxy":

        product=new GalaxyProduct();

         break;

         case  "iphone":

         product=new IphoneProduct();

         break;

     }

     return product;

 }

}

有了上述的工厂类，那么我们生产起手机来就方便了。

其它程序或函数调用就方便了

Product p;

p=ProductFactory("lumia");

p.showInfo();

p=ProductFactor("galaxy");

p.showInfo();

p=ProductFactory("iphone");

p.showInfo();

从上述的例子中我们可以看出简单工厂模式的特点，就是实例化类的一个类，可以灵活的输出相应的子类，当然缺点也是显然的，如果这个工厂又要多加一款手机的话，那么要就修改工厂类了，这就不符合开放－封闭原则了。

所以我们就用工厂方法模式来修改，来使之能动态的实例化我们想要的类。

从简单工厂模式我们可以看出，其中的product接口是对三种手机的一个抽象，在工厂中其它的手机可以由它来表示。那么我们也定义这样的接口IFactory,来定义不同了子工厂类。

public interface IFactory()

{

   public  Product createProduct();

}

然后定义子工厂类

class LumiaFactory() implement IFactory

{

   public Product createProduct()

  {

    return new LumiaProduct();

 }

}

class GalaxyFacotry implement IFactory

{

   public Product createProduct();

    {

       return new GalaxyProduct();

    }

}

class IphoneFactory implement IFactory

{

    public Product createProduct()

    {

       return new IphoneProduct();

     }

}

那么我们在程序或函数中调用就可以方面了。

IFactory factory=new LumiaFactory();

Product pro=factory.createProduct();

pro.showInfo();

其它同理

通过抽像工厂类，我们可以发现，如果要增加一款手机的手产，就不用改类了，只继承Product 类生成相应的手机类，然后继承IFactory 生成相就有工厂类就行了，那么就实现了动态的调用。

那么接下来我们再看看抽象工厂模式，抽象工厂模式其实是工厂模式的一个括充。比如我们这个工厂加在搞资，要增加平反电脑(我们在这里认为是另一种不同的product)，那我们如休在原来的基础上做出修改呢?

首先我们定义抽象

public interface NewProduct()

{

   public void showProduct();

}

public void  iPad implement NewProduct

{

   public void showProduct()

   {

       System.out.println("Apple公司 新作");  

   }

public void NexusTen  implement NewProduct

{

    public void showProduct()

    {

       System.out.println("google公司新出的平板");

       }

}

然后我们要定义工厂类了，于是我们在原先的工厂抽象类里面，加入新的定义，故IFactory可改为：

public interface IFactory()

{

   public  Product createProduct();

   public  NewProduct createNewProduct();

}

这样factor就能生产出新的平板了产品

public void IpadFactory implement IFacotry

{

     public NewProduct createNewProduct()

    {

         return new Ipad();

     }

}

public void NexusTenFactory implement IFactory

{

   public NewProduct createNewProduct()

   {

      return new NexusTen();

    }

}

写到这大家一定可以发现利用工厂模式的好处了，无论是添加商品的个数，还是种类，都十分的方便，至于在程序中怎么调用，就比较简单了。

IFactory facotry=new IphomeFactory();

Product iphone=factory.createProduct();

NewProduct ipad=factory.createNewProduct();

iphone.showInfo();

ipad.showProduct();

大功告成，是不是很神奇。。。。