函数式编程思想：耦合和组合，第1部分

最新推荐文章于 2021-06-20 17:07:26 发布
最新推荐文章于 2021-06-20 17:07:26 发布
阅读量672 收藏
点赞数
文章标签： 函数式编程 面向对象编程

面向对象编程通过封装变动部分把代码变成易懂的，函数式编程则是通过最小化变动部分来把代码变成易懂的。

——Michael Feathers，Working with Legacy Code一书的作者

清单1.命令式的数字分类器

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import static java.lang.Math.sqrt;

public class ClassifierAlpha {
    private int number;

    public ClassifierAlpha(int number) {
        this.number = number;
    }

    public boolean isFactor(int potential_factor) {
        return number % potential_factor == 0;
    }

    public Set factors() {
        HashSet factors = new HashSet();
        for (int i = 1; i <= sqrt(number); i++)
            if (isFactor(i)) {
                factors.add(i);
                factors.add(number / i);

            }
        return factors;
    }

    static public int sum(Set factors) {
        Iterator it = factors.iterator();
        int sum = 0;
        while (it.hasNext())
            sum += (Integer) it.next();
        return sum;
    }

    public boolean isPerfect() {
        return sum(factors()) - number == number;
    }

    public boolean isAbundant() {
        return sum(factors()) - number > number;
    }

    public boolean isDeficient() {
        return sum(factors()) - number < number;
    }

}

清单2. 素数测试，以命令方式来编写

import java.util.HashSet;
import java.util.Set;

import static java.lang.Math.sqrt;

public class PrimeAlpha {
    private int number;

    public PrimeAlpha(int number) {
        this.number = number;
    }

    public boolean isPrime() {
        Set primeSet = new HashSet() {{
            add(1); add(number);}};
        return number > 1 &&
                factors().equals(primeSet);
    }

    public boolean isFactor(int potential_factor) {
        return number % potential_factor == 0;
    }

    public Set factors() {
        HashSet factors = new HashSet();
        for (int i = 1; i <= sqrt(number); i++)
            if (isFactor(i)) {
                factors.add(i);
                factors.add(number / i);
            }
        return factors;
    }
}

在 清单 2 中有几点需要注意。第一个是在 isPrime() 方法中加入了有点奇怪的初始化代码。这是一个关于实例初始值设定项 的示例。了解更多关于实例初始化的信息（函数式编程所附带的一种 Java 技术），请参阅 “演化架构和紧急设计: 利用可重用代码，第 2 部分”。

清单 2 中另要注意的是 isFactor() 和 factors() 方法。注意，它们与 ClassifierAlpha 类（在 清单 1）中的对应方法相同。这是单独实施两个解决方案并意识到您实际上有两个相同的功能所产生的自然结果。

清单 3. 常用的重构分解代码

import java.util.Set;
import static java.lang.Math.sqrt;
import java.util.HashSet;

public class FactorsBeta {
    protected int number;

    public FactorsBeta(int number) {
        this.number = number;
    }

    public boolean isFactor(int potential_factor) {
        return number % potential_factor == 0;
    }

    public Set<Integer> getFactors() {
        HashSet<Integer> factors = new HashSet<Integer>();
        for (int i = 1; i <= sqrt(number); i++)
            if (isFactor(i)) {
                factors.add(i);
                factors.add(number / i);
            }
        return factors;
    }
}

清单4 重构和简化数字分类器

import java.util.Iterator;
import java.util.Set;

public class ClassifierBeta extends FactorsBeta {

    public ClassifierBeta(int number) {
        super(number);
    }

    public int sum() {
        Iterator it = getFactors().iterator();
        int sum = 0;
        while (it.hasNext())
            sum += (Integer) it.next();
        return sum;
    }

    public boolean isPerfect() {
        return sum() - number == number;
    }

    public boolean isAbundant() {
        return sum() - number > number;
    }

    public boolean isDeficient() {
        return sum() - number < number;
    }

}

清单 5. 重构和简化的质数检验器

import java.util.HashSet;
import java.util.Set;

public class PrimeBeta extends FactorsBeta {
    public PrimeBeta(int number) {
        super(number);
    }

    public boolean isPrime() {
        Set<Integer> primeSet = new HashSet<Integer>() {{
            add(1); add(number);}};
        return getFactors().equals(primeSet);
    }
}

通过组合实现代码重用

