简单工厂与抽象工厂

谁是黄黄

已于 2022-07-03 23:32:50 修改

阅读量712

点赞数 1

分类专栏：各种模式文章标签： java 开发语言

于 2022-06-29 21:14:15 首次发布

本文链接：https://blog.csdn.net/weixin_43189971/article/details/125529702

版权

各种模式专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一.抽象模式概念

理解：外界调用者只负责管理如何调用对象，对象创建者只负责对象的实例化，使整个系统的设计更符合单一职责原则。

从问题出发

简单工厂是什么？是不是一个设计模式？如果使用？
工厂方法是什么？抽象了什么？
抽象工厂是什么？抽象了什么？
工厂方法和抽象工厂的区别？

二.简单工厂模式

2.1 理解

理解：

优点
灵活：我们在实例化对象的时候通常用的是 New关键字，但是有了工厂，我们在声明对象的时候就可以用工厂了，用new导致代码不够灵活，用工厂来实例化对象很灵活！

适用范围广：上帝类，一个含参的工厂方法，我们可以实例化任何产品类，上至飞机火箭，下至土豆面条，无所不能。

在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性

重要：客户端无需知道所创建的具体产品类的类名，只需要具体产品类对应的参数即可

简单工厂包含必要的判断逻辑，简单工厂实现了对象的创建和使用的分离

缺点

在遵循开闭原则（对拓展开放，对修改关闭）的原则下，对于新增加的产品无能为力，无法进行系统的维护和扩展。

由于要生产的子类种类太多，导致代码十分的臃肿

简单工厂中涉及判断，计算的业务一旦出错导致系统崩塌且难判断错误源

简单工厂的静态方法，使得工厂角色无法形成基于集成的等级结构。

2.2 spring中如何解决简单工厂的缺陷

注意：spring中也用到了简单工厂

小提示：spring中是通过配置文件和反射解决了简单工厂中的缺点

2.3 小例子

2.3.1 第一步：写入父类 Fruit

package com.huang.demo.p6;
public class Fruit {
    void sell()
    }
}

2.3.2 .第二步写出 Fruit的子类 Apple 和Bana

Apple

package com.huang.demo.p6;

public class Apple implements Fruit{

    public  Apple(){
        System.out.println("黄黄来买苹果了");
        //黄黄的苹果类中的苹果方法调用了苹果类中覆写的sell方法。
        this.sell();
    }

    @Override
    public void sell() {
        System.out.println("黄黄的苹果也是水果哇");
    }
}

Bana

package com.huang.demo.p6;

public class Bana implements  Fruit{

    public  Bana(){
        this.sell();
    }


    @Override
    public void sell() {
        System.out.println("黄黄的香蕉类不要香蕉");
    }
}

2.3.3 写出工厂类 Factory

package com.huang.demo.p6;


public class Factory {
    public  Fruit makeFruit (String fruitType){
        if (fruitType.equalsIgnoreCase("Apple")){
            return  new Apple();
        }
        else  if (fruitType.equalsIgnoreCase("Bana")){
            return  new Bana();
        }
        return  null;
    }
}

2.3.4 写出测试类

package com.huang.demo.p6;

public class Demo {
    public static void main(String[] args) {
        Factory factory = new Factory();

        //把值”Apple“传递给 factory工厂,进入makeFruit方法，再到工厂里进行匹配，看是那种水果，输出响应的水果的方法
       //接收的对象是父类Fruit
        Apple apple = (Apple) factory.makeFruit("Apple");


        //接收的对象是父类Fruit
        Fruit bana  = factory.makeFruit("Bana");
    }
}

三.工厂模式

3.1 概念：

3.1.1 理解：

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

3.1.1 应用实例：

1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以

3.1.2 使用场景：

复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

在这里插入图片描述

3.2 例子

例子：

第一步. 创造接口

package com.huang.demo.p4.shape;

public interface Shape {
    void draw();
}

第二步. 实际工作中想调用到的方法或者属性

1.circle 类

package com.huang.demo.p4.shape;

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

2.Rectangle类

package com.huang.demo.p4.shape;

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

Square类

package com.huang.demo.p4.shape;

public class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

第三步工厂类实现出来，工厂类里要干什么要先想好

package com.huang.demo.p4.factory;

import com.huang.demo.p4.shape.Circle;
import com.huang.demo.p4.shape.Rectangle;
import com.huang.demo.p4.shape.Shape;
import com.huang.demo.p4.shape.Square;

import java.awt.*;

public class ShapeFactory {
    //使用 getShape 方法获取形状类型的对象
    public Shape getShape(String shapeType){
        if(shapeType == null){
            return null;
        }
        if(shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        } else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
        return null;
    }
}

第四步 demo类即具体实现类写出来，重要的上面三步，要先想好调用什么功能，工厂类要怎么写，具体的被调用的类里面有什么我们想拿出来的东西

package com.huang.demo.p4;

import com.huang.demo.p4.factory.ShapeFactory;
import com.huang.demo.p4.shape.Shape;

