【设计模式】一文带你搞懂什么是“工厂模式”和“抽象工厂模式”

        在Java中，工厂模式是一种广泛使用的设计模式，它属于创建型模式，旨在解决对象创建过程中的耦合问题，提高代码的复用性和扩展性。工厂模式通过定义一个共同的接口或抽象类来创建对象，客户端通过调用这个接口或抽象类来获取具体对象，而无需知道具体类的实现细节。工厂模式通常分为三种类型：简单工厂模式（Simple Factory Pattern）、工厂方法模式（Factory Method Pattern）和抽象工厂模式（Abstract Factory Pattern）。

一、简单工厂模式（Simple Factory Pattern）

        简单工厂模式是最基本的工厂模式，它通过一个工厂类来创建对象。客户端通过传递参数给工厂类来获取特定类型的对象，而无需关心对象的创建过程。这种模式也被称为静态工厂模式，因为它通常使用静态方法来创建对象。

优点：

• 客户端只需要知道工厂类，不需要知道具体的产品类。
• 减少了客户端与具体产品类的耦合。

缺点：

• 当需要增加新的产品时，需要修改工厂类的代码，违反了开闭原则（对扩展开放，对修改关闭）。

代码示例：

        假设我们有一个手机接口（Phone）和两个具体的手机实现类（Xiaomi和Meizu），以及一个工厂类（PhoneFactory）来创建手机对象。

// Phone接口  
public interface Phone {  
    void getBrand();  
}  
  
// Xiaomi实现类  
public class Xiaomi implements Phone {  
    @Override  
    public void getBrand() {  
        System.out.println("小米");  
    }  
}  
  
// Meizu实现类  
public class Meizu implements Phone {  
    @Override  
    public void getBrand() {  
        System.out.println("魅族");  
    }  
}  
  
// PhoneFactory工厂类  
public class PhoneFactory {  
    public static Phone getPhone(String phoneType) {  
        if ("小米".equals(phoneType)) {  
            return new Xiaomi();  
        } else if ("魅族".equals(phoneType)) {  
            return new Meizu();  
        } else {  
            return null;  
        }  
    }  
}  
  
// 消费者类  
public class Customer {  
    public static void main(String[] args) {  
        Phone xiaomi = PhoneFactory.getPhone("小米");  
        xiaomi.getBrand(); // 输出：小米  
  
        Phone meizu = PhoneFactory.getPhone("魅族");  
        meizu.getBrand(); // 输出：魅族  
    }  
}

二、工厂方法模式（Factory Method Pattern）

        工厂方法模式通过定义一个用于创建对象的接口，但将实际创建工作延迟到子类。每个子类都可以实现工厂接口以提供具体的对象实例化过程。这样，客户端通过调用工厂方法来创建所需的对象，实现了对象的解耦。

优点：

• 客户端不需要在代码中指定具体产品的类。
• 增加了系统的扩展性和灵活性，遵循了开闭原则。

缺点：

• 类的个数会增多，增加了系统的复杂性。

代码示例：

        假设我们有一个电视（TV）的抽象类和两个具体的电视实现类（SamsungTV和LGTV），以及一个工厂接口（TVFactory）和两个具体的工厂实现类（SamsungTVFactory和LGTVFactory）来创建电视对象。

// TV抽象类  
public abstract class TV {  
    public abstract void play();  
}  
  
// SamsungTV实现类  
public class SamsungTV extends TV {  
    @Override  
    public void play() {  
        System.out.println("Playing Samsung TV...");  
    }  
}  
  
// LGTV实现类  
public class LGTV extends TV {  
    @Override  
    public void play() {  
        System.out.println("Playing LG TV...");  
    }  
}  
  
// TVFactory接口  
public interface TVFactory {  
    TV createTV();  
}  
  
// SamsungTVFactory工厂类  
public class SamsungTVFactory implements TVFactory {  
    @Override  
    public TV createTV() {  
        return new SamsungTV();  
    }  
}  
  
// LGTVFactory工厂类  
public class LGTVFactory implements TVFactory {  
    @Override  
    public TV createTV() {  
        return new LGTV();  
    }  
}  
  
