java的三种工厂模式是什么？

Java的三种工厂模式解析

工厂模式是Java中常用的一种设计模式，关键用于对象的创建。它可以将对象的创建与使用解耦，提高程序的扩展性和可维护性。Java中的工厂模式关键有三种：简洁工厂模式、工厂方法模式和抽象工厂模式。下面将详细介绍这三种工厂模式的特点和应用。

1. 简洁工厂模式

简洁工厂模式是最基础的工厂模式，它由一个工厂类负责创建所有产品对象。客户端只需要传入相应的参数，就可以获取到所需的产品对象。以下是一个简洁工厂模式的示例：

class Product {
    public void show() {
        System.out.println("这是一个产品");
    }
}
class ConcreteProductA extends Product {
    @Override
    public void show() {
        System.out.println("这是具体产品A");
    }
}
class ConcreteProductB extends Product {
    @Override
    public void show() {
        System.out.println("这是具体产品B");
    }
}
class Factory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            return null;
        }
    }
}
public class SimpleFactoryTest {
    public static void main(String[] args) {
        Product productA = Factory.createProduct("A");
        productA.show();
        Product productB = Factory.createProduct("B");
        productB.show();
    }
}

2. 工厂方法模式

工厂方法模式将创建对象的任务委托给子类实现，每个子类负责创建一种产品对象。这种模式将对象的创建延迟到子类，提高了程序的扩展性。以下是一个工厂方法模式的示例：

interface Product {
    void show();
}
class ConcreteProductA implements Product {
    @Override
    public void show() {
        System.out.println("这是具体产品A");
    }
}
class ConcreteProductB implements Product {
    @Override
    public void show() {
        System.out.println("这是具体产品B");
    }
}
interface Factory {
    Product createProduct();
}
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
public class FactoryMethodTest {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.show();
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.show();
    }
}

3. 抽象工厂模式

抽象工厂模式是工厂方法模式的升级版，它不仅负责创建单个产品，而是负责创建一系列相关的产品。这些产品属于同一产品族，具有相同的主题。以下是一个抽象工厂模式的示例：

interface ProductA {
    void show();
}
interface ProductB {
    void show();
}
class ConcreteProductA1 implements ProductA {
    @Override
    public void show() {
        System.out.println("这是产品A1");
    }
}
class ConcreteProductA2 implements ProductA {
    @Override
    public void show() {
        System.out.println("这是产品A2");
    }
}
class ConcreteProductB1 implements ProductB {
    @Override
    public void show() {
        System.out.println("这是产品B1");
    }
}
class ConcreteProductB2 implements ProductB {
    @Override
    public void show() {
        System.out.println("这是产品B2");
    }
}
interface Factory {
    ProductA createProductA();
    ProductB createProductB();
}
class ConcreteFactory1 implements Factory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}
class ConcreteFactory2 implements Factory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}
public class AbstractFactoryTest {
    public static void main(String[] args) {
        Factory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.show();
        ProductB productB1 = factory1.createProductB();
        productB1.show();
        Factory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA
本文由IT视界版权所有,禁止未经同意的情况下转发