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

 

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

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

为何要有了工厂模式以后还要有抽象工厂模式？

由于更方便，更合理，更加低耦合，我举个例子来讲明一下。

假设目前你的程序里面有两个对象，苹果(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，勉强算是概念图，有点丑。。。