definição
O padrão de fábrica é um padrão de design criativo que fornece uma interface ou classe abstrata para criar objetos. Ele encapsula a lógica de criação de objetos e permite que o código do cliente crie objetos sem conhecer classes específicas ou detalhes de implementação.
A ideia principal por trás do padrão de fábrica é delegar a responsabilidade da criação do objeto a uma classe de fábrica separada. Essa classe de fábrica contém a lógica necessária para determinar a classe concreta para instanciar e retornar ao código do cliente. Dessa forma, o código do cliente apenas faz interface com a fábrica, tornando-o mais flexível e desacoplado do processo real de criação do objeto.
O padrão de fábrica é normalmente usado em cenários que exigem criação centralizada de objetos, flexibilidade para criar objetos com base em condições de tempo de execução e separação do código do cliente da implementação concreta. Ele ajuda a melhorar a capacidade de manutenção, escalabilidade e testabilidade do código.
Classificação
1. Padrão de fábrica simples : Esta é a forma básica do padrão de fábrica. Envolve uma única classe de fábrica com métodos que criam e retornam objetos com base em parâmetros ou entradas específicas. A classe de fábrica encapsula a lógica de criação e retorna o objeto apropriado. No entanto, ele viola o princípio aberto-fechado porque adicionar novos tipos de objetos requer modificar a classe de fábrica.
caso:
//抽象类
public abstract class Pizza {
public abstract void prepare();
public abstract void bake();
public abstract void cut();
public abstract void box();
}
//具体类
public class CheesePizza extends Pizza {
// Implementation of CheesePizza class
}
//具体类
public class PepperoniPizza extends Pizza {
// Implementation of PepperoniPizza class
}
//具体类
public class VeggiePizza extends Pizza {
// Implementation of VeggiePizza class
}
//简单工厂类（如果添加新的Pizza类型还需要更改该类）
public class SimplePizzaFactory {
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
}
return pizza;
}
}
//具体使用工厂类创建各种类。
public class PizzaStore {
private SimplePizzaFactory pizzaFactory;
public PizzaStore(SimplePizzaFactory pizzaFactory) {
this.pizzaFactory = pizzaFactory;
}
public Pizza orderPizza(String type) {
Pizza pizza = pizzaFactory.createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
//测试类
public class Test {
public static void main(String[] args) {
SimplePizzaFactory pizzaFactory = new SimplePizzaFactory();
PizzaStore pizzaStore = new PizzaStore(pizzaFactory);
Pizza cheesePizza = pizzaStore.orderPizza("cheese");
Pizza pepperoniPizza = pizzaStore.orderPizza("pepperoni");
Pizza veggiePizza = pizzaStore.orderPizza("veggie");
}
}
2. Padrão de método de fábrica : Este padrão define uma interface ou classe abstrata para criar objetos, mas delega a criação real para subclasses. Cada subclasse é responsável por criar um tipo específico de objeto. Isso permite mais flexibilidade e extensibilidade, pois novos tipos de objetos podem ser adicionados criando novas subclasses sem modificar o código existente.
caso:
//抽象类
public abstract class Vehicle {
public abstract void drive();
}
public class Car extends Vehicle {
// Implementation of Car class
}
public class Motorcycle extends Vehicle {
// Implementation of Motorcycle class
}
public class Truck extends Vehicle {
// Implementation of Truck class
}
//抽象工厂
public abstract class VehicleFactory {
public abstract Vehicle createVehicle();
}
//具体工厂
public class CarFactory extends VehicleFactory {
public Vehicle createVehicle() {
return new Car();
}
}
//具体工厂
public class MotorcycleFactory extends VehicleFactory {
public Vehicle createVehicle() {
return new Motorcycle();
}
}
//具体工厂
public class TruckFactory extends VehicleFactory {
public Vehicle createVehicle() {
return new Truck();
}
}
//测试
public class Test {
public static void main(String[] args) {
VehicleFactory carFactory = new CarFactory();
VehicleFactory motorcycleFactory = new MotorcycleFactory();
VehicleFactory truckFactory = new TruckFactory();
Vehicle car = carFactory.createVehicle();
Vehicle motorcycle = motorcycleFactory.createVehicle();
Vehicle truck = truckFactory.createVehicle();
car.drive();
motorcycle.drive();
truck.drive();
}
}
3. Padrão Abstract Factory : Este padrão fornece uma interface ou classe abstrata para criar uma série de objetos relacionados ou dependentes. Ele encapsula a criação de vários objetos que são projetados para trabalhar juntos. O código do cliente interage com a interface de fábrica abstrata e a implementação de fábrica concreta cria objetos relacionados. Esse padrão é útil quando há várias famílias de objetos e o código do cliente precisa criar a família de objetos de uma só vez.
Caso:
vamos considerar um cenário em que temos uma estrutura GUI (Graphical User Interface) compatível com diferentes sistemas operacionais, como Windows e macOS. Cada sistema operacional tem seu próprio conjunto de componentes de interface do usuário, como botões e caixas de seleção. Podemos usar o padrão de fábrica abstrato para criar uma série de componentes de interface do usuário relacionados para cada sistema operacional.
Primeiro, definimos a classe abstrata do componente de interface do usuário:
//公共工作的对象抽象
public interface Button {
void render();
}
public interface Checkbox {
void render();
}
//创建不同需求的具体实例
public class WindowsButton implements Button {
public void render() {
System.out.println("Rendering a Windows button");
}
}
public class WindowsCheckbox implements Checkbox {
public void render() {
System.out.println("Rendering a Windows checkbox");
}
}
public class MacOSButton implements Button {
public void render() {
System.out.println("Rendering a macOS button");
}
}
public class MacOSCheckbox implements Checkbox {
public void render() {
System.out.println("Rendering a macOS checkbox");
}
}
//创建一个抽象工厂类
public interface GUIFactory {
Button createButton();
Checkbox createCheckbox();
}
// 具体的工厂，这里和工厂模式思想一样。
public class WindowsFactory implements GUIFactory {
public Button createButton() {
return new WindowsButton();
}
public Checkbox createCheckbox() {
return new WindowsCheckbox();
}
}
public class MacOSFactory implements GUIFactory {
public Button createButton() {
return new MacOSButton();
}
public Checkbox createCheckbox() {
return new MacOSCheckbox();
}
}
//具体的应用
public class Application {
private GUIFactory factory;
private Button button;
private Checkbox checkbox;
public Application(GUIFactory factory) {
this.factory = factory;
}
public void createUI() {
button = factory.createButton();
checkbox = factory.createCheckbox();
}
public void renderUI() {
button.render();
checkbox.render();
}
}
public class Test {
public static void main(String[] args) {
Application windowsApp = new Application(new WindowsFactory());
windowsApp.createUI();
windowsApp.renderUI();
Application macApp = new Application(new MacOSFactory());
macApp.createUI();
macApp.renderUI();
}
}
vantagem:
1. Encapsulamento : A criação do objeto é encapsulada na fábrica, separando-a do código do cliente. Isso aumenta a capacidade de manutenção e a flexibilidade do código.
2. Acoplamento fraco : o código cliente só interage com a fábrica, reduzindo a dependência de classes específicas. Isso facilita a substituição de objetos de diferentes tipos.
3. Princípio da Responsabilidade Única : As fábricas são responsáveis pela criação de objetos e aderem ao princípio de que há uma única razão para mudar.
4. Reutilização de código : A fábrica pode ser reutilizada para criar vários objetos do mesmo tipo, reduzindo a duplicação de código.
deficiência:
**1. Complexidade: **A implementação do padrão de fábrica pode introduzir complexidade adicional à base de código, especialmente ao lidar com um grande número de classes e dependências concretas.
2. Aumentar a sobrecarga do código : O padrão de fábrica precisa criar classes adicionais, o que pode levar a um aumento da sobrecarga e da complexidade do código.
**3. Flexibilidade reduzida: **O padrão de fábrica pode não ser adequado para cenários em que a lógica de criação de objetos precisa ser altamente dinâmica ou configurável em tempo de execução.
4. Aumento do esforço inicial de desenvolvimento : A implementação do padrão de fábrica requer esforço inicial de projeto e desenvolvimento, que pode não ser justificado para aplicações simples ou de pequena escala.
Cenários de uso comuns
1. Criação de objetos : Quando o aplicativo precisa criar diferentes tipos de objetos de acordo com certas condições ou parâmetros, o padrão de fábrica pode ser usado para encapsular a lógica de criação de objetos.
2. Injeção de dependência : quando um aplicativo usa injeção de dependência para gerenciar dependências de objeto, o padrão de fábrica pode ser usado para criar e injetar as dependências necessárias.
3. Criação dinâmica de objetos : quando um aplicativo precisa criar objetos dinamicamente em tempo de execução, o padrão de fábrica pode ser usado para fornecer uma maneira flexível e extensível de criar objetos.
4. Teste : quando um aplicativo precisa criar objetos fictícios para teste, o padrão de fábrica pode ser usado para criar objetos fictícios que imitam o comportamento de objetos reais.
**5. Estruturas e bibliotecas:** Ao desenvolver uma estrutura ou biblioteca, o padrão de fábrica pode ser usado para fornecer aos clientes uma maneira padronizada de criar e interagir com objetos.