Java创建型设计模式之工厂方法模式深入详解

目录
  • 简单工厂模式
    • 定义产品对象
    • 创建工厂类
    • 工厂使用反射
  • 工厂方法模式
    • 概述
    • 应用场景
    • 优缺点
    • 主要角色
  • 工厂方法模式的基本使用
    • 创建抽象产品
    • 创建具体产品
    • 创建抽象工厂
    • 创建具体工厂
    • 客户端执行

简单工厂模式

简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创建出哪一种产品类的实例,但是它不属于设计模式。

简单工厂适用于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,对于如何创建对象的逻辑不需要关心。

定义产品对象

public interface ICar {
    void create();
}
public class BMCar implements ICar{
    @Override
    public void create(){
        System.out.println("制造BM车");
    }
}
public class ADCar implements ICar {
    @Override
    public void create() {
        System.out.println("制造AD车");
    }
}

创建工厂类

创建一个实现工厂类,所有的对象交由该工厂类创建

public class CarFactory {
    public ICar create(ICar car) {
        if (car instanceof BMCar) {
            return new BMCar();
        } else if (car instanceof ADCar) {
            return new ADCar();
        } else {
            return null;
        }
    }
}
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        ICar bm = carFactory.create(new BMCar());
        bm.create();
        ICar ad = carFactory.create(new ADCar());
        ad.create();
    }

工厂使用反射

上述方式随着业务扩展,就需要修改createAnimal方法中的逻辑代码,不符合开闭原则。

可使用反射技术,即使业务变化扩展,也不需要修改AnimalFactory中的逻辑代码

