正文

深入浅出：抽象工厂方法模式类图解析与实战案例

/0 浏览量
0408

什么是抽象工厂方法模式？

抽象工厂方法模式是一种设计模式，它提供了一种创建相关或依赖对象的接口，而不需要明确指定具体类。这种模式让程序在运行时能够动态地选择具体实现，从而提高了代码的灵活性和可扩展性。

类图解析

1. 抽象工厂（AbstractFactory）

  • 职责：声明创建抽象产品的方法。
  • 类图：一个接口，定义了创建产品的抽象方法。
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

2. 具体工厂（ConcreteFactory）

  • 职责：实现抽象工厂接口，创建具体产品。
  • 类图：实现AbstractFactory接口的类。
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

3. 抽象产品（Product）

  • 职责：声明产品的接口，被所有创建的产品实现。
  • 类图：一个接口，定义了产品的公共方法。
public interface Product {
    void operation();
}

4. 具体产品（ConcreteProduct）

  • 职责：实现抽象产品的接口，定义具体产品的行为。
  • 类图：实现Product接口的类。
public class ProductA1 implements Product {
    @Override
    public void operation() {
        // 具体实现
    }
}

public class ProductA2 implements Product {
    @Override
    public void operation() {
        // 具体实现
    }
}

public class ProductB1 implements Product {
    @Override
    public void operation() {
        // 具体实现
    }
}

public class ProductB2 implements Product {
    @Override
    public void operation() {
        // 具体实现
    }
}

实战案例

假设我们要开发一个游戏，游戏中有角色和装备，角色可以装备不同的装备。为了简化问题，我们只考虑两种角色和两种装备。

1. 定义抽象工厂和具体工厂

public interface GameFactory {
    Character createCharacter();
    Equipment createEquipment();
}

public class FantasyGameFactory implements GameFactory {
    @Override
    public Character createCharacter() {
        return new FantasyCharacter();
    }

    @Override
    public Equipment createEquipment() {
        return new FantasyEquipment();
    }
}

public class SciFiGameFactory implements GameFactory {
    @Override
    public Character createCharacter() {
        return new SciFiCharacter();
    }

    @Override
    public Equipment createEquipment() {
        return new SciFiEquipment();
    }
}

2. 定义抽象产品和具体产品

public interface Character {
    void fight();
}

public class FantasyCharacter implements Character {
    @Override
    public void fight() {
        // 具体实现
    }
}

public class SciFiCharacter implements Character {
    @Override
    public void fight() {
        // 具体实现
    }
}

public interface Equipment {
    void use();
}

public class FantasyEquipment implements Equipment {
    @Override
    public void use() {
        // 具体实现
    }
}

public class SciFiEquipment implements Equipment {
    @Override
    public void use() {
        // 具体实现
    }
}

3. 使用抽象工厂创建对象

public class GameClient {
    public static void main(String[] args) {
        GameFactory gameFactory = new FantasyGameFactory();
        Character character = gameFactory.createCharacter();
        Equipment equipment = gameFactory.createEquipment();

        character.fight();
        equipment.use();
    }
}

通过以上示例，我们可以看到抽象工厂方法模式如何帮助我们创建相关或依赖对象，提高了代码的灵活性和可扩展性。在实际开发中，我们可以根据需求创建更多的具体工厂和具体产品，以满足不同的业务场景。

-- 展开阅读全文 --