设计模式之 —— 抽象工厂模式

设计模式之 —— 抽象工厂模式含java代码示例，一篇文章即可看懂

一般路过糸.

2643人浏览 · 2024-07-30 10:58:32

一般路过糸. · 2024-07-30 10:58:32 发布

创建扩展了 AbstractFactory 的工厂类

什么是抽象工厂模式？

定义

抽象工厂模式（Abstract Factory Pattern），它围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。它也是一种创建型设计模式，提供了一种创建对象的最佳方式。

特点

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。

抽象工厂模式（java代码示例）

首先定义第一个接口

（饮料：Drinks）

public interface Drinks {
    void product();
}

实现第一个接口的类

（类：茶、可乐、矿泉水)

public class Tea implements Drinks {
    @Override
    public void product(){
        System.out.println("饮料——茶");
    }
}

public class Cola implements Drinks {
    @Override
    public void product(){
        System.out.println("饮料——可乐");
    }
}

public class MineralWater implements Drinks {
    @Override
    public void product(){
        System.out.println("饮料——矿泉水");
    }
}

定义第二个接口

（食物：Foods）

public interface Foods {
    void product();
}

实现第二个接口的类

public class Chicken implements Foods {
    @Override
    public void product(){
        System.out.println("食物——鸡肉");
    }
}

public class Beaf implements Foods {
    @Override
    public void product(){
        System.out.println("食物——牛肉");
    }
}

public class Fish implements Foods {
    @Override
    public void product(){
        System.out.println("食物——鱼肉");
    }
}

.......................................

（相似地，可以继续定义n个接口，然后用类实现这些接口。）

* 创建抽象工厂类

public abstract class AbstractFactory {
    public abstract Drinks getDrinks(String drinks);
    public abstract Foods getFoods(String foods);
    //上边创建了多少被实现的接口，这里就可以创建多少个方法
}

（上边创建了多少被实现的接口，这里就可以创建多少个方法）

创建扩展了 AbstractFactory 的工厂类

（基于给定的信息生成实体类的对象）

饮料工厂

public class DrinksFactory extends AbstractFactory {

    @Override
    public Drinks newDrinks(String DrinksType){
        if(DrinksType.equals(("茶"))){
            return new Tea();
        }
        else if(DrinksType.equals("可乐")){
            return new Cola();
        }
        else if(DrinksType.equals("矿泉水")){
            return new MineralWater();
        }else {
            System.out.println("暂时没有这种饮料");
            return null;
        }
    }

    @Override
    public Foods newFoods(String FoodsType){
        return null;
    }
}

食物工厂

public class FoodsFactory extends AbstractFactory {

    @Override
    public Drinks newDrinks(String DrinksType){
        return null;
    }

    @Override
    public Foods newFoods(String FoodsType){
        if(FoodsType.equals(("鸡肉"))){
            return new Chicken();
        }
        else if(FoodsType.equals("鱼肉")){
            return new Fish();
        }
        else if(FoodsType.equals("牛肉")){
            return new Beaf();
        }else {
            System.out.println("暂时没有这种食物");
            return null;
        }
    }
}

（这里麻烦的是，每一个具体的工厂，没有办法只重载自己所需要的方法，都需要将 AbstractFactory 中所有的方法@Override。否则会报错，这是抽象工厂模式的缺点之一。）

* 创建一个工厂生成器类

（通过传递 “选择” 信息来获取工厂）

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if(choice.equalsIgnoreCase("食物")){
            return new FoodsFactory();
        } else if(choice.equalsIgnoreCase("饮料")){
            return new DrinksFactory();
        }else {
            System.out.println("暂时没有该工厂");
            return null;
        }
    }
}

测试类：

public class Test {
    public static void main(String[] args) {

        AbstractFactory foodsFactory = FactoryProducer.getFactory("食物");
        AbstractFactory foodsFactory2 = FactoryProducer.getFactory("饮料");
        AbstractFactory foodsFactory3 = FactoryProducer.getFactory("衣服");

        Foods foods = foodsFactory.newFoods("鱼肉");
        foods.product();
        Foods foods2 = foodsFactory.newFoods("鸡肉");
        foods2.product();
        Foods foods3 = foodsFactory.newFoods("牛肉");
        foods3.product();
        Foods foods4 = foodsFactory.newFoods("猪肉");

        Drinks drinks = foodsFactory2.newDrinks("可乐");
        drinks.product();
        Drinks drinks2 = foodsFactory2.newDrinks("矿泉水");
        drinks.product();
        Drinks drinks3 = foodsFactory2.newDrinks("茶");
        drinks.product();
        Drinks drinks4 = foodsFactory2.newDrinks("啤酒");
        

    }
}

运行结果：

抽象工厂模式的优缺点

优点：

客户端独立于具体的实现类：客户端使用抽象工厂来创建产品，而不需要关心具体的实现类。这样可以降低客户端与具体实现类之间的耦合度。

易于切换产品系列：由于客户端只使用抽象工厂来创建产品，所以只需要切换具体的工厂实现类，就可以切换到不同的产品系列。

确保产品组合的一致性：每个具体工厂负责创建一个产品系列，这确保了产品之间的一致性。

支持产品等级结构：抽象工厂模式提供了一种支持产品等级结构的方式，可以很容易地增加新的产品。

缺点:

难以支持新种类的产品：如果需要添加一个新种类的产品，则需要修改抽象工厂接口以及所有的具体工厂实现。（上述java代码 “ 创建扩展了 AbstractFactory 的工厂类 ” 中@Override）
由于引入了抽象层，增加了系统的抽象性和理解难度。对于不熟悉该模式的开发人员来说，理解工厂方法的作用和应用场景可能会有一些困难。