【设计模式|创建型】抽象工厂模式（Abstract Factory Pattern）

背景

假设我们正在开发一个游戏，游戏中有不同种类的武器，包括剑、魔杖和弓箭。每种武器都有不同的攻击方法和特殊效果。我们可以使用抽象工厂模式来创建不同类型的武器。

解释

抽象工厂模式是一种创建型设计模式，用于创建相关或依赖对象的家族，而无需指定具体的类。该模式通过引入抽象工厂接口和抽象产品接口，将具体产品的创建延迟到具体工厂的实现类中。抽象工厂模式可以帮助我们实现产品族的创建和切换，提高了系统的灵活性和可扩展性。

主要角色：

• 抽象工厂（Abstract Factory）：定义了创建一系列产品的接口。
• 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体的产品对象。
• 抽象产品（Abstract Product）：定义了产品的共性，描述了产品的接口。
• 具体产品（Concrete Product）：实现了抽象产品接口，具体工厂负责创建具体产品的对象。

示例一

首先，我们定义一个武器接口，其中包含攻击方法和特殊效果方法：

public interface Weapon {
    void attack();
    void specialEffect();
}

然后，我们定义剑、魔杖和弓箭类，它们分别实现了武器接口：

public class Sword implements Weapon {
    @Override
    public void attack() {
        System.out.println("Attacking with sword");
    }

    @Override
    public void specialEffect() {
        System.out.println("No special effect");
    }
}

public class Wand implements Weapon {
    @Override
    public void attack() {
        System.out.println("Attacking with wand");
    }

    @Override
    public void specialEffect() {
        System.out.println("Casting spell");
    }
}

public class Bow implements Weapon {
    @Override
    public void attack() {
        System.out.println("Attacking with bow");
    }

    @Override
    public void specialEffect() {
        System.out.println("Shooting arrows");
    }
}

接下来，我们定义一个武器工厂接口，它包含创建剑、魔杖和弓箭的方法：

public interface WeaponFactory {
    Weapon createSword();
    Weapon createWand();
    Weapon createBow();
}

然后，我们可以实现不同的武器工厂来创建不同类型的武器。比如，剑工厂只创建剑：

public class SwordFactory implements WeaponFactory {
    @Override
    public Weapon createSword() {
        return new Sword();
    }

    @Override
    public Weapon createWand() {
        return null;
    }

    @Override
    public Weapon createBow() {
        return null;
    }
}

魔杖工厂只创建魔杖：

public class WandFactory implements WeaponFactory {
    @Override
    public Weapon createSword() {
        return null;
    }

    @Override
    public Weapon createWand() {
        return new Wand();
    }

    @Override
    public Weapon createBow() {
        return null;
    }
}

弓箭工厂只创建弓箭：

public class BowFactory implements WeaponFactory {
    @Override
    public Weapon createSword() {
        return null;
    }

    @Override
    public Weapon createWand() {
        return null;
    }

    @Override
    public Weapon createBow() {
        return new Bow();
    }
}

最后，我们可以使用武器工厂来创建不同类型的武器：

public class Main {
    public static void main(String[] args) {
        WeaponFactory swordFactory = new SwordFactory();
        Weapon sword = swordFactory.createSword();

        WeaponFactory wandFactory = new WandFactory();
        Weapon wand = wandFactory.createWand();

        WeaponFactory bowFactory = new BowFactory();
        Weapon bow = bowFactory.createBow();

        sword.attack();
        sword.specialEffect();

        wand.attack();
        wand.specialEffect();

        bow.attack();
        bow.specialEffect();
    }
}

运行结果：

Attacking with sword
No special effect
Attacking with wand
Casting spell
Attacking with bow
Shooting arrows

示例二

下面以一个手机工厂为例进行说明

定义抽象工厂接口：

// 抽象工厂接口
public interface PhoneFactory {
    // 创建手机屏幕
    Screen createScreen();

    // 创建手机电池
    Battery createBattery();
}

定义抽象产品接口：

// 抽象产品接口
public interface Screen {
    void display();
}

// 抽象产品接口
public interface Battery {
    void charge();
}

定义具体产品类：

// 具体产品类
public class AMOLED implements Screen {
    @Override
    public void display() {
        System.out.println("AMOLED screen is displaying.");
    }
}

// 具体产品类
public class LithiumBattery implements Battery {
    @Override
    public void charge() {
        System.out.println("Lithium battery is charging.");
    }
}

定义具体工厂类：

// 具体工厂类
public class SamsungFactory implements PhoneFactory {
    @Override
    public Screen createScreen() {
        return new AMOLED();
    }

    @Override
    public Battery createBattery() {
        return new LithiumBattery();
    }
}

// 具体工厂类
public class AppleFactory implements PhoneFactory {
    @Override
    public Screen createScreen() {
        return new RetinaScreen();
    }

    @Override
    public Battery createBattery() {
        return new LiPoly();
    }
}

客户端使用抽象工厂创建产品：

public class Client {
    public static void main(String[] args) {
        // 创建三星手机
        PhoneFactory samsungFactory = new SamsungFactory();
        Screen samsungScreen = samsungFactory.createScreen();
        Battery samsungBattery = samsungFactory.createBattery();
        samsungScreen.display();
        samsungBattery.charge();

        // 创建苹果手机
        PhoneFactory appleFactory = new AppleFactory();
        Screen appleScreen = appleFactory.createScreen();
        Battery appleBattery = appleFactory.createBattery();
        appleScreen.display();
        appleBattery.charge();
    }
}

运行结果：

AMOLED screen is displaying.
Lithium battery is charging.
Retina screen is displaying.
LiPoly battery is charging.