Java设计模式——工厂模式

这篇具有很好参考价值的文章主要介绍了Java设计模式——工厂模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

设计模式系列文章

目录

设计模式系列文章

前言

一、简单工厂模式

二、工厂方法模式

三、抽象工厂模式

总结


前言

最近在学习一些Java设计模式的概念,设计模式诞生的目的,我认为是可以使得写出的代码具有更好的逻辑性,减少了大量冗余代码来进行重复而繁琐的操作,也更好的提升了复用性。所以学习并且能够使用合理的设计模式可以让我们的代码更加美观,优雅,结构更加清晰。

本次内容对Java中的工厂模式进行讲解,工厂模式又可以分为三种

                              ” 简单工厂,工厂方法, 抽象工厂 ”


一、简单工厂模式

工厂模式,主要用于创建对象时的一系列操作。

在我们平时创建对象的时候,一般使用New关键字来进行创建。

ClassA a = new ClassA();
ClassB b = new ClassB();

 我们使用New关键字创建对象,会根据括号内的参数在构造函数里对实例化对象进行初始化。

然而,我们创建一个对象的时候,可能需要对他进行一些初始化操作,例如查询数据库,对属性赋值等等。如果我们把这些操作也全部写到构造函数中。那构造函数就变得很长很长,可读性大大降低。

针对这种情况,我们可以引入 ” 工厂 “ 的概念,我们不通过New关键字去创建对象了,我们直接去创建一个工厂,让工厂去帮我们创建对象。

例如,我们创建了一个专门生产手机的工厂,这个工厂可以生产梨子手机,菠萝手机。

那么首先我们要创建梨子手机和菠萝手机这两个类,这里我实现了一个Phone接口,表明梨子手机和菠萝手机都是一个 ” Phone “类型的类,然后我们在创建的时候返回Phone类型的就可以了。

public interface Phone {
    void show();
}

public class LiPhone implements Phone {
    @Override
    public void show() {
        System.out.println("我是梨子手机");
    }
}

public class BoPhone implements Phone {
    @Override
    public void show(){
        System.out.println("我是菠萝手机");
    }

}

 然后我们再创建一个手机工厂,来生产手机。

这里应该很通俗易懂,我们再创建手机的时候,只需要给定规定好的number,工厂就知道该生产什么手机了,然后也可以按照我们的意愿去进行初始化。

public class PhoneFactory{

    public Phone createPhone(Integer number) {
        Phone phone = null;
        if(number == 1){
            phone = new LiPhone();
            // .....
            // 梨子手机的初始化代码
        }else if(number == 2){
            phone =  new BoPhone();
            // .....
            // 菠萝的初始化代码
        }
        return phone;
    }
}

然而这么做其实又会衍生出一个问题,那就是当我们有很多牌子手机的时候,比如我们还有锤子手机,番茄手机,土豆手机。那我们每多一个手机,就要去修改一次手机工厂的 if else 判断,这违背了设计模式的一个原则 “ 对修改关闭,对拓展开启 ”

(注:所谓面向对象的开放-封闭原则,就是在程序中对“扩展”开放,对“修改”封闭。如果每次业务改动都要增加新的if-else,就涉及对旧有代码的修改,不但容易出错,可读性也不好。)

那么怎么解决呢,我们可以使用下面提到的工厂方法模式。

二、工厂方法模式

前面我们提到,为了解决简单工厂模式中通过工厂创建对象 if esle 语句过多的问题可以使用工厂方法模式。而工厂方法模式的主要原理就是,我们把每一个要创建的产品对象独立分配一个工厂,提取一个工厂接口出来,独立分配的工厂作为工厂接口的实现类,这样我们在创建工厂——再通过工厂创建对象的过程中,工厂就是唯一确定了的,所以创建的对象也是唯一确定的,不需要再使用过多的判断语句了。

所以我们对之前的工厂类进行修改先.

现在我们提取出了一个工厂接口,接口中有生产手机的方法,然后我们为梨子手机和菠萝手机都创建一个工厂类去实现接口,在实现类的 createPhone 方法中创建手机,这样如果我们以后有了其他手机,只需要再增加手机的工厂类去实现接口就可以了。

public interface PhoneFactory {
    Phone createPhone();
}

