Java设计模式之简单工厂 工厂方法 抽象工厂深度总结

以下是“Java设计模式之简单工厂、工厂方法、抽象工厂深度总结”的完整攻略，包含两个示例。

简介

在Java开发中，设计模式是一种常用的编程思想，可以提高代码的可读性、可维护性和可扩展性。其中，简单工厂、工厂方法和抽象工厂是三种常用的创建型设计模式，用于创建对象和解耦合。本攻略将详细讲解这三种设计模式的原理、应用场景和实现方法，包括示例说明。

示例一：简单工厂模式

以下是简单工厂模式的示例：

1. 定义一个抽象产品类和多个具体产品类。

public abstract class Product {
    public abstract void use();
}

public class ConcreteProductA extends Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ConcreteProductB extends Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

1. 定义一个工厂类，根据不同的参数创建不同的产品对象。

public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type: " + type);
        }
    }
}

1. 在客户端代码中使用工厂类创建产品对象。

public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();

        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

通过以上步骤，我们可以使用简单工厂模式创建不同类型的产品对象，实现了对象的创建和解耦合。

示例二：工厂方法模式

以下是工厂方法模式的示例：

1. 定义一个抽象产品类和多个具体产品类。

public abstract class Product {
    public abstract void use();
}

public class ConcreteProductA extends Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ConcreteProductB extends Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

1. 定义一个抽象工厂类和多个具体工厂类，每个具体工厂类负责创建一种具体产品。

public abstract class Factory {
    public abstract Product createProduct();
}

public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

1. 在客户端代码中使用具体工厂类创建产品对象。

public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

通过以上步骤，我们可以使用工厂方法模式创建不同类型的产品对象，实现了对象的创建和解耦合。

示例三：抽象工厂模式

以下是抽象工厂模式的示例：

1. 定义一个抽象产品类和多个具体产品类。

public abstract class Product {
    public abstract void use();
}

public class ConcreteProductA1 extends Product {
    @Override
    public void use() {
        System.out.println("使用产品A1");
    }
}

public class ConcreteProductA2 extends Product {
    @Override
    public void use() {
        System.out.println("使用产品A2");
    }
}

public class ConcreteProductB1 extends Product {
    @Override
    public void use() {
        System.out.println("使用产品B1");
    }
}

public class ConcreteProductB2 extends Product {
    @Override
    public void use() {
        System.out.println("使用产品B2");
    }
}

1. 定义一个抽象工厂类和多个具体工厂类，每个具体工厂类负责创建一组相关的产品。

public abstract class Factory {
    public abstract Product createProductA();
    public abstract Product createProductB();
}

public class ConcreteFactory1 extends Factory {
    @Override
    public Product createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public Product createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 extends Factory {
    @Override
    public Product createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public Product createProductB() {
        return new ConcreteProductB2();
    }
}

1. 在客户端代码中使用具体工厂类创建产品对象。

public class Client {
    public static void main(String[] args) {
        Factory factory1 = new ConcreteFactory1();
        Product productA1 = factory1.createProductA();
        Product productB1 = factory1.createProductB();
        productA1.use();
        productB1.use();

        Factory factory2 = new ConcreteFactory2();
        Product productA2 = factory2.createProductA();
        Product productB2 = factory2.createProductB();
        productA2.use();
        productB2.use();
    }
}

通过以上步骤，我们可以使用抽象工厂模式创建一组相关的产品对象，实现了对象的创建和解耦合。

结论

通过攻略的学习，了解了Java设计模式之简单工厂、工厂方法、抽象工厂的原理、应用场景和实现方法，包括示例说明。我们提供了相应的示例，帮助您更好地掌握这三种设计模式的应用和实现方法。在实际应用中，我们需要根据具体的需求和场景选择合适的设计模式，并注意代码的可读性、可维护性和可扩展性。