public class CarFactory {
    public ICar create(String className) {
        try {
            if (!(null == className || "".equals(className))) {
                return (ICar) Class.forName(className).newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        ICar bm = carFactory.create("cn.ybzy.demo.BMCar");
        bm.create();
    }

上述方式的缺点是方法参数是字符串,有着不可控的风险。可进一步优化,使用强制类型限制,控制参数传递

public class CarFactory {
    public ICar create(Class<? extends ICar> clazz) {
        try {
            if (!(null == clazz)) {
                return clazz.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        ICar bm = carFactory.create(BMCar.class);
        bm.create();
    }

工厂方法模式

概述

工厂方法模式是简单工厂模式的衍生,解决了许多简单工厂模式的问题。工厂方法模式属于创建型模式。

工厂模式(Factory Pattern)是Java中最常用的设计模式之一。它提供了一种创建对象的最佳方式。

它定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

在工厂方法模式中只需要关心所需产品对应的工厂,无须关心创建细节,而且加入新的产品符合开闭原则。

应用场景

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

2.客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。

3.一个类通过其子类来指定创建哪个对象。

优缺点

优点:

1.一个调用者想创建一个对象,只需要知道其名称就可以

2.扩展性高,如果想增加一个产品,只需要扩展一个工厂类

3.屏蔽产品的具体实现,调用者只关心产品的接口

缺点:

1.每增加一个产品时,都需要增加一个具体类和对象实现工厂,使系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。

主要角色

1.抽象产品角色(Product)

工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。

2.具体产品角色(Concrete Product)

这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建,它们之间往往一一对应。

3.抽象工厂角色(Creator)

是工厂方法模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

4.具体工厂角色(Concrete Creator)

这是实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建产品对象。

工厂方法模式的基本使用

创建抽象产品

创建抽象产品角色,工厂类所创建的产品的父类,封装了产品对象的公共方法

public abstract class AbstractCar {
    public abstract void run();
}

创建具体产品

public class Car extends AbstractCar {
    public void run() {
        System.out.println("Car run");
    }
}

创建抽象工厂

public abstract class ICarFactory {
    public abstract <T> T create(Class<T> clazz);
}

创建具体工厂

创建多个实现抽象工厂接口的具体工厂类。负责实现创建产品的内部逻辑,该工厂类可以被直接调用,创建所需的具体对象。

public class CarFactory extends ICarFactory {
    @Override
    public <T> T create(Class<T> clazz) {
        Car car;
        try {
            car = (Car) Class.forName(clazz.getName()).getConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return (T) car;
    }
}

客户端执行

通过一个工厂类,对实现了同一接口的一些类进行实例的创建

    public static void main(String[] args) {
        ICarFactory factory = new CarFactory();
        Car car = factory.create(Car.class);
        car.run();
    }

Car run

到此这篇关于Java创建型设计模式之工厂方法模式深入详解的文章就介绍到这了,更多相关Java工厂方法模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java使用设计模式中的工厂方法模式实例解析

    工厂方法模式的定义 工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中.核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品. 它包含了如下角色: 抽象产品(Product) 具体产品(ConcreteProduct) 抽象工厂(Factory) 具体工厂(ConcreteFactory) 模式的UML

  • java设计模式学习之工厂方法模式

    工厂方法模式(Factory Method):定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 工厂方法模式结构图: 项目需求,创建一个雷锋工厂,大学生可以去帮助别人,志愿者也可以帮助别人做事情. 1:创建一个雷锋类,具有帮助别人扫地,洗衣,买米的功能. package FactoryMethodModel; public class LeiFeng { public void Sweep(){ System.out.println("扫地"

  • Java设计模式编程中的工厂方法模式和抽象工厂模式

    工厂方法模式 动机 创建一个对象往往需要复杂的过程,所以不适合包含在一个复合工厂中,当有新的产品时,需要修改这个复合的工厂,不利于扩展. 而且,有些对象的创建可以需要用到复合工厂访问不到的信息,所以,定义一个工厂接口,通过实现这个接口来决定实例化那个产品,这就是工厂方法模式,让类的实例化推迟到子类中进行. 目的 1. 定义一个接口,让子类决定实例化哪个产品. 2. 通过通用接口创建对象. 实现 1. 产品接口和具体产品很好理解. 2. 工厂类提供一个工厂方法,返回一个产品对象.但是这个工厂方法是

  • java设计模式之工厂方法模式

    概要 设计模式是一门艺术,如果真正了解这门艺术,你会发现,世界都将变得更加优美. 定义 定义一个用于创建对象的接口,让其子类去决定实例化那个类 使用场景 任何使用复杂对象的地方,都可以使用工厂模式 UML 1.抽象工厂 抽象工厂:我们都知道,工厂,一般只有一个作用,那就生产,比如,吉利汽车厂,那就制造吉利汽车,iphone手机制造厂就造iphone等等 所以可以用一个简单的方法概括,就是create(); 2.具体汽车制造厂 具体汽车制造厂:实现了抽象工厂,具有实际的制造汽车的流程和方法等 3.

  • Java设计模式编程之工厂方法模式的使用

    定义:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类. 类型:创建类模式 类图: 工厂方法模式代码 interface IProduct { public void productMethod(); } class Product implements IProduct { public void productMethod() { System.out.println("产品"); } } interface IFactory { publ

  • java编程创建型设计模式工厂方法模式示例详解

    目录 1.什么是工厂方法模式? 2.案例实现 3.JDK中的工厂方法模式 1.什么是工厂方法模式? 工厂方法模式设计方案:  将披萨项目的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现. 工厂方法模式:  定义了一个创建对象的抽象方法,由子类决定要实例化的类.工厂方法模式将对象的实例化推迟到子类. 何时使用?  不同条件下创建不用实例时.方法是让子类实现工厂接口. 2.案例实现 假如说,我们现在有这样一个需求:客户在点披萨时,可以点不同口味的披萨,比如北京的奶酪pizza.北京的胡椒p

  • Java设计模式之工厂方法模式实例简析

    本文实例讲述了Java设计模式之工厂方法模式.分享给大家供大家参考,具体如下: 工厂方法模式使用的频率非常高,在我们日常的开发中总能遇见到它的身影.其定义为:Define an interface for creating an object, but let subclass decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.(定义一个用于创建对象的接口

  • Java设计模式之工厂方法模式详解

    目录 1.工厂方法是什么 2.如何实现 3.代码实现 4.工厂方法模式的优点 5.拓展 1.工厂方法是什么 众所周知,工厂是生产产品的,并且产品供消费者使用.消费者不必关心产品的生产过程,只需要关心用哪种产品就行. 在Java世界中,工厂方法模式和现实功能类似.工厂即一个工厂类,提供获得对象(产品)的方法(工厂方法).其他类(消费者)需要用到某个对象时,只需调用工厂方法就行,不必new这个对象. 2.如何实现 1)创建产品的抽象类或接口---抽象产品 2)创建具体产品的类---具体产品 3)创建

  • Java创建型设计模式之工厂方法模式深入详解

    目录 简单工厂模式 定义产品对象 创建工厂类 工厂使用反射 工厂方法模式 概述 应用场景 优缺点 主要角色 工厂方法模式的基本使用 创建抽象产品 创建具体产品 创建抽象工厂 创建具体工厂 客户端执行 简单工厂模式 简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创建出哪一种产品类的实例,但是它不属于设计模式. 简单工厂适用于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,对于如何创建对象的逻辑不需要关心. 定义产品对象 public interf

  • Android编程设计模式之工厂方法模式实例详解

    本文实例讲述了Android编程设计模式之工厂方法模式.分享给大家供大家参考,具体如下: 一.介绍 工厂方法模式(Factory Pattern),是创建型设计模式之一.工厂方法模式是一种结构简单的模式,其在我们平时开发中应用很广泛,也许你并不知道,但是你已经使用了无数次该模式了,如Android中的Activity里的各个生命周期方法,以onCreate方法为例,它就可以看作是一个工厂方法,我们在其中可以构造我们的View并通过setContentView返回给framework处理等,相关内

  • Python设计模式之工厂方法模式实例详解

    本文实例讲述了Python设计模式之工厂方法模式.分享给大家供大家参考,具体如下: 工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延时到其子类. #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' """ 大话设计模式 设计模式--工厂方法模式 工厂方法模式(Factory Method Pattern):

  • Java结构型设计模式之享元模式示例详解

    目录 享元模式 概述 目的 应用场景 优缺点 主要角色 享元模式结构 内部状态和外部状态 享元模式的基本使用 创建抽象享元角色 创建具体享元角色 创建享元工厂 客户端调用 总结 享元模式实现数据库连接池 创建数据库连接池 使用数据库连接池 享元模式 概述 享元模式(Flyweight Pattern)又称为轻量级模式,是对象池的一种实现.属于结构型模式. 类似于线程池,线程池可以避免不停的创建和销毁多个对象,消耗性能.享元模式提供了减少对象数量从而改善应用所需的对象结构的方式. 享元模式尝试重用

  • Java创建型设计模式之抽象工厂模式(Abstract Factory)

    目录 抽象工厂模式 概述 产品等级结构与产品族 优缺点 主要角色 抽象工厂模式的基本使用 创建抽象产品 创建具体产品 创建抽象工厂 创建具体工厂 客户端执行 抽象工厂模式 概述 抽象工厂模式(Abastract Factory Pattern)属于创建型模式,它提供了一种创建对象的最佳方式. 它提供一个创建一系列相关或相互依赖对象的接口,无须显式指定他们具体的类.每个生成的工厂都能按照工厂模式提供对象. 抽象工厂模式是围绕一个超级工厂创建其他工厂,该超级工厂又称为其他工厂的工厂. 产品等级结构与

  • Java十分钟精通进阶工厂方法模式

    目录 一.什么是工厂方法模式? 二.工厂方法模式的优缺点 三.模式的结构与实现 四.工厂方法模式代码实现 五.总结 一.什么是工厂方法模式? 工厂方法模式:也叫虚拟构造器模式或者多态工厂模式,它属于类创建型模式. 在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类. 我们知道在现在的真实工厂内分工越来越细,越来越专业化..各种产品有专门的工厂生产,

  • C++设计模式之工厂方法模式的实现及优缺点

    工厂方法模式是在简单工厂模式的缺点上进行优化的,我们都知道,在简单工厂模式中,要去增加或者减少一个产品的类型,都需要修改工厂中的if-else判断.这样子显然不符合我们代码开发中的开闭原则,拓展起来也是非常麻烦的 工厂方法模式 = 简单工厂模式 + "开闭原则" 定义思想:工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的就是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类 优点: 不需要记住具体的类名,

随机推荐