public class LiFactory implements PhoneFactory{

    @Override
    public Phone createPhone() {
        Phone phone =  new LiPhone();
        // .....
        // 初始化代码
        return phone;
    }
}

public class BoFactory implements PhoneFactory{

    @Override
    public Phone createPhone() {
        Phone phone =  new BoPhone();
        // .....
        //  初始化代码
        return phone;
    }
}

测试方法

public class Test {

    public static void main(String[] args) {
        PhoneFactory factoryA = new LiFactory();
        PhoneFactory factoryB = new BoFactory();
        Phone phoneA = factoryA.createPhone();
        Phone phoneB = factoryB.createPhone();
        phoneA.show();
        phoneB.show();
    }
}

 输出:

我是梨子手机

我是菠萝手机

那么, 其实我们可以显而易见的发现,工厂方法模式虽然可以确保我们每一个手机对应一个工厂,而且需要创建手机的时候只需要通过对应工厂创建就可以了,但是这样随着我们的产品越来越多,工厂的实现类也越来越多,看的人头都晕了。

Java设计模式——工厂模式

那么,我们可以使用 “ 抽象工厂 ”模式来解决这个问题。比如我们的梨子手机和菠萝手机分别来自梨子厂和菠萝厂。那梨子厂和菠萝厂它们也有远大的理想!!他们不想只做手机! 他们要搞吧来福,搞把AK,做大做强!

梨子厂要做手机和电脑,菠萝见状,心想那我指定也得卷起来啊,于是菠萝老板下令,我们也要做手机和电脑!

三、抽象工厂模式

从上面的情景我们可以分析得到,梨子厂和菠萝厂都不甘现状,他们不禁想做手机,还想做电脑。

那我们需要去创建一个手机厂的同时再去创建一个电脑厂吗??

那当然不需要了,我们可以创建一个工厂接口,这个工厂既可以做手机,又可以做电脑

我们再创建实现类工厂,梨子厂和菠萝厂。因为梨子厂和菠萝厂都实现了工厂接口,所以他们都有创建手机和电脑的流水线(方法)

那就简单了,我们在各自的流水线中创建自己的产品不就行了嘛

直接上代码!!

哦不 先上个图 画的丑陋,帅哥美女们将就看看

Java设计模式——工厂模式

上代码!!!

首先安排两个产品的接口,手机接口和电脑接口,以及他们的实现类。

public interface Phone {
    void showPhone();
}

public class LiPhone implements Phone {
    @Override
    public void showPhone(){
        System.out.println("我是梨子手机");
    }
}

public class BoPhone implements Phone {
    @Override
    public void showPhone(){
        System.out.println("我是菠萝手机");
    }
}

public interface Computer {
    void showComputer();
}

public class LiComputer implements Computer {
    @Override
    public void showComputer() {
        System.out.println("我是梨子电脑");
    }
}

public class BoComputer implements Computer {
    @Override
    public void showComputer() {
        System.out.println("我是菠萝电脑");
    }
}

然后再安排一下我们的重头戏,抽象工厂。

public interface IFactory {
    //创建口罩
    Phone createPhone();
    //创建防护服
    Computer createComputer();
}

public class LiFactory implements IFactory {
    @Override
    public Phone createPhone() {
        Phone phone =  new LiPhone();
        // .....
        //  初始化代码
        return phone;
    }

    @Override
    public Computer createComputer() {
        Computer computer =  new LiComputer();
        // .....
        // 初始化代码
        return computer;
    }
}

public class BoFactory implements IFactory {
    @Override
    public Phone createPhone() {
        Phone phone =  new BoPhone();
        // .....
        //  初始化代码
        return phone;
    }

    @Override
    public Computer createComputer() {
        Computer computer =  new BoComputer();
        // .....
        // 初始化代码
        return computer;
    }
}

 最后测试一下来看看

public class Test {

    public static void main(String[] args) {
        IFactory factoryA = new LiFactory();
        IFactory factoryB = new BoFactory();
        //创建低端口罩
        Phone phoneA = factoryA.createPhone();
        //创建高端口罩
        Phone phoneB = factoryB.createPhone();
        //创建低端防护服
        Computer computerA = factoryA.createComputer();
        //创建高端防护服
        Computer computerB = factoryB.createSuit();

        phoneA.showPhone();
        phoneB.showPhone();
        computerA.showComputer();
        computerB.showComputer();
    }
}

 输出:

