Factory 工厂模式

一、工厂模式的形态 
1：简单工厂（Simple Factory）。 
2：工厂方法（Factory Method）。 
3：抽象工厂（Abstract Factory）。
二、简单工厂（Simple Factory）  
又叫静态工厂，是工厂模式三中状态中结构最为简单的。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。
//抽象产品接口  水果接口
public interface Fruit {
    void getFruit();
}

//具体产品角色 
public class Apple implements Fruit{
    public void getFruit(){
        System.out.println("get apple");
    }
}
public class Pear implements Fruit{
     public void getFruit(){
           System.out.println("get pear");
     }
}
public class Orange implements Fruit{
    public void getFruit(){
        System.out.println("get orange");
    }
}

//工厂类角色
public class SimpleFactory {
    public static Fruit factory(String  fruitnam){
        if("apple".equals(fruitnam))
            return new Apple();
        else if("orange".equals(fruitnam))
            return new Orange();
        else if("pear".equals(fruitnam))
            return new Pear();
        else{
            System.out.println("no this kind fruit");
            return null;
        }
    }
}

public class Client {
    public static void main(String[] args){
        Fruit fruit = SimpleFactory.factory("pear"); 
        fruit.getFruit();
    }
}
由上面的代码可以看出，简单工厂的核心就是一个SimpleFactory类，他拥有必要的逻辑判断能力和所有产品的创建权利，实际上，这个SimpleFactory有很多的局限。首先，我们每次想要增加一种新产品的时候，都必须修改SimpleFactory的原代码，整个系统都严重依赖SimpleFactory类，只要SimpleFactory类一出问题，系统就进入不能工作的状态，这也是最为致命的一点....

三、工厂方法（Factory Method）
   抽象产品Furuit，具体产品Apple,Orange,Pear,都如上：

//工厂方法为工厂类定义了接口，用多态来削弱了工厂类的职能，以下是工厂接口的定义：
public interface Factory {
    public Fruit creat();
}

//一个产品继承一个式类
public class CreateApple implements Factory {
    public Fruit creat(){
        return new Apple();
    }
}
public class Client {
    public static void main(String[] agrs){
        Factory factory= new CreateApple();
        Fruit apple= factory.creat();
        apple.getFruit();
    }
}
从上面创建产品对象的代码可以看出，工厂方法和简单工厂的主要区别是，简单工厂是把创建产品的职能都放在一个类里面，而工厂方法则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口的工厂类，就能达到，不用修改已有的代码。但工厂方法也有它局限的地方，那就是当面对的产品有复杂的等级结构的时候，例如除了水果外还有饮料或其他食物，必须为每种食物创建一个工厂，这时需要抽象工厂模式。

四、抽象工厂（Factory Method）
抽象工厂：意图在于创建一系列互相关联或互相依赖的对象。
增加饮料
public interface Drinks {
    void getDrinks();
}
public class BeerA implements Drinks {
    public void getDrinks(){
        System.out.println("get beer");
    }
}

public class BeerB implements Drinks {
    public void getDrinks(){
        System.out.println("get beer");
    }
}

public interface Factory {
    public Fruit creatFurit();
    public Drinks creatDrinks();
}

public class FactoryA implements Factory{
      public Fruit creatFurit(){
          return new OrangeA();
      }
      public Drinks creatDrinks(){
          return new BeerA();
      }
}

public class FactoryB implements Factory{
      public Fruit creatFurit(){
          return new OrangeB();
      }
      public Drinks creatDrinks(){
          return new BeerB();
      }
}

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   
    
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。