设计模式-工厂模式 Factory Pattern(简单工厂、工厂方法、抽象工厂)

简介: 这篇文章详细解释了工厂模式,包括简单工厂、工厂方法和抽象工厂三种类型。每种模式都通过代码示例展示了其应用场景和实现方法,并比较了它们之间的差异。简单工厂模式通过一个工厂类来创建各种产品;工厂方法模式通过定义一个创建对象的接口,由子类决定实例化哪个类;抽象工厂模式提供一个创建相关或依赖对象家族的接口,而不需要明确指定具体类。

工厂模式 Factory Pattern(简单工厂、工厂方法、抽象工厂)

工厂模式-创建型模式-提供了创建对象的最佳方式。

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

简单工厂

简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式由一个工厂对象决定创建出哪一种产品类的实例。(工厂类拥有一个工厂方法(create),接受了一个参数,通过不同的参数实例化不同的产品类。)

定义了一个创建对象的类,由这个类来封装实例化对象的行为。

例子:一个汽车生产工厂,生产不同品牌的汽车,每台汽车具有说广告标语的行为。将汽车生产工厂封装成一个简单工厂类。说汽车广告标语的行为封装为一个接口。

在这里插入图片描述

接口:

package com.robin.factoryPattern.simpleFactory;

public interface Moveable {
   

    void RunRoad();
}

品牌汽车类:

比亚迪:

package com.robin.factoryPattern.simpleFactory;

// 比亚迪
public class BydCar implements Moveable {
   

    @Override
    public void RunRoad() {
   
        System.out.println("[比亚迪]:一路同驰骋");
    }
}

法拉利:

package com.robin.factoryPattern.simpleFactory;

// 法拉利汽车
public class FerrariCar implements Moveable {
   

    @Override
    public void RunRoad() {
   
        System.out.println("[法拉利]:对车手来说,是速度\n" +
                "对小孩来说,是红色\n" +
                "对父亲来说,是血液\n" +
                "对车迷来说,是情人\n" +
                "对个人来说,是挑战\n" +
                "对一群人来说,是传奇\n" +
                "对我们来说,是一切");
    }
}

五菱宏光:

package com.robin.factoryPattern.simpleFactory;

// 五菱汽车
public class WuLingCar implements Moveable {
   

    @Override
    public void RunRoad() {
   
        System.out.println("[五菱宏光]:人民需要什么,五菱就造什么");
    }
}

简单工厂类:

package com.robin.factoryPattern.simpleFactory;

public class SimpleFactory {
   

    // 根据传入参数进行不同汽车的生产
    public Moveable getVehicle(String vehicleName){
   
        if (vehicleName.equalsIgnoreCase("BYD")){
   
            return new BydCar();
        }else if(vehicleName.equalsIgnoreCase("FERRARI")){
   
            return new FerrariCar();
        }else if(vehicleName.equalsIgnoreCase("WULING")){
   
            return new WuLingCar();
        }
        return null;
    }
}

客户端类:

package com.robin.factoryPattern.simpleFactory;

import java.util.Scanner;

public class Main {
   
    public static void main(String[] args) {
   
        // 充当客户端 利用一个While循环测试
        while (true){
   
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入汽车名称:");
            String carName = scanner.next();
            Moveable m = new SimpleFactory().getVehicle(carName);
            if (m==null){
   
                break;
            }else {
   
                m.RunRoad();
            }
        }
        System.out.println("=====over=====");
    }
}

在这里插入图片描述

小结:当我们需要新的品牌汽车时,在简单工厂类中进行代码修改即可。

  • 优点:很明显,简单工厂的特点就是“简单粗暴”,通过一个含参的工厂方法,可以实例化任何产品类。
  • 缺点:
    • 任何”东西“的子类都可以被生产,负担太重。当所要生产产品种类非常多时,工厂方法的代码量可能会很庞大
    • 没有遵循开闭原则(对拓展开放,对修改关闭),简单工厂对于增加新的产品,无能为力。因为增加新产品只能通过修改工厂方法来实现。

