简单工厂模式

简单工厂模式

1、定义

由一个工厂对象决定创建出哪一种产品类的实例，简单来说就是根据不同参数获取不同的实例

2、简单工厂模式的结构

• Fruit：抽象的产品类
• AppleFruit、OrangeFruit：具体的产品类
• FruitFactory：工厂类

3、代码实现

Fruit：

/**
 * @author: Renaaa
 * @date: 2021-02-18 22:02
 * @description: 简单工厂模式--抽象的水果类（也可以是interface）
 */
public abstract class Fruit {

    /**
     * 买水果
     */
    public abstract void buy();
}

AppleFruit：

/**
 * @author: Renaaa
 * @date: 2021-02-18 22:04
 * @description: 简单工厂模式--具体的实现：苹果类型
 */
public class AppleFruit extends Fruit {
    @Override
    public void buy() {
        System.out.println("买了一些苹果");
    }
}

OrangeFruit：

/**
 * @author: Renaaa
 * @date: 2021-02-18 22:09
 * @description: 简单工厂模式--具体的实现：橘子类型
 */
public class OrangeFruit extends Fruit {
    @Override
    public void buy() {
        System.out.println("买了一些橘子");
    }
}

FruitFactory：

/**
 * @author: Renaaa
 * @date: 2021-02-18 22:03
 * @description: 简单工厂模式--水果工厂
 * 简单工厂模式的优点：
 * 1、只传入一个参数就可以获取具体的对象，不需要其中的过程
 *
 * 简单工厂模式存在的缺点：
 * 1、工厂类的职责过重，每增加一种类型就需要对工厂类进行一次修改
 * 2、违背了开闭原则（类、模块、函数应对扩展开放，对修改关闭）
 */
public class FruitFactory {
    public static Fruit buyFruit(String fruitType) throws Exception {
        if (fruitType.equalsIgnoreCase(FruitEnum.APPLE.toString())) {
            return new AppleFruit();
        } else if (fruitType.equals(FruitEnum.ORANGE.toString())) {
            return new OrangeFruit();
        } else {
            throw new Exception("对不起，暂没有其他品种水果出售");
        }
    }

}

FruitEnum：

/**
 * @author: Renaaa
 * @date: 2021-02-18 22:44
 * @description: 水果枚举类
 */
public enum FruitEnum {
    APPLE,
    ORANGE
}

Client：

/**
 * @author: Renaaa
 * @date: 2021-02-18 22:13
 * @description: 客户端
 */
public class Client {

    public static void main(String[] args) {
        try {
            Fruit fruit = FruitFactory.buyFruit("apple");
            //多态--父类的引用指向子类的对象、接口的引用指向实现类的对象
            fruit.buy();
        } catch (Exception e) {
            System.out.println("没有买到想要吃的水果");
        }
    }
}

运行效果：

4、简单工厂模式的优缺点和应用场景

优点：

• 只传入一个参数就可以获取具体的对象，不需要其中的过程

缺点：

• 工厂类的职责过重，每增加一种类型就需要对工厂类进行一次修改
• 违背了开闭原则（类、模块、函数应对扩展开放，对修改关闭）

应用场景：

• 工厂类负责创建的对象比较少
• 客户端（应用层）只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心