public class demo {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();

        //获取 Circle 的对象，并调用它的 draw 方法
        Shape shape1 = shapeFactory.getShape("CIRCLE");

        //调用 Circle 的 draw 方法
        shape1.draw();

        //获取 Rectangle 的对象，并调用它的 draw 方法
        Shape shape2 = shapeFactory.getShape("RECTANGLE");

        //调用 Rectangle 的 draw 方法
        shape2.draw();

        //获取 Square 的对象，并调用它的 draw 方法
        Shape shape3 = shapeFactory.getShape("SQUARE");

        //调用 Square 的 draw 方法
        shape3.draw();
    }
}

四.抽象工厂模式

4.1 概念

概念：抽象工厂模式时工厂方法的泛化版，提供一个创建一系列相关或相互依赖的对象的接口，而无需指定他们具体的类，提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类，抽象工厂模式又称为Kit模式，属于对象创建模式。

4.2 了解的相关概念

引入概念
产品等级结构：产品的继承机构，比如抽象类时电视机，其子类是海尔电视机、海信电视机、长虹电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构
产品族：指同一个工厂生产的，位于不同产品等级结构的一组商品，如海尔电视机、海尔冰箱、海尔空调属于一个产品族，都由海尔工厂生产。

**优点：**当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

**缺点：**产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

在这里插入图片描述

说到底就是几个工厂组合到一起,然后再加一层，毕竟没什么是加一层解决不了的

4.3 小例子

第一步真实场景中先在脑子里构建号一个工厂模式

，我们需要什么就弄什么出来

color族的类的接口，跟简单工厂一样

package com.huang.demo.p3.color;

public interface Color {
    void fill();
}

color族的类的

Blue类

package com.huang.demo.p3.color;

public class Blue implements Color{
    @Override
    public void fill() {
        System.out.println("Inside Blue::fill() method.");
    }
}

Green类

package com.huang.demo.p3.color;

public class Green implements  Color{
    @Override
    public void fill() {
        System.out.println("Inside Green::fill() method.");
    }
}

Red类

package com.huang.demo.p3.color;

public class Red implements Color{
    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

shape族的类的接口，跟上一步一样，抽象工厂能扩充产品族就是这种，因为再加了一层所以能横切进去扩充一个产品族

package com.huang.demo.p3.shape;

public interface Shape {
    void  draw();
}

Square类

package com.huang.demo.p3.shape;

public class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");

    }
}

Circle类

package com.huang.demo.p3.shape;

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

Rectangele类

package com.huang.demo.p3.shape;

public class Rectangele implements  Shape{

    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");

    }
}

第二步，先写出为 Color 和 Shape 对象创建抽象类来获取工厂AbstractFactory

package com.huang.demo.p3.factory;
import com.huang.demo.p3.color.Color;
import com.huang.demo.p3.shape.Shape;


public abstract class AbstractFactory {
    public  abstract Color getColor(String color);
    public  abstract Shape getShape(String shape);
}

第三步创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象

color族的工厂类ColorFactory

package com.huang.demo.p3.factory;

import com.huang.demo.p3.color.Blue;
import com.huang.demo.p3.color.Color;
import com.huang.demo.p3.color.Green;
import com.huang.demo.p3.color.Red;
import com.huang.demo.p3.shape.Shape;

public class ColorFactory extends AbstractFactory{

    @Override
    public Shape getShape(String shapeType){
        return null;
    }



    //color的工厂来接受color
    @Override
    public Color getColor(String color) {
        if(color == null){
            return null;
        }
        if(color.equalsIgnoreCase("RED")){
            return new Red();
        } else if(color.equalsIgnoreCase("GREEN")){
            return new Green();
        } else if(color.equalsIgnoreCase("BLUE")){
            return new Blue();
        }
        return null;
    }


}

shape族的工厂类ShapeFactory

package com.huang.demo.p3.factory;

import com.huang.demo.p3.color.Color;
import com.huang.demo.p3.shape.Circle;
import com.huang.demo.p3.shape.Rectangele;
import com.huang.demo.p3.shape.Shape;
import com.huang.demo.p3.shape.Square;

public class ShapeFactory extends AbstractFactory{


    //同理，shape工厂来接受shape
    @Override
    public Shape getShape(String shapeType){
        if(shapeType == null){
            return null;
        }
        if(shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangele();
        } else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
        return null;
    }

    @Override
    public Color getColor(String color) {
        return null;
    }
}

第四步：

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

第五步.

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
 
      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取形状为 Rectangle 的对象
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
      
      //获取形状为 Square 的对象
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
 
      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
 
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
 
      //调用 Red 的 fill 方法
      color1.fill();
 
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("GREEN");
 
      //调用 Green 的 fill 方法
      color2.fill();
 
      //获取颜色为 Blue 的对象
      Color color3 = colorFactory.getColor("BLUE");
 
      //调用 Blue 的 fill 方法
      color3.fill();
   }
}