【设计模式】java设计模式——抽象方法模式

此篇联系工厂方法模式来看

java设计模式——工厂方法模式_是瑞穗的猫啊的博客-CSDN博客

        工厂方法和抽象工厂的区别在于它们处理产品的方式不同，从而导致了对产品类型的限制和灵活性不同。

        工厂方法模式将产品的实例化延迟到工厂子类中执行。在工厂方法模式中，有一个抽象工厂接口或者抽象类，定义了创建产品的方法，该方法返回一个抽象产品类型。具体的工厂类继承抽象工厂，并负责创建具体类型的产品。这意味着每个具体的工厂类只能生产特定类型的产品，即只能生产该抽象产品的具体实现类的实例。因此，工厂方法模式可以理解为一种单一类型产品的创建方式。

        抽象工厂模式可以用于创建多个类型的产品，即一系列相关或兼容的产品。在抽象工厂模式中，抽象工厂接口或者抽象类定义了一组抽象方法，每个方法负责创建一种类型的产品。具体的工厂类实现抽象工厂，并且实现了所有抽象方法，每个方法可以创建一个具体类型的产品。这样，具体的工厂类可以根据客户端的需要创建一系列的产品，从而形成了产品族。因此，抽象工厂模式提供了一种创建多类型产品的方式。

举一个实例帮助理解

        假设我们正在开发一个游戏，其中包含两个不同的角色：骑士和法师。这两个角色都可以穿戴装备，而装备又分为武器和防具两种类型。

        首先，我们来看抽象工厂模式的应用。在这种情况下，我们可以定义一个抽象的角色工厂接口，该接口有两个抽象方法：createWeapon()——制造武器和createArmor()——制造防具。然后，我们可以创建两个具体的工厂类，分别是骑士工厂和法师工厂，它们分别实现了这个抽象工厂接口。骑士工厂负责创建骑士角色所需的武器和防具，法师工厂则负责创建法师角色所需的武器和防具。这样，我们可以根据不同的工厂选择，创建出相关的产品系列，即骑士角色所需的武器和防具，或者法师角色所需的武器和防具。

        接下来，我们考虑工厂方法模式的应用。在这种情况下，我们定义一个抽象的装备工厂接口，该接口有两个工厂方法：createWeapon()和createArmor()。然后，我们创建两个具体的工厂类，分别是骑士武器工厂和法师武器工厂，它们都实现了装备工厂接口。骑士武器工厂只负责创建骑士角色所需的武器，法师武器工厂则只负责创建法师角色所需的武器。类似地，我们还可以创建骑士防具工厂和法师防具工厂来分别创建不同角色所需的防具。这样，每个具体的装备工厂类只负责创建一种类型的装备，即工厂方法模式适用于创建单一类型产品。

       因此，抽象工厂模式适合创建一系列相关产品的情况，如骑士角色所需的武器和防具、法师角色所需的武器和防具。而工厂方法模式适用于创建单一类型产品，如只需要创建骑士角色所需的武器或者法师角色所需的武器。

可以看出：
工厂方法侧重于 不同工厂生产出不同的产品，实际用时会实现成很多种工厂
抽象工厂侧重于 同一工厂生产出一系列产品，实际用时可能只有一个实现类，但是生成的产品系列/结构不同。

应用场景：

• 工厂方法模式适用于单一产品等级结构，即每个具体工厂只负责创建一个具体产品。例如，每个具体工厂只创建苹果手机或安卓手机。
• 抽象工厂模式适用于多个产品等级结构，即每个具体工厂负责创建一族相关的产品。例如，一个具体工厂可以创建苹果手机和对应的iOS操作系统。

结构：

• 工厂方法模式中有一个抽象产品接口和多个具体产品类，还有一个抽象工厂接口和多个具体工厂类。每个具体工厂类只负责创建一个具体产品类。
• 抽象工厂模式中有多个抽象产品接口和多个具体产品类，还有一个抽象工厂接口和多个具体工厂类。每个具体工厂类负责创建一族相关的具体产品类。

工厂方法的UML的结构如下