工厂方法

结合上面的简单工厂,工厂方法进一步解耦合,把工厂类进行抽象,不再负责所有实例的创建,而是把具体的创建工作交给其子类去完成,实例化延迟到子类加载,由子类来决定要实例化的类。

一句话概括就是,工厂方法定义了一个对象的接口,但由子类去决定实例化的类是哪一个。

一个电脑配件工厂,创建对应的品牌配件。

在这里插入图片描述

鼠标接口(打印名称):

package com.robin.factoryPattern.factoryMethod;

public interface CpParts {
   
    void printName();
}

鼠标工厂方法类:

package com.robin.factoryPattern.factoryMethod;

public abstract class CpPartsFactory {
   

    public abstract CpParts create();
}

鼠标实现类工厂:

package com.robin.factoryPattern.factoryMethod;

public class HpMouseFactory extends CpPartsFactory implements CpParts{
   

    @Override
    public void printName() {
   
        System.out.println("惠普鼠标 created!");
    }

    @Override
    public CpParts create() {
   
        return new HpMouseFactory();
    }
}
package com.robin.factoryPattern.factoryMethod;

public class LenovoMouseFactory extends CpPartsFactory implements CpParts{
   
    @Override
    public void printName() {
   
        System.out.println("联想鼠标 created!");
    }

    @Override
    public CpParts create() {
   
        return new LenovoMouseFactory();
    }
}
package com.robin.factoryPattern.factoryMethod;

public class LogitechMouseFactory extends CpPartsFactory implements CpParts{
   
    @Override
    public void printName() {
   
        System.out.println("罗技鼠标 created!");
    }

    @Override
    public CpParts create() {
   
        return new LogitechMouseFactory();
    }
}

客户端测试类:

package com.robin.factoryPattern.factoryMethod;

public class Main {
   
    public static void main(String[] args) {
   
        //  工厂模式-工厂方法
        CpPartsFactory cpPartsFactory = new HpMouseFactory();
        cpPartsFactory.create().printName();// 惠普鼠标 created!
    }
}

优缺点

  • 优点

    • 工厂方法模式就很好的减轻了工厂类的负担,把某一类/某一种东西交由一个工厂生产;(对应简单工厂的缺点)。
    • 同时增加某一类 ”东西“ 并不需要修改工厂类,只需要添加生产这类 ”东西“ 的工厂即可,使得工厂类符合开闭原则
  • 缺点

    • 对于某些可以形成产品族(一组产品)的情况处理比较复杂。

抽象工厂

抽象工厂:提供一个接口,用于创建相关或依赖的家族,而不需要明确指定具体类。

例子:假设你做了一个大型游戏,里面人物角色的种族属性及世界观都是不同的。比如,普通人类,魔法师,外星物种…

在这里插入图片描述

载具抽象类:

package com.robin.factoryPattern.abstractFactory;

// 交通工具的抽象类
public abstract class Vehicle {
   

    abstract void go();
}

食物抽象类:

package com.robin.factoryPattern.abstractFactory;

// 食物抽象类  抽象类,一个具体的名词真实世界存在且是一个抽象的概念统称
public abstract class Food {
   
    abstract void printName();
}

武器抽象类:

package com.robin.factoryPattern.abstractFactory;

// 武器抽象类
public abstract class Weapon {
   
    abstract void wave();
}

抽象工厂类:

package com.robin.factoryPattern.abstractFactory;

// 抽象工厂类  一个【人】的拥有的...
public abstract class AbstractFactory {
   

    // 抽象方法
    abstract Food getFood();
    abstract Weapon getWeapon();
    abstract Vehicle getVehicle();
}

载具实现类:

package com.robin.factoryPattern.abstractFactory;

public class Car extends Vehicle{
   
