我理解的设计模式-------抽象工厂模式

 

接着上一次工厂模式来说说抽象工厂模式。

首先抽象工厂模式和工厂模式一样是属于创建型模式，也就是说它的目的也是用来创建对象的，其实我觉得说用来管理对象的创建更为恰当一些。

为什么要有了工厂模式之后还要有抽象工厂模式？

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

假设目前你的程序里面有两个对象，苹果(apple)和香蕉(banana),那么你使用工厂模式就已经足够了，因为她们属于同一个品类，都属于水果，如果在添加一个菠萝产品，也只需要把菠萝加入到你的

水果工厂里面就够了。

但是如果你程序里面有四个对象，苹果汁，苹果派，香蕉汁，香蕉派，这四个对象正好有明确的层级关系，可以抽象为两个层级，苹果，香蕉，或者果汁，派。这时候你怎么来创建这些对象呢？这时候工厂模式明显已经不适用了，因为工厂模式是对象都实现了同一个接口，这时候就可以使用抽象工厂模式了。

具体怎么做呢？

就是把对象抽象一下，把这四个对象抽象为两个接口，一个果汁接口，一个派的接口。

然后再设计一个抽象的工厂（抽象类）abstractFactory，里面生产抽象的对象（也就是接口）Juice，Pie，单看这个结构就是一个工厂模式，但是我们要用生产的是对象而不是接口。

所以我们还需要两个具体工厂：

一个AppleFactory继承abstractFactory，实现生成Pie的方法和生成Juice的方法，实际上就是生成对象AppleJuice和ApplePie，

一个BananaFactory继承abstractFactory，实现生成Pie的方法和生成Juice的方法，实际上就是生成对象BananaJuice和BananaPie，

这样的话，对于调用者来说，我在开发过程中，只需要知道我操作的对象是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("香蕉派");
    }
}

然后最后，再配上一张，我觉得可以帮助理解的图，没有用UML，勉强算是概念图，有点丑。。。