在本系列的 第 2 部分中，我介绍了 Java 函数版的数字分类器，如清单 6 所示：

清单 6. 更加函数化版本的数字分类器

public class FClassifier {

    static public boolean isFactor(int number, int potential_factor) {
        return number % potential_factor == 0;
    }

    static public Set<Integer> factors(int number) {
        HashSet<Integer> factors = new HashSet<Integer>();
        for (int i = 1; i <= sqrt(number); i++)
            if (isFactor(number, i)) {
                factors.add(i);
                factors.add(number / i);
            }
        return factors;
    }

    public static int sumOfFactors(int number) {
        Iterator<Integer> it = factors(number).iterator();
        int sum = 0;
        while (it.hasNext())
            sum += it.next();
        return sum;
    }

    public static boolean isPerfect(int number) {
        return sumOfFactors(number) - number == number;
    }

    public static boolean isAbundant(int number) {
        return sumOfFactors(number) - number > number;
    }

    public static boolean isDeficient(int number) {
        return sumOfFactors(number) - number < number;
    }
}

我还有一个函数版的质数检验器（采用纯函数，无共享状态），其中的 isPrime() 方法如清单 7 所示。代码的其余部分与 清单 6 中同名方法相同。

清单 7. 函数版的质数检验器

public static boolean isPrime(int number) {
    Set<Integer> factors = factors(number);
    return number > 1 &&
            factors.size() == 2 &&
            factors.contains(1) &&
            factors.contains(number);
}

正如我在命令式版本中所做的一样，我将重复的代码提取到其 Factors 类中，并且为便于阅读，将 factors 方法的名称改为 of ，如清单 8 所示：

清单 8. 函数化重构的 Factors 类

import java.util.HashSet;
import java.util.Set;
import static java.lang.Math.sqrt;

public class Factors {
    static public boolean isFactor(int number, int potential_factor) {
        return number % potential_factor == 0;
    }

    static public Set<Integer> of(int number) {
        HashSet<Integer> factors = new HashSet<Integer>();
        for (int i = 1; i <= sqrt(number); i++)
            if (isFactor(number, i)) {
                factors.add(i);
                factors.add(number / i);
            }
        return factors;
    }
}

因为函数版中的所有状态都被作为参数传递，提取时并没有出现共享状态。一旦提取了该类之后，我就能通过同时重构函数分类器和质数检验器来使用它。 清单 9 中显示了重构的数字分类器。

因为函数版中的所有状态都被作为参数传递，提取时并没有出现共享状态。一旦提取了该类之后，我就能通过同时重构函数分类器和质数检验器来使用它。 清单 9 中显示了重构的数字分类器。

清单 9. 重构的数字分类器

public class FClassifier {

    public static int sumOfFactors(int number) {
        Iterator<Integer> it = Factors.of(number).iterator();
        int sum = 0;
        while (it.hasNext())
            sum += it.next();
        return sum;
    }

    public static boolean isPerfect(int number) {
        return sumOfFactors(number) - number == number;
    }

    public static boolean isAbundant(int number) {
        return sumOfFactors(number) - number > number;
    }

    public static boolean isDeficient(int number) {
        return sumOfFactors(number) - number < number;
    }
}

清单 10 显示了重构的质数检验器：

import java.util.Set;

public class FPrime {

    public static boolean isPrime(int number) {
        Set<Integer> factors = Factors.of(number);
        return number > 1 &&
                factors.size() == 2 &&
                factors.contains(1) &&
                factors.contains(number);
    }
}

注意：我并没有使用任何特殊的库或语言来使第二个版本更加函数化。相反，我是通过使用组合 而非耦合来实现代码重用。清单 9 和 清单 10 都使用了 Factors 类，但是对于它的使用是完全包含在单独的方法中的。

耦合与组合的区别非常细微但是又很重要。举一个简单的例子，您可以看到呈现代码结构的框架。然而，当您重构大型的代码库后，到处都会出现耦合的地方，因为那是面向对象语言中的其中 一种重用机制。对于丰富的耦合结构的理解困难阻碍了面向对象语言中的重用，限制了定义明确的技术域（如对象关系映射和小部件库）的有效重用。在编写不太明显的结构化 Java 代码时（比如您在业务应用程序中所编写的代码），我们无法做到同一级的重用。

结束语