我是梨子手机

我是菠萝手机

我是梨子电脑

我是菠萝电脑

大功告成~ ✌✌ 


总结

现在越来越多Java开发方面的工作在招聘的要求上都会要求应聘者要熟知常见的设计模式,以及在面试的过程中也经常会问道设计模式相关的知识,所以设计模式的学习是非常重要的,而且学习了还要会融会贯通,在写代码的时候,遇到有重复的代码就可以思考一下是否可以将重复的代码抽取出来进行封装或者其他操作。文章来源地址https://www.toymoban.com/news/detail-411848.html

到了这里,关于Java设计模式——工厂模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java设计模式-抽象工厂模式

    设计模式是软件设计中的一种常见方法,通过定义一系列通用的解决方案,来解决常见的软件设计问题。其中,抽象工厂模式是一种非常常见的设计模式,它可以帮助我们创建一组相关的对象,而不需要指定具体的实现方式。 抽象工厂模式是一种创建型设计模式,它提供了一

    2024年02月01日
    浏览(44)
  • java设计模式【抽象工厂模式】

    抽象工厂模式 是对简单工厂模式的一个变种,它允许通过一个统一的接口来创建不同的产品实例,而无需指定具体的子类。在这个模式中,我们只关心产品的抽象接口,而将具体的产品实现留给子类去实现。这样,我们可以通过创建不同的工厂对象来创建不同的产品实例,而

    2024年02月05日
    浏览(48)
  • java设计模式-工厂方法模式

    定义一个创建产品对象的工厂接口,将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程; 在系统增加新的产品时只需要添加

    2024年02月04日
    浏览(46)
  • Java设计模式 (二) 工厂模式

    什么是工厂模式? 工厂模式是一种创建型设计模式,它提供了一种统一的方式来创建对象,隐藏了对象的创建细节,使客户端代码与具体类的实例化过程解耦。工厂模式可以帮助您在不暴露对象创建细节的情况下实例化对象,从而提高代码的灵活性和可维护性。 工厂模式通常

    2024年02月12日
    浏览(36)
  • Java设计模式---单例 工厂 代理模式

    单例模式是设计模式中的一种,属于创建型模式。在软件工程中,单例模式确保一个类只有一个实例,并提供一个全局访问点。这种模式常用于那些需要频繁实例化然后引用,且创建新实例的开销较大的类,例如数据库连接池、缓存管理等。 意图 :保证一个类仅有一个实例

    2024年01月24日
    浏览(52)
  • 【java设计模式】创建型模式介绍(工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式)

    简介 本文介绍Java设计模式中创建型模式的五种 一、工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工

    2024年02月16日
    浏览(47)
  • Java工厂设计模式

    工厂设计模式是一种创建型设计模式,它允许你创建对象,但不暴露其创建逻辑。该模式定义了一个工厂类,该类负责创建对象。这样,客户端代码只需知道如何与工厂交互,而不必知道对象的实际创建方式。 下面是工厂设计模式的通用结构:

    2024年02月07日
    浏览(34)
  • Java与设计模式(1):简单工厂模式

    简单工厂模式(Simple Factory Pattern)是一种创建型设计模式,它提供了一种创建对象的方式,将对象的创建逻辑封装在一个工厂类中,而不是直接在客户端代码中进行实例化。 在简单工厂模式中,有三个主要角色: 工厂类(Factory Class):负责创建具体对象的工厂类。它通常包

    2024年02月11日
    浏览(50)
  • Java特性之设计模式【抽象工厂模式】

    概述 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式 在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。

    2024年02月10日
    浏览(38)
  • Java与设计模式(2):工厂方法模式

    工厂方法模式是一种创建型设计模式,它提供了一种将对象的创建委托给子类的方式。在工厂方法模式中,我们定义一个抽象的工厂类,该类负责定义创建对象的接口,但具体的对象创建由子类来实现。这样可以将对象的创建和使用解耦,使得系统更加灵活和可扩展。 工厂方

    2024年02月11日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包