    public void go(){
   
        System.out.println("[人类]-载具-汽车...");
    }
}
package com.robin.factoryPattern.abstractFactory;

public class Broom extends Vehicle{
   
    public void go(){
   
        System.out.println("[魔法师]-载具-魔法扫帚...");
    }
}

食物实现类:

package com.robin.factoryPattern.abstractFactory;

public class Bread extends Food{
   
    public void printName(){
   
        System.out.println("[人类]-食物-面包...");
    }
}
package com.robin.factoryPattern.abstractFactory;

public class MushRoom extends Food {
   
    public void printName(){
   
        System.out.println("[魔法师]食物-蘑菇");
    }
}

武器实现类:

package com.robin.factoryPattern.abstractFactory;

public class BroadSword extends Weapon{
   
    public void wave(){
   
        System.out.println("[人类]挥动大刀...");
    }
}
package com.robin.factoryPattern.abstractFactory;

public class MagicWand extends Weapon{
   
    public void wave(){
   
        System.out.println("[魔法师]挥舞着魔法棒....");
    }
}

不同人物种族的区分:

普通地球人:

package com.robin.factoryPattern.abstractFactory;

public class EarthManFactory extends AbstractFactory{
   
    @Override
    Food getFood() {
   
        return new Bread();
    }

    @Override
    Weapon getWeapon() {
   
        return new BroadSword();
    }

    @Override
    Vehicle getVehicle() {
   
        return new Car();
    }
}

魔法师:

package com.robin.factoryPattern.abstractFactory;

public class MagicManFactory extends AbstractFactory{
   
    @Override
    Food getFood() {
   
        return new MushRoom();
    }

    @Override
    Weapon getWeapon() {
   
        return new MagicWand();
    }

    @Override
    Vehicle getVehicle() {
   
        return new Broom();
    }
}

Main客户端测试类:

package com.robin.factoryPattern.abstractFactory;

// 充当客户端
public class Main {
   
    // 一个人类
    public static void main(String[] args) {
   
        // 通过AbstractFactory 抽象工厂类对不同世界|星球|种族 的人的描述
        AbstractFactory abstractFactory = new MagicManFactory();
        // 这样当我们有不同的设定的种族来时,从抽象工厂继承实现即可,
        // 然后客户端只需要修改 AbstractFactory abstractFactory = new xxxFactory();即可
        Vehicle vehicle = abstractFactory.getVehicle();
        vehicle.go();// [魔法师]-载具-魔法扫帚...
        Weapon weapon = abstractFactory.getWeapon();
        weapon.wave();// [魔法师]挥舞着魔法棒....
        Food food = abstractFactory.getFood();
        food.printName();// [魔法师]食物-蘑菇
    }
}

工厂模式区别

  • 简单工厂 : 使用一个工厂对象用来生产同一等级结构中的任意产品。(不支持拓展增加产品)
  • 工厂方法 : 使用多个工厂对象用来生产同一等级结构中对应的固定产品。(支持拓展增加产品)
  • 抽象工厂 : 使用多个工厂对象用来生产不同产品族的全部产品。(不支持拓展增加产品;支持增加产品族)

