Java设计模式 | 工厂模式解析与实战-优快云博客

本文深入讲解工厂方法模式的定义、使用场景及不同实现方式，包括简单工厂、多工厂方法模式等，探讨其如何降低对象间耦合度并提高扩展性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义

定义一个用于创建对象的接口，让子类决定实例化哪个类。

工厂方法模式的使用场景

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。
复杂对象适合使用工厂模式，
简单用new就可以完成创建的对象无需使用工厂模式。

工厂方法模式的UML类图

● 抽象工厂，其为工厂方法模式的核心；
● 具体工厂，其实现了具体的业务逻辑；
● 抽象产品，工厂方法模式所创建的产品的父类；
● 具体产品，为实现抽象产品的某个具体产品的对象。

实战【下面demo主要有三种形式】

最简单的，只生产一种类型实例的写法：

    public abstract class Product {
        /**
         * 产品类的抽象方法
         *由具体的产品类去实现
         */
        public abstract void method();
    }
    //具体产品类A
    public class ConcreteProductA extends Product {
        @Override
        public void method() {
            System.out.println("我是具体的产品A");
        }
    }
    //具体产品类B
    public class ConcreteProductB extends Product {
        @Override
        public void method() {
            System.out.println("我是具体的产品B");
        }
    }

    //抽象工厂类
    public abstract class Factory {
        /**
         * 抽象工厂方法
         * 具体生产什么由子类去实现
         *
         * @return 具体的产品对象
         */
        public abstract Product createProduct();
    }
    //具体工厂类
    public class ConcreteFactory extends Factory {
        @Override
        public Product createProduct() {
            return new ConcreteProductA();
        }
    }

    //客户类
    public class Client {
        public static void main(String[] args) {
            Factory factory = new ConcreteFactory();
            Product p = factory.createProduct();
            p.method();
        }
    }

上面是生产产品A，如果要生产产品B，则手动修改工厂方法：

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

以上这种方式比较不灵活，不优雅，只是比较简单，
如果要生产的产品只有一种，就可以这样写；

但是如果要生产的产品有多种，
则建议用以下的动态写法！！！！！！！
通过反射、泛型来实现^^^^^^^^^^^^^^^^^^

public abstract class Factory {
        /**
         * 抽象工厂方法
         * 具体生产什么由子类去实现
         *
         * @param clz 产品对象类类型
         *
         * @return 具体的产品对象
         */
        public abstract <T extends Product> T createProduct(Class<T> clz);
    }

对于具体的工厂类，则通过反射获取类的示例即可：

public class ConcreteFactory extends Factory {
        @Override
        public <T extends Product> T createProduct(Class<T> clz) {
            Product p = null;
            try {
                p = (Product) Class.forName(clz.getName()).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) p;
        }
}

最后再来看看Client中的实现：

public class Client {
        public static void main(String[] args) {
            Factory factory = new ConcreteFactory();
            Product p = factory.createProduct(ConcreteProductB.class);
            p.method();
        }
    }

需要哪一个类的对象就传入哪一个类的类型即可，
这种方法比较简洁、动态；
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
【只有一个具体工厂类，
所有产品的构建
都挤在一个createProduct()中完成！】
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

而前面的两种工厂方法模式，
即如果确定工厂类只有一个，也可以简化掉抽象类！！！！！！！！！！！
将对应的工厂方法改为静态方法即可：
（这样的方式又称为简单工厂模式或静态工厂模式，
它是工厂方法模式的一个弱化版本）
这里只剩下三个元素，抽象 / 具体产品类、工厂类；

简单工厂模式 / 静态工厂模式

public class Factory {
        public static Product createProduct() {
            //构建逻辑
            return new ConcreteProductB();

            // return new ConcreteProductA();
        }
}

-------------------------------------------
//泛型
public class Factory {
        
        public <T extends Product> T createProduct(Class<T> clz) {
            Product p = null;
            try {
                p = (Product) Class.forName(clz.getName()).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) p;
        }
}

或者也可以用另外的形式，
尝试为每一个产品都定义一个具体的工厂，各司其职：
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
【与上面的形式相比，
这里拥有多个具体工厂类，
每个工厂类各自封装对应产品的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();
        }
}

public class Client {
        public static void main(String[] args) {
            Factory factoryA = new ConcreteFactoryA();
            Product productA = factoryA.createProduct();
            productA.method();
            Factory factoryB = new ConcreteFactoryB();
            Product productB = factoryB.createProduct();
            productB.method();
        }
    }