// 消费者类  
public class Customer {  
    public static void main(String[] args) {  
        TVFactory samsungFactory = new SamsungTVFactory();  
        TV samsungTV = samsungFactory.createTV();  
        samsungTV.play(); // 输出：Playing Samsung TV...  
  
        TVFactory lgFactory = new LGTVFactory();  
        TV lgTV

三、抽象工厂模式（Abstract Factory Pattern）

        抽象工厂模式是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式允许客户端在不指定具体类的情况下，创建一系列的产品对象。在这个模式中，一个具体的工厂类能够创建一系列相互关联或相互依赖的产品对象，这些产品对象属于同一个产品族。

结构:

• 抽象工厂（Abstract Factory）：声明一个用于创建对象的接口。
• 具体工厂（Concrete Factory）：实现抽象工厂接口，创建具体产品的实例。
• 抽象产品（Abstract Product）：定义产品的接口。
• 具体产品（Concrete Product）：实现了抽象产品接口的具体类的实例。由具体工厂类创建。

优点:

1. 封装性：客户端不需要知道具体产品的创建细节，只需要知道对应工厂的接口。
2. 扩展性：当需要增加新的产品族时，只需要增加新的具体工厂类，而不需要修改现有的系统结构。
3. 解耦：将产品的创建与使用过程分离，客户端只需要通过抽象工厂和抽象产品接口来操作实例，减少了客户端与具体产品类之间的耦合。

缺点:

1. 系统复杂度增加：由于引入了抽象层，增加了系统的抽象性和理解难度。
2. 难以支持新种类的产品：如果抽象工厂接口中增加一个新的抽象方法，则所有具体工厂类都需要实现这个方法，否则编译不通过。这增加了系统扩展和维护的难度。
3. 开闭原则的倾斜：虽然抽象工厂模式对“产品族”的扩展是开放的，但对“产品等级”的修改（增加新的抽象方法）则是不友好的，违反了开闭原则的部分原则。

代码示例:

        以下是一个简单的抽象工厂模式示例，假设我们有一个按钮（Button）和文本框（TextBox）的接口，以及它们的实现类，我们使用抽象工厂来创建这些UI组件的不同风格（如Windows风格和Mac风格）。

// 抽象产品 - Button  
public interface Button {  
    void paint();  
}  
  
// 具体产品 - WindowsButton  
public class WindowsButton implements Button {  
    @Override  
    public void paint() {  
        System.out.println("Rendering a Windows button");  
    }  
}  
  
// 具体产品 - MacButton  
public class MacButton implements Button {  
    @Override  
    public void paint() {  
        System.out.println("Rendering a Mac button");  
    }  
}  
  
// 抽象产品 - TextBox  
public interface TextBox {  
    void display();  
}  
  
// 具体产品 - WindowsTextBox  
public class WindowsTextBox implements TextBox {  
    @Override  
    public void display() {  
        System.out.println("Displaying a Windows text box");  
    }  
}  
  
// 具体产品 - MacTextBox  
public class MacTextBox implements TextBox {  
    @Override  
    public void display() {  
        System.out.println("Displaying a Mac text box");  
    }  
}  
  
// 抽象工厂  
public interface UIFactory {  
    Button createButton();  
    TextBox createTextBox();  
}  
  
// 具体工厂 - WindowsFactory  
public class WindowsFactory implements UIFactory {  
    @Override  
    public Button createButton() {  
        return new WindowsButton();  
    }  
  
    @Override  
    public TextBox createTextBox() {  
        return new WindowsTextBox();  
    }  
}  
  
// 具体工厂 - MacFactory  
public class MacFactory implements UIFactory {  
    @Override  
    public Button createButton() {  
        return new MacButton();  
    }  
  
    @Override  
    public TextBox createTextBox() {  
        return new MacTextBox();  
    }  
}  
  
// 客户端代码  
public class Application {  
    public static void main(String[] args) {  
        UIFactory windowsFactory = new WindowsFactory();  
        Button windowsButton = windowsFactory.createButton();  
        windowsButton.paint(); // 输出：Rendering a Windows button  
  
        TextBox windowsTextBox = windowsFactory.createTextBox();  
        windowsTextBox.display(); // 输出：Displaying a Windows text box  
  
        UIFactory macFactory = new MacFactory();  
        Button macButton = macFactory.createButton();  
        macButton.paint(); // 输出：Rendering a Mac button  
  
        TextBox macTextBox = macFactory.createTextBox();  
        macTextBox.display(); // 输出：Displaying a Mac text box  
    }  
}