设计模式之工厂模式

最新推荐文章于 2025-06-01 19:34:47 发布

Java人人

最新推荐文章于 2025-06-01 19:34:47 发布

阅读量63

点赞数

文章标签： java

原文链接：https://www.search1990.com/

版权

顾名思义，工厂设计模式用于生成对象。在Java中，一切都是对象，需要创建这些对象。如果我们在创建对象时直接new对象，工程与该对象将严重耦合。如果我们想替换对象，所有new对象的位置都需要修改，这显然违反了软件设计的开闭原则，如果我们使用工厂来生产对象，我们只需处理工厂，与对象完全解耦。如果要更换对象，可以直接在工厂更换对象，达到了与对象解耦的目的；因此，工厂模式（Factory Pattern）的最大优势是解耦。

注：开闭原则 (The Open/Closed Principle, OCP) 规定“软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的”。

在工厂模式下，在创建对象时，我们不向客户端公开创建逻辑，而是使用共同的接口指向新创建的对象。

简单工厂（Simple Factory）

一种工厂方法，根据传入的参数生成相应的产品对象；

角色：

1、抽象产品
2、具体产品
3、具体工厂
4、产品使用者

使用说明：首先，抽象产品类。例如，苹果和梨属于水果，抽象出一个水果类Fruit。苹果和梨是更具体的产品类，然后创建一个水果工厂，分别创建苹果和梨。代码如下：

水果接口：

public interface Fruit {
	void whatIm();
}

苹果类：

public class Apple implements Fruit {
    @Override
    public void whatIm(){
        System.out.println("苹果");
    }
}

梨类：

public class Pear implements Fruit {
    @Override
    public void whatIm(){
        System.out.println("梨");
    }
}

水果工厂：

public class FruitFactory {
    public Fruit createFruit(String type) {
            //生产苹果
        if ("apple".equals(type)) {
            return new Apple();
            //生产梨
        } else if ("pear".equals(type)) {
            return new Pear();
        }
        return null;
    }
}

使用工厂生产水果：

public class FruitApp {
    public static void main(String[] args) {
        FruitFactory fruitFactory = new FruitFactory();
        //获得苹果
        Apple apple = (Apple) fruitFactory.createFruit("apple");
        //获得梨
        Pear pear = (Pear) fruitFactory.createFruit("pear");
        apple.whatIm();
        pear.whatIm();
    }
}

这样，无论何时添加水果新种类，都必须修改FruitFactory类，这违反了开闭原则；
因此，简单工厂只适合产品对象少、产品固定的需求，显然不适合产品不断变化的情况。

工厂方法（Factory Method）

定义：

将工厂抽取成接口或抽象类，具体生产什么产品由子类决定；

角色：

1、抽象产品
2、具体产品
3、抽象工厂
4、具体工厂

使用说明：

和上例中一样，产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定。

如上例，产品类是抽象出来。这一次，我们还抽象了工厂类。生产什么样的产品取决于子类。代码如下：

水果接口、苹果类和梨类：

代码和上例一样

抽象工厂接口：

public interface FruitGreatFactory {
    /**
     * 生产水果
     *
     * @return : com.junior.practice.Fruit
     */
    Fruit createFruit();
}

苹果工厂：

public class AppleFactory implements FruitGreatFactory {
    /**
     * 生产苹果
     *
     * @return : com.junior.practice.Fruit
     */
    @Override
    public Apple createFruit() {
        return new Apple();
    }
}

梨工厂：

public class PearFactory implements FruitGreatFactory{
    /**
     * 生产梨
     *
     * @return : com.junior.practice.Fruit
     */
    @Override
    public Pear createFruit() {
        return new Pear();
    }
}

使用工厂生产产品：

public class FruitApp {
    public static void main(String[] args) {
        AppleFactory appleFactory = new AppleFactory();
        PearFactory pearFactory = new PearFactory();
        //获得苹果
        Apple apple = appleFactory.createFruit();
        //获得梨
        Pear pear = pearFactory.createFruit();
        apple.whatIm();
        pear.whatIm();
    }
}

虽然上述方法是解耦的，遵循开闭原则，但如果我需要很多产品，需要创建很多工厂，所以这种方法的缺点也很明显。

抽象工厂（Abstract Factory）

定义：

一个接口，用于创建一组相关或相互依赖的对象，而无需指定它们的具体类。

角色：

抽象产品
具体产品
抽象工厂
具体工厂

使用说明：

抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；举个例子，假如生产小米手机，小米手机有很多系列，小米note、红米note等；假如小米note生产需要的配件有825的处理器，6英寸屏幕，而红米只需要650的处理器和5寸的屏幕就可以了。用抽象工厂来实现：

抽象工厂的模式与工厂方法的模式基本相同。区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以生产一组具有相对关系的产品；重点是一组、一批、一系列；例如，如果生产小米手机，小米手机有很多系列，如小米Note、红米Note等；如果小米Note生产所需的配件是825处理器和6英寸屏幕，而红米Note只需要650处理器和5英寸屏幕。用抽象工厂来实现：

Cpu接口和实现类：

public interface Cpu {
    /**
     * 配置
     *
     * @return : void
     */
    void run();

    class Cpu650 implements Cpu {

        @Override
        public void run() {
            System.out.println("650也厉害");
        }
    }

    class Cpu825 implements Cpu {

        @Override
        public void run() {
            System.out.println("825更强劲");
        }
    }
}

屏幕接口和实现类：

public interface Screen {
    /**
     * 尺寸
     *
     * @return : void
     */
    void size();

    class Screen5 implements Screen {

        @Override
        public void size() {
            System.out.println("5英寸");
        }
    }

    class Screen6 implements Screen {

        @Override
        public void size() {
            System.out.println("6英寸");
        }
    }
}

抽象工厂接口：

public interface PhoneFactory {
    /**
     * 使用的CPU
     *
     * @return : com.junior.practice.Cpu
     */
    Cpu getCpu();

    /**
     * 使用的屏幕
     *
     * @return : com.junior.practice.Screen
     */
    Screen getScreen();
}

小米手机工厂：

public class XiaoMiFactory implements PhoneFactory {
    @Override
    public Cpu.Cpu825 getCpu() {
        return new Cpu.Cpu825();
    }

    @Override
    public Screen.Screen6 getScreen() {
        return new Screen.Screen6();
    }
}

红米手机工厂：

public class RedMiFactory implements PhoneFactory {
    @Override
    public Cpu.Cpu650 getCpu() {
        return new Cpu.Cpu650();
    }

    @Override
    public Screen.Screen5 getScreen() {
        return new Screen.Screen5();
    }
}

使用工厂生产产品：

public class PhoneApp {
    public static void main(String[] args) {
        RedMiFactory redMiFactory = new RedMiFactory();
        XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
        Cpu.Cpu650 cpu650 = redMiFactory.getCpu();
        Cpu.Cpu825 cpu825 = xiaoMiFactory.getCpu();
        cpu650.run();
        cpu825.run();

        Screen.Screen5 screen5 = redMiFactory.getScreen();
        Screen.Screen6 screen6 = xiaoMiFactory.getScreen();
        screen5.size();
        screen6.size();
    }
}

从上面的例子可以看出，抽象工厂可以满足一系列产品的生产需要。对于大批量、多系列的产品，可以使用抽象工厂进行更好的管理和扩展。