抽象工厂的UML结构如下

        工厂方法模式： 假设我们有两个具体产品：iPhone和Samsung，并且每个产品都有一个对应的工厂类：iPhoneFactory和SamsungFactory。在工厂方法模式中，每个具体产品对应一个具体工厂类。具体代码如下：

// 工厂方法模式
// 抽象产品
interface Phone {
    void makeCall();
}
// 具体产品：iPhone
class iPhone implements Phone {
    public void makeCall() {
        System.out.println("Make a call using iPhone.");
    }
}
// 具体产品：Samsung
class Samsung implements Phone {
    public void makeCall() {
        System.out.println("Make a call using Samsung.");
    }
}
// 抽象工厂
interface PhoneFactory {
    Phone createPhone();
}
// 具体工厂：iPhone工厂
class iPhoneFactory implements PhoneFactory {
    public Phone createPhone() {
        return new iPhone();
    }
}
// 具体工厂：Samsung工厂
class SamsungFactory implements PhoneFactory {
    public Phone createPhone() {
        return new Samsung();
    }
}
// 客户端代码
public class FactoryMethodExample {
    public static void main(String[] args) {
        PhoneFactory factory = new iPhoneFactory();
        Phone phone = factory.createPhone();
        phone.makeCall();  // 输出：Make a call using iPhone.
        
        factory = new SamsungFactory();
        phone = factory.createPhone();
        phone.makeCall();  // 输出：Make a call using Samsung.
    }
}

在工厂方法模式中，每个具体产品（iPhone、Samsung）都有对应的具体工厂类（iPhoneFactory、SamsungFactory），每个具体工厂只负责创建相应的产品。

        抽象工厂模式： 假设我们需要生产不同品牌的手机和相应的操作系统，如苹果手机和安卓手机以及它们对应的iOS和Android操作系统。在抽象工厂模式中，手机和操作系统之间存在一种关联关系，并且每个品牌的手机都有对应的操作系统。具体代码如下：

// 抽象产品：手机
interface Phone {
    void makeCall();
}
// 具体产品：苹果手机
class iPhone implements Phone {
    public void makeCall() {
        System.out.println("Make a call using iPhone.");
    }
}
// 具体产品：安卓手机
class AndroidPhone implements Phone {
    public void makeCall() {
        System.out.println("Make a call using Android Phone.");
    }
}
// 抽象产品：操作系统
interface OperatingSystem {
    void run();
}
// 具体产品：iOS
class iOS implements OperatingSystem {
    public void run() {
        System.out.println("Running on iOS.");
    }
}
// 具体产品：Android
class Android implements OperatingSystem {
    public void run() {
        System.out.println("Running on Android.");
    }
}
// 抽象工厂
interface PhoneFactory {
    Phone createPhone();
    OperatingSystem createOperatingSystem();
}
// 具体工厂：苹果手机工厂
class iPhoneFactory implements PhoneFactory {
    public Phone createPhone() {
        return new iPhone();
    }
    public OperatingSystem createOperatingSystem() {
        return new iOS();
    }
}
// 具体工厂：安卓手机工厂
class AndroidPhoneFactory implements PhoneFactory {
    public Phone createPhone() {
        return new AndroidPhone();
    }
    public OperatingSystem createOperatingSystem() {
        return new Android();
    }
}
// 客户端代码
public class AbstractFactoryExample {
    public static void main(String[] args) {
        PhoneFactory factory = new iPhoneFactory();
        Phone phone = factory.createPhone();
        OperatingSystem os = factory.createOperatingSystem();

        phone.makeCall();  // 输出：Make a call using iPhone.
        os.run();         // 输出：Running on iOS.

        factory = new AndroidPhoneFactory();
        phone = factory.createPhone();
        os = factory.createOperatingSystem();

        phone.makeCall();  // 输出：Make a call using Android Phone.
        os.run();         // 输出：Running on Android.
    }
}

        在抽象工厂模式中，一个具体工厂（如iPhoneFactory）负责创建一族产品（iPhone和iOS），并且这些产品之间有一定的关联关系。同样地，另一个具体工厂（如AndroidPhoneFactory）负责创建另一族产品（AndroidPhone和Android）。