工厂模式

   工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：
1. 简单工厂模式(Simple Factory)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)
   这三种模式从上到下逐步抽象，并且更具一般性。还有一种分类法，就是将简单工厂模式看为工厂方法模式的一种特例，两个归为一类。下面是使用工厂模式的两种情况：
1.在编码时不能预见需要创建哪种类的实例。
2.系统不应依赖于产品类实例如何被创建、组合和表达的细节  

  简单工厂模式
   顾名思义，这个模式本身很简单，而且使用在业务较简单的情况下。
   它由三种角色组成：
1、工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

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

3、具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

下面看一个小例子：假如要做各种水果果汁，那么可以直接一个类中创建方法，但是那样可维护型太低了，所以使用了以下简单的工厂模式来实现一下，就简单模式而言，虽然代码稍微多了点，但是能是我为提高了以下代码的可维护性：

public interface Fruit {
    public void juce();
}
public class Apple implements Fruit{
    @Override
    public void juce() {
        System.out.println("Do Apple juce");
    }
}
public class Orange implements Fruit{
    @Override
    public void juce() {
        System.out.println("Do Orange juce");
    }
}
public class Juce {
    public static Fruit makeJuce(String fruit){
        if(fruit.equalsIgnoreCase("apple")){
            return new Apple();
        }else if(fruit.equalsIgnoreCase("orange")){
            return new Orange();
        }
        return null;
                                                                                                                                                                               
    }
}
public class Me {
    public static void main(String[] args) {
        Fruit f = Juce.makeJuce("apple");
        f.juce();
        Fruit ff = Juce.makeJuce("orange");
        ff.juce();
    }
}

结果如下：

Do Apple juce
Do Orange juce

下面看一下工厂方法模式，能币以上简单工程模式稍稍复杂一点，说白了也就是加一个具体的做果汁的人而不是由自己做，只要自己点就行了。

   工厂方法模式
先来看下它的组成吧：
1、抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2、具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
3、抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4、具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

下面看一个实例：

public interface Juce {
public Fruit makeJuce();
                                                                                                                                       
}
public interface Fruit {
    public void juce();
}
public class AppleJuce implements Juce{
    public Fruit makeJuce() {
        return new Apple();
    }
}
public class OrangeJuce implements Juce{
    @Override
    public Fruit makeJuce() {
        return new Orange();
    }
}
public class People {
    public static void main(String[] args) {
        Juce juce2 = new OrangeJuce();
        Fruit fruit2 = juce2.makeJuce();
        fruit2.juce();
        Juce juce = new AppleJuce();
        Fruit fruit = juce.makeJuce();
        fruit.juce();
    }
}
public class Apple implements Fruit{
    @Override
    public void juce() {
        System.out.println("Do Apple juce");
    }
}
public class Orange implements Fruit{
    @Override
    public void juce() {
        System.out.println("Do Orange juce");
    }
}
输出结果如下：
Do Orange juce
Do Apple juce

以上的将果汁的做法抽象成了一个接口，直接调用接口中的方法，然后再用另一个接口得到想要的果汁即可，这样比上面的简单工厂方法更加好了，以下还有个抽象工厂。

让我们来看看简单工厂模式、工厂方法模式给我们的启迪：
如果不使用工厂模式来实现我们的例子，也许代码会减少很多--只需要实现已有的果汁，不使用多态。但是在可维护性上，可扩展性上是非常差的。因此为了提高扩展性和维护性，多写些代码是值得的。  

   抽象工厂模式
先来认识下什么是产品族：位于不同产品等级结构中，功能相关联的产品组成的家族。如果光看这句话就能清楚的理解这个概念，我不得不佩服你啊。还是让我们用一个例子来形象地说明一下吧。  

回到抽象产品模式的话题上，可以这么说，它和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。而且使用抽象工厂模式还要满足一下条件：
1.系统中有多个产品族，而系统一次只可能消费其中一族产品
2.同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。  

下面看一个实例吧！

public interface IOrange {
public void makeJuce();
}
public interface IApple {
    public void makeJuce();
}
public class AppleJuce implements IApple{
    @Override
    public void makeJuce() {
        System.out.println("Do AppleJuce!");
    }
}
public class OrangeJuce implements IOrange{
    @Override
    public void makeJuce() {
        System.out.println("Do OrangeJuce!");
    }
}
interface IFactory {
    public IApple creatApple();
    public IOrange createOrange();
}
public class Factory implements IFactory{
    @Override
    public IApple creatApple() {
        return new AppleJuce();
    }
    @Override
    public IOrange createOrange() {
        return new OrangeJuce();
    }
}
public class Client {
    public static void main(String[] args) {
        IFactory factory = new Factory();
        factory.creatApple().makeJuce();
        factory.createOrange().makeJuce();
    }
}
结果同上：
Do AppleJuce!
Do OrangeJuce!

工厂的大概理解了，使用以后还需多用用才能熟练……