工厂模式并不难理解-CSDN博客

本文链接：https://blog.csdn.net/qq_55931044/article/details/132416577

文章目录

工厂模式

工厂模式

功能：将对象的创建交给工厂，我们只需要告诉工厂我们要什么对象就可以得到该对象。

目的：实现创建对象和使用对象分离；让我们更加关注需要什么，而不是这个是怎么来的。

工厂模式根据不同的创建场景和创建需求可以分为：简单工厂、工厂方法、抽象工厂。

例如：现在需要制造汽车，汽车有不同的颜色，将不同的颜色分成类。

将汽车抽象为一个Car抽象类，不同颜色的汽车分别继承它。

public abstract class Car {
    String color;
    public  abstract  void carColor();
    public  void carSpeed(){
        System.out.println(String.format("正在生产%s的汽车,时速100KM/h",color));
    }
    public  void carPrice(){
        System.out.println(String.format("正在生产%s的汽车,价格10W",color));
    }
}

public class BlackCar extends  Car {
    public BlackCar() {
        this.color = "黑色";
    }

    @Override
    public void carColor() {
        System.out.println(String.format("生产的是%s的车",color));
    }
}

public class PinkCar extends Car {
    public PinkCar() {
        this.color = "粉色";
    }

    @Override
    public void carColor() {
        System.out.println(String.format("生产的是%s的车",color));
    }
}

在最开始我们要创建什么汽车就会手动的new对应的汽车，

简单工厂模式

简单工厂不是一种设计模式，它是为接下来的工厂方法模式提供基础的。

通过简单工厂模式会创建如下的一个工厂：

public class SimpleFactory {
    public Car creatCar(String color){
        if ("pink".equals(color)){
            return new PinkCar();
        }else if("black".equals(color)){
            return new BlackCar();
        }else {
            System.out.println("无法制造"+color+"颜色的车");
            return null;
        }
    }
}

测试代码：

public class Test {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Car pink = factory.creatCar("pink");
        pink.carColor();
        pink.carPrice();
        pink.carSpeed();
    }
}

/*
生产的是粉色的车
正在生产粉色的汽车,价格10W
正在生产粉色的汽车,时速100KM/h
*/

类图如下：

在这里插入图片描述

用标识符“pink”传递非常容易出错，我们可以使用java提供的反射，此时简单工厂变为：

public class SimpleFactory {
    public Car creatCar(Class<? extends Car> clazz){
        try {
            return  clazz.newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

测试代码变为：

public class Test {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Car pink = factory.creatCar(PinkCar.class);
        pink.carColor();
        pink.carPrice();
        pink.carSpeed();
    }
}

类图如下：用户之和工厂之间有联系，而和具体的汽车类是没有联系的。

在这里插入图片描述

简单工厂模式使用的场景

工厂负责创建的对象较少。

客户端只需要出入一个工厂类的参数，对于内部的逻辑不用关心。

优点：只需要插入一个正确的参数，无需在意细节。

缺点：工厂类的职责相对较重，新增产品时需要修改工厂的逻辑，违背开闭原则。不宜扩展过于复杂的产品结构。

工厂方法模式

简单工厂模式中，一旦需要大规模的添加新的创建对象时需要修改工厂的逻辑，违背开闭原则，不方便使用。

工厂方法模式与简单工厂模式不同的是：方法工厂模式会为每一个类创建一个工厂，用的时候就会创建自己对应的工厂，通过对应的工厂创建对象；再创建一个总工厂，就是对工厂的抽象。

三个汽车类不变，

创建对应的工厂类

public abstract class CarFactory {
    abstract Car creatCar();
}

public class PinkCarFactory extends CarFactory{
    @Override
    Car creatCar() {
        System.out.println("正在生产粉色汽车");
        return new PinkCar();
    }
}

public class BlackCarFactory extends CarFactory {
    @Override
    Car creatCar() {
        System.out.println("正在生产黑色汽车");
        return new BlackCar();
    }
}

测试：

public static void main(String[] args) {
        CarFactory  carFactory = null ;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您想要生产的汽车颜色");
        String s = scanner.next();
        if(s.equals("black")){
            carFactory = new BlackCarFactory();
        }else if(s.equals("pink")){
            carFactory = new PinkCarFactory();
        }else {
            System.out.println("没有这类颜色的车");
        }
        carFactory.creatCar();
    }

在这里插入图片描述

工厂方法模式使用场景

创建对象需要大量重复的代码。

优点：

产品只需要要关心对应的工厂，无需关心创建细节。

加入新的产品时符合开闭原则，提高系统的可扩展性。

缺点：

类的数量过多，增加了代码结构的复杂度。

增加了系统的抽象性和理解难度。

抽象工厂模式

是为访问类提供一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类，就能得到同族的不同等级的产品。

什么意思呢？

在这里插入图片描述

利用B站视屏的例子：
在这里插入图片描述

左图中商务一套搭配属于同一族，右边运动服属于一族，右边的外套和左边的外套属于不同组的同一个等级，右图中的上衣，裤子，鞋是同族的不同等级产品。

以上提到的只是汽车的颜色不同，例如，无论什么颜色的车都有七座和五座两种。

结构

抽象工厂：提供创建产品的接口，包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

还是上面那个汽车案例，要求：黑色汽车安装A类引擎，粉色汽车安装B类引擎。则黑色汽车和A类引擎是同一族，粉色汽车和黑色汽车是同一等级。

具体实现：

具体产品和抽象产品:

public abstract class Car {
    String color;
    public  abstract  void carColor();
}

public class BlackCar extends Car  {
    public BlackCar() {
        this.color = "黑色";
    }

    @Override
    public void carColor() {
        System.out.println(String.format("生产的是%s的车", color));
    }
}

public class PinkCar extends Car  {
    public PinkCar() {
        this.color = "粉色";
    }

    @Override
    public void carColor() {
        System.out.println(String.format("生产的是%s的车", color));
    }
}

public abstract class Engine {
    abstract void getEngine();
}

public class EngineA extends Engine{
    @Override
    void getEngine() {
        System.out.println("引擎A");
    }
}

public class EngineB extends Engine{
    @Override
    void getEngine() {
        System.out.println("引擎B");
    }
}

具体工厂和抽象工厂:

public abstract interface CarFactory {
    //生产汽车
     Car creatCar();
    //生产引擎
      Engine creatEngine();
}

public class BlackFactory implements   CarFactory{
    @Override
    public Car creatCar() {
        return new BlackCar();
    }
    @Override
    public Engine creatEngine() {
        return new EngineA();
    }
}

public class PinkCarFactory implements CarFactory {
    @Override
    public Car creatCar() {
        return new PinkCar();
    }
    @Override
    public Engine creatEngine() {
        return new EngineB();
    }
}

test:

public class Test {
    public static void main(String[] args) {
        BlackFactory blackFactory = new BlackFactory();
        Car car = blackFactory.creatCar();
        Engine engine = blackFactory.creatEngine();
        car.carColor();
        engine.getEngine();

        PinkCarFactory pinkCarFactory = new PinkCarFactory();
        Car car1 = pinkCarFactory.creatCar();
        Engine engine1 = pinkCarFactory.creatEngine();
        car1.carColor();
        engine1.getEngine();
    }
}
/*
生产的是黑色的车
引擎A
生产的是粉色的车
引擎B
*/