大话设计模式-----抽象工厂模式

1、思想

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

抽象工厂模式和工厂模式一样都是属于创建型模式，也就是说它的目的也是用来创建对象的，为什么有了工厂模式之后还要有抽象工厂模式？

因为更方便、更合理、更加低耦合，我举个例子来说明一下。

假设目前你的程序里面有两个对象，香蕉和苹果，那么你使用工厂模式就已经足够了，因为它们属于同一个类别，都属于水果，如果再添加一个菠萝产品，也只需要把菠萝加入到你的水果工厂就足够了。但是如果你程序里面有四个对象，苹果汁，苹果派，香蕉汁，香蕉派，这四个对象正好有明确的层级关系，可以抽象为两个层级，果汁和派，这时候你怎么样来创建这些对象呢，这时候工厂方法模式明显已经不适用了，因为工厂方法模式的对象都实现了同一个接口，这时候就可以使用抽象工厂模式了，具体是将这四个对象抽象为两个接口，一个果汁的接口，一个派的接口。然后再设计一个抽象的工厂（抽象类）AbstarctFactory，里面生产抽象的对象（也就是接口），果汁和派。我们需要两个具体的工厂：

一个是AppleFactory继承AbstractFactory，实现生成苹果果汁和苹果派的方法，实际上就是生成苹果果汁和苹果派对象。

一个是BananaFactory继承AbstractFactory，实现生成香蕉果汁和香蕉派的方法，实际上就是生成香蕉果汁和香蕉派对象。

这样的话，对于调用者来说，我在开发过程中，只需要知道我操作的对象是Pie或者是Juice就够了，这样降低了耦合。

工厂方法模式和抽象工厂模式的区别如下：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

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

下面看下代码，首先是调用点。

package abstractFactory;

/**
 * Created by songjian on 3/30/2016.
 */
public class Test {
    public  static void main(String args[]){
        AbstractFactory factory1 = new AppleFactory();
        factory1.createJuice().desc();
        factory1.createPie().desc();
        //假设我们之前需要的是applePie和appleJuice对象，现在需要换成bananaPie和BananaJuice对象
        //我们只需要替换对应的实现工厂（把new AppleFactory换成new BananFactory就可以了，耦合比较低）
        AbstractFactory factory2 = new BananaFactory();
        factory2.createJuice().desc();
        factory2.createPie().desc();
 
    }
}

 下面是抽象工厂，生产对象的抽象。

package abstractFactory;

/**
 * Created by songjian on 3/29/2016.
 */
public abstract class AbstractFactory {
    abstract Juice createJuice();
    abstract Pie createPie();
}

下面是具体工厂两个

package abstractFactory;

/**
 * Created by songjian on 3/29/2016.
 */
public class AppleFactory extends AbstractFactory{

    @Override
    Juice createJuice() {
        return new AppleJuice();
    }

    @Override
    Pie createPie() {
        return new ApplePie();
    

package abstractFactory;

/**
 * Created by songjian on 3/29/2016.
 */
public class BananaFactory extends  AbstractFactory{
    @Override
    Juice createJuice() {
        return new BananaJuice();
    }

    @Override
    Pie createPie() {
        return new BananaPie();
    }
}

下面是对象抽象出来的接口两个

package abstractFactory;

/**
 * Created by songjian on 3/29/2016.
 */
public interface Juice {
    public void desc();
}

package abstractFactory;

/**
 * Created by songjian on 3/29/2016.
 */
public interface  Pie {
    public void desc();
}

 

最后是我们要生产的四个对象。

package abstractFactory;

/**
 * Created by ken on 1/29/2016.
 */
public class AppleJuice implements Juice {

    @Override
    public void desc() {
        System.out.println("苹果汁.");
    }
}

 

package abstractFactory;

/**
 * Created by ken on 1/29/2016.
 */
public class ApplePie implements Pie {
    @Override
    public void desc() {
        System.out.println("苹果派");
    }
}

 

package abstractFactory;

/**
 * Created by ken on 1/29/2016.
 */
public class BananaJuice implements Juice {
    @Override
    public void desc() {
        System.out.println("香蕉汁.");
    }
}

 

package abstractFactory;

/**
 * Created by ken on 1/29/2016.
 */
public class BananaPie implements Pie {
    @Override
    public void desc() {
        System.out.println("香蕉派");
    }
}

2、结构图

3、抽象工厂模式的优点和缺点

（1）抽象工厂模式的优点

I、分离接口和实现

客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已。也就是说，客户端从具体的产品实现中解耦。

II、使切换产品族变得容易

因为一个具体的工厂实现代表的是一个产品族，所以对于不同的产品族，只需要切换不同的具体工厂。

（2）抽象工厂模式的缺点

I、不太容易扩展新的产品

如果需要给整个产品族添加一个新的产品，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类。