像更加函数式的程序员一样思考指的是换个方式来考虑编码的各个方面。代码重用是一个显著的开发目标，而命令式抽象倾向于用不同于函数式程序员解决问题的方法来解决问题。本文对两种代码重用进行了比较：通过继承实现的耦合和通过参数实现的组合。下一篇文件将继续讨论这一重要的内容。

xxfigo
关注
Python函数详解：函数定义、调用，lambda函数，高阶函数map,filter,reduce，函数式编程，模块化设计、代码复用、函数递归、enumerate()
weixin_47008635的博客
02-12 1109
一、函数 函数是一段具有特定功能的、可重用的语句组，通过函数名来表示和调用。 函数是一段代码的抽象和封装 函数是一段具有特定功能的、可重用的语句组 函数是一种功能的抽象，表达特定功能 两个作用：降低编程难度和代码复用 降低编程难度：利用函数可以将一个复杂的大问题分解成一系列简单的小问题，分而治之，为每个小问题编写程序，通过函数封装，当各个小问题都解决了，大问题也就迎刃而解。 代码复用：函数可以在一个程序中的多个位置使用，也可以用于多个程序，当需要修改代码时，只需要在函数中修改一次，所有调用位置的功能都更新
面向过程编程（pop），面向对象编程（oop），函数式编程（fp）
热门推荐
大海
08-26 1万+
1、概念 面向过程编程（procedure oriented Programming）（POP） 面向对象编程（object oriented programming）(OOP) 函数式编程（functional programming)(FP) 2、解释 面向过程编程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 面向对象编程是...
函数式编程思想：耦合和组合，第2部分
SE7EN的技术历程
10-26 468
习惯于使用面向对象构建块（继承、多态等）的编程者可能会对这一方法的缺点及其他的可选做法视而不见，函数式编程使用不同的构建块来实现重用，其基于的是更一般化的概念，比如说列表转换和可移植代码。函数式编程思想的这一部分内容比较了作为重用机制的经由继承的耦合和组合，指出了命令式编程和函数式编程之间的主要区别之一。 在上一部分内容中，我说明了代码重用的不同做法。在面向对象的版本中，我提取出了重复的
函数式思维: 耦合和组合，第 2 部分
肖飞figo的云计算专栏
05-09 1083
习惯使用面向对象（继承、多态性等）构建块的程序员会越发对于该构建块的缺点和替代方案视而不见。函数式编程是使用不同的构建块来实现重用，它基于更通用的概念，比如列表转换和可移植代码。函数式思维 系列文章的这一期将比较通过继承进行的耦合与作为重用机制的组合，并指出命令式编程和函数式编程的主要区别。
类的耦合：组合、继承、友元
weixin_41565755的博客
08-28 706
一、组合（可直接访问：公有成员） 1、 组合的概念 组合，在一个类中内嵌另一个类的对象作为数据成员，该内嵌对象称为对象成员，也称为子对象。 class A { //.. .. }; class B { //.. .. }; class C { //.. .. }; class D { A a; B b; ...
Python中的函数式编程与数据科学的结合：使用函数式编程解决实际问题
函数式编程是一种编程范式，它将计算视为数学函数的求值，避免使用改变状态和可变数据的命令式语句。在函数式编程中，函数是一等公民，可以作为参数传递给其他函数，也可以作为返回值返回。它强调函数的纯粹性和不可...
模块化编程与函数式编程的结合：如何更好地组织代码
# 1. 理解模块化编程 ## 1.1 什么是模块化编程？ 模块化编程是一种基于将代码分成独立的模块的方法。每个模块包含特定功能的代码，可以独立开发、测试和维护。通过模块化编程，开发人员可以更好地组织代码，提高...
语言开发中的函数式编程范式解析
函数式编程的核心思想是将程序看作一系列函数的组合，而不是一组可变的状态和可变的操作。函数式编程强调纯函数、高阶函数和不可变性。 - 纯函数：纯函数是指具有相同输入必定产生相同输出，并且没有副作用的函数。...
函数式编程思想：耦合和组合
weixin_34247155的博客
11-01 106
2019独角兽企业重金招聘Python工程师标准>>> ...
依赖、关联、聚合和组合之间区别
木易
06-06 9424
依赖、关联、聚合和组合之间区别 耦合度依次增强：依赖、关联、聚合和组合 1、依赖(Dependency)关系 依赖关系表示一个类依赖于另一个类的定义。依赖关系中，可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是B类的变化会影响到A。一般而言，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。 class Car {.........
耦合和内聚-图解7种耦合关系
学习永无止境
06-20 7508
图解7种耦合关系颜海镜知名技术博主,《React状态管理与同构实战》作者 yanhaijing.com237 人赞同了该文章之前组内同学问我耦合的关系，我没给对方讲清楚，今天借这个机会来深入讲讲模块之间的耦合关系这个事情。本文将用图文详细讲解七种耦合的不同之处。高内聚与低耦合高内聚与低耦合是每个软件开发者追求的目标，那么内聚和耦合分别是什么意思呢？内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块
设计模式中类的关系
yuanlanjun
01-09 377
在java以及其他的面向对象设计模式中，类与类之间主要有6种关系，他们分别是：依赖、关联、聚合、组合、继承、实现。他们的耦合度依次增强。 1.依赖（Dependence） 依赖关系的定义为：对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。定义比较晦涩难懂，但在java中的表现还是比较直观的：类A当中使用了类B，...
编程思想-解耦
xiaoqiaozhongcai的专栏
09-02 4329
解耦方法有但不限有如下几种：（百度解释前三种） （a）采用现有设计模式实现解耦，如事件驱动模式、观察者模式、责任链模式等都可以达到解耦的目的； （b）采用面向接口的方式编程，而不是用直接的类型引用，除非在最小内聚单元内部。但使用该方法解耦需要注意不要滥用接口。 （c）高内聚，往往会带来一定程度的低耦合度。高内聚决定了内部自行依赖，对外只提供必须的接口或消息对象，那么由此即可达
java - 设计模式学习总结
wcqwcq123的博客
12-12 895
熟练掌握各种设计模式，并能在实际编程开发中灵活运用它们，不仅能使代码更规范，重用性更高，同时也能保证代码的可靠性，提高开发效率。这段时间又系统看了设计模式的相关内容，整理学习总结如下，文中内容如有表达有误的地方，还请指出，共同交流学习。 一、概述 二、7个设计原则 三、创建型模式(5种) 四、结构型模式(7种) 五、行为型模式(11种) 六、总结 一、概述 面向对象编程有七大原则，即经常提到
Java编程思想之高内聚低耦合
smilehappiness的博客
05-18 4254
文章目录1 前言2 低耦合耦合性定义耦合性分类3 高内聚高内聚定义耦合性分类4 示例5 总结 1 前言 编程的时候，经常要使得系统高内聚、低耦合，那么，我们口中的这些概念到底是什么？什么是高内聚低耦合呢？ 2 低耦合 耦合性定义 起因 模块独立性指每个模块只完成系统要求的独立子功能，并且与其他模块的联系最少且接口简单，所以就有了两个定性的度量标准，即耦合性和内聚性。 定义： 耦合性也称块间联系，指软件系统结构中各模块间相互联系紧密程度的一种度量。使用白话来说，就是代码（程序）和代码（程序）之间的关联
浅谈聚合与耦合
weixin_34186950的博客
03-10 358
2019独角兽企业重金招聘Python工程师标准>>> ...
梦幻西游手游多开与自动化的详细教程
最新发布
09-23
本文档提供了梦幻西游手游多开以及自动化的完整指南。主要内容涵盖了所需软硬件的具体配置流程，其中包括Windows 10操作系统的要求限制、使用沙盒工具进行多账号安全操作的方法以及借助Python和AirTest实现游戏脚本自动化的技巧。对于希望实现游戏账号多开并运用自动化来减轻任务负担的手游玩家而言，它给出了详细的解决方案，帮助玩家完成诸如批量任务操作、窗口管理和自动化脚本编写等功能。 适用人群：喜欢《梦幻西游》并有兴趣提升日常任务效率的玩家和初学者级别的Python爱好者。 使用场景及目标：用于解决《梦幻西游》多账号管理过程中所遇到的问题，提高任务的自动化程度以节省时间。 阅读建议：文档不仅限于代码展示，还涉及了很多配置和调试的操作指引。因此，读者应该按照文档内的步骤逐一操作实践才能真正掌握多开与自动化应用的技术要点。
函数式编程入门：JavaScript ES6中的声明式与抽象
书中深入探讨了JavaScript中的函数式编程思想，特别是声明式编程和抽象的概念。" 在编程世界中，"命令式"、"声明式"和"抽象"是三种不同的编程范式，它们各自有着独特的特点和应用场景。 1. **命令式编程**：这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值