工厂模式

如何使用工厂模式

工厂模式可以分成三类：

• 简单/静态工厂模式
• 工厂方法模式
• 抽象工厂模式

1.1工厂方法模式

下面以一个什么水果都有的水果店举例子

package com.cat.factory;

/**
 * 什么水果都有的水果店（工厂）
 */
public interface FruitFactory {

    //可以获取任何水果的方法
    Fruit createFurit();
}

构建苹果和梨的工厂(继承着所有水果的工厂)

/**
 * 苹果工厂继承水果工厂
 */
public class AppleFactory implements FruitFactory {

    /**
     * 创建水果
     * @return
     */
    @Override
    public Fruit createFruit(){
        return new Apple();
    }
}

/**
 * 梨工厂继承水果工厂
 */
public class PearFactory implements FruitFactory {

    /**
     * 创建梨
     * @return
     */
    @Override
    public Fruit createFruit() {
        return new Pear();
    }
}

还有我们的实体类：苹果、梨、水果(多态：苹果和梨都是水果，可以直接用水果来表示)

/**
 * 水果抽象类
 */
public abstract class Fruit {

    // 所有水果都有颜色-抽象方法
    public abstract void color();
}

/**
 * 苹果
 */
public class Apple  extends Fruit {

    @Override
    public void color() {
        System.out.println("苹果是红色的");
    }
}

/**
 * 梨
 */
public class Pear extends Fruit {

    @Override
    public void color() {
        System.out.println("梨是黄色的");
    }
}

那么现在我想要买一个苹果，我就跟水果店老板说，老板就给我拿来苹果了，如下：

public class TestFruit {

    public static void main(String[] args) {
        //去苹果工厂找了一个苹果
        FruitFactory f = new AppleFactory();
        //老板就拿了一个苹果给客人
        Fruit fruit = f.createFruit();
        //苹果的颜色
        fruit.color();
    }
}

优点:

• 1:客户端不需要在负责对象的创建,明确了各个类的职责
• 2:如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可
• 3:不会影响已有的代码,后期维护容易,增强系统的扩展性

缺点:

• 1:需要额外的编写代码,增加了工作量

1.2简单/静态工厂模式

现在水果店生意不好做啊，很多水果都卖不出去了，于是老板只卖苹果和梨两种水果了。

• 既然就只有两种水果的话，那就没必要有”苹果厂“、”梨厂“了，一个（苹果+梨）厂就行了！

所以我们的工厂是这样子的：

/**
 * 一个即可创建苹果又可创建梨的简单工厂
 */
public class SimpleFruitFactory {


    public static Apple createApple(){
        return new Apple();
    }

    public static Pear createPear(){
        return new Pear();
    }

    /**
     * 如果外界（客人）想要苹果、梨，直接在这里创建就行了
     */
    public static Fruit createFruit(String type){
        if("apple".equals(type)){
            return createApple();
        }else if("pear".equals(type)){
            return createPear();
        }else{
            return null;
        }
    }
}

获取苹果，梨：

public class TestFruit {

    public static void main(String[] args) {
        //苹果
        Fruit apple = SimpleFruitFactory.createApple();
        apple.color();
        //梨
        Fruit pear = SimpleFruitFactory.createPear();
        pear.color();
    }
}

现在问题来了:

• 1:我想要一个西瓜,可是我的工厂类没有西瓜
• 2:我就去改代码,写可以创建西瓜对象的
• 3:接着,我又要其他的水果
• 4:我还是得改代码
• 5...................
• 6:这就是简单工厂类的缺点：当需求改变了,我就要改代码.

简单工厂类的优点也很明显：我就一个具体的工厂来创建对象，代码量少。

1.3抽象工厂模式

抽象工厂模式就比较复杂了，我们一般的应用都写不到。我首先来简述一下需求吧：

• 每一种水果都有它的价格

  • 有的人买贵的
  • 有的人买便宜的

那我们的苹果和梨都是有价格的，不是贵的就是便宜的~~

• 我们之前在工厂方法模式下是每种水果都开一个工厂，如果水果过多的话，那么就有很多的工厂~
• 那现在我们可以抽取出来：每个水果不是贵的就是便宜~
• 所以我们有两个工厂就足够了！

具体的代码是这样的：

我们的最大工厂还是定义了创建什么水果

（待续）