相关文章
|
27天前
|
设计模式 Java
【设计模式】工厂模式(定义 | 特点 | Demo入门讲解)
【设计模式】工厂模式(定义 | 特点 | Demo入门讲解)
41 2
|
9天前
|
设计模式 开发者 Python
Python编程中的设计模式:工厂方法模式###
本文深入浅出地探讨了Python编程中的一种重要设计模式——工厂方法模式。通过具体案例和代码示例,我们将了解工厂方法模式的定义、应用场景、实现步骤以及其优势与潜在缺点。无论你是Python新手还是有经验的开发者,都能从本文中获得关于如何在实际项目中有效应用工厂方法模式的启发。 ###
|
2月前
|
设计模式 Java
Java设计模式-工厂方法模式(4)
Java设计模式-工厂方法模式(4)
|
7天前
|
设计模式 安全 Java
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
|
2月前
|
设计模式 数据库连接 PHP
PHP中的设计模式:提升代码的可维护性与扩展性在软件开发过程中,设计模式是开发者们经常用到的工具之一。它们提供了经过验证的解决方案,可以帮助我们解决常见的软件设计问题。本文将介绍PHP中常用的设计模式,以及如何利用这些模式来提高代码的可维护性和扩展性。我们将从基础的设计模式入手,逐步深入到更复杂的应用场景。通过实际案例分析,读者可以更好地理解如何在PHP开发中应用这些设计模式,从而写出更加高效、灵活和易于维护的代码。
本文探讨了PHP中常用的设计模式及其在实际项目中的应用。内容涵盖设计模式的基本概念、分类和具体使用场景,重点介绍了单例模式、工厂模式和观察者模式等常见模式。通过具体的代码示例,展示了如何在PHP项目中有效利用设计模式来提升代码的可维护性和扩展性。文章还讨论了设计模式的选择原则和注意事项,帮助开发者在不同情境下做出最佳决策。
|
2天前
|
设计模式 安全 Java
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
10 1
|
25天前
|
设计模式 Java Kotlin
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
本教程详细讲解Kotlin语法,适合希望深入了解Kotlin的开发者。对于快速学习Kotlin语法,推荐查看“简洁”系列教程。本文重点介绍了构建者模式在Kotlin中的应用与改良,包括如何使用具名可选参数简化复杂对象的创建过程,以及如何在初始化代码块中对参数进行约束和校验。
19 3
|
2月前
|
设计模式 算法 安全
设计模式——模板模式
模板方法模式、钩子方法、Spring源码AbstractApplicationContext类用到的模板方法
设计模式——模板模式
|
2月前
|
设计模式 数据库连接 PHP
PHP中的设计模式:如何提高代码的可维护性与扩展性在软件开发领域,PHP 是一种广泛使用的服务器端脚本语言。随着项目规模的扩大和复杂性的增加,保持代码的可维护性和可扩展性变得越来越重要。本文将探讨 PHP 中的设计模式,并通过实例展示如何应用这些模式来提高代码质量。
设计模式是经过验证的解决软件设计问题的方法。它们不是具体的代码,而是一种编码和设计经验的总结。在PHP开发中,合理地使用设计模式可以显著提高代码的可维护性、复用性和扩展性。本文将介绍几种常见的设计模式,包括单例模式、工厂模式和观察者模式,并通过具体的例子展示如何在PHP项目中应用这些模式。
|
2月前
|
设计模式 Java Spring
spring源码设计模式分析-代理设计模式(二)
spring源码设计模式分析-代理设计模式(二)

热门文章

最新文章

  • 1
    《手把手教你》系列基础篇(九十四)-java+ selenium自动化测试-框架设计基础-POM设计模式实现-下篇(详解教程)
    44
  • 2
    C++一分钟之-C++中的设计模式:单例模式
    51
  • 3
    《手把手教你》系列基础篇(九十三)-java+ selenium自动化测试-框架设计基础-POM设计模式实现-上篇(详解教程)
    36
  • 4
    《手把手教你》系列基础篇(九十二)-java+ selenium自动化测试-框架设计基础-POM设计模式简介(详解教程)
    59
  • 5
    Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
    54
  • 6
    Java面试题:设计模式在并发编程中的创新应用,Java内存管理与多线程工具类的综合应用,Java并发工具包与并发框架的创新应用
    39
  • 7
    Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
    49
  • 8
    Java面试题:请列举三种常用的设计模式,并分别给出在Java中的应用场景?请分析Java内存管理中的主要问题,并提出相应的优化策略?请简述Java多线程编程中的常见问题,并给出解决方案
    102
  • 9
    Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
    74
  • 10
    Go语言设计模式:使用Option模式简化类的初始化
    71