软件工程[第三课摘要]
软件工程 3
软件工程并不是一种科学,而且其重要性也与计算机本身并无关系。
软件工程革命是有关我们如何去思考的方式,以及我们如何去表达自己的思考的一个革命。
在第一课时,对比了【面向过程】、【面向对象】。
这一课,我们来说说他们的思想,具体的设计细节。
面向过程以【计算机】为核心,符合 CPU 顺序处理数据的流水线思路。
面向过程程序 = 算法 + 数据结构:
- 面向过程的程序是流水线的产品;
- 算法是流水线;
- 数据结构是原料;
面向对象以【人】为核心,不再注重机器,而侧重于人对现实世界的观察。
您可以往周围看看,看到的是什么?
可能是您的同事、桌子、墙、电脑、花盆;或者是电话、窗子、书本……这些都是【对象】,是吗~
除了观察目标聚焦于【对象】外,当我们观察人类世界各种事情的运作的时候,我们也不知不觉的聚焦于【对象】。
- 家庭:父亲、母亲、大哥、小哥等;
- 公司:董事长、经理、主管、员工等;
- 国家:…
人一般是按照面向对象的方式思考的,而且人类世界的运转方式通常也是按照面向对象的方式运作的。面向对象,是我们天然的视角。
面向对象程序 = 对象 + 交互:
- 对象:具体存在的事物;
- 交互:事物之间的链接;
在工业系统中,面向过程的流水线工艺以【效率】著称,一环套一环非常高效,可灵活性却不好。
一条流水线从建成开始,接下来几年甚至十几年生产的都是同一产品。
但对于软件系统来说,一款软件可能因为增加新功能、需求的变更,每年都要扩展多次…如果用流水线工艺,由于每次需求的变更,流程里的每一步骤、一环套一环,哪怕只是更改了某一环,整个流水线都得重新调整一下。
一想到是这样的情况,头就大了。这就是一个无底洞呀,小型项目还好,要是大项目,每更改一次,软件出现 bug 的概率就大几分。
所以,所以,就有了【面向对象】来解决这个问题,其实就是比较灵活(术语叫“可扩展性”)。
面向对象,适合用于经常变化的地方。
对于软件开发来说,可变的通常集中于客户需要,不变的是计算机系统的基础。
- 操作系统、数据库、各种协议,它们相对稳定,用【面向过程】更贴切;
- 企业应用、互联网、游戏,需求经常变更、功能不断扩展的,用【面向对象】才适合。
虽然可扩展性,只是其中之一。
但足够了,如同法师、射手主伤害,坦克主防御,辅助主增益一样,面向对象主敏捷。
了解面向对象的特点,是应用面向对象的关键。千万不要拿把锤子,看什么都是钉子。
面向过程、面向对象都有它们的局限性,也有在各自很优秀的指标。
面向过程:模块化设计
背景:鲁滨孙漂流记。
环境:无人小岛。
目标:做一碗杂酱面。
某天鲁滨孙心血来潮,想吃一碗杂酱面了。
于是,他花了2年时间做这碗杂酱面:
原来吃一碗杂酱面是这么幸福,回想我们想吃杂酱面,只需要在手机点几下就好啦。
为什么我们想吃一碗杂酱面,就这么容易呢?
因为平等,带来了合作,而整个社会的分工合作带来了群体演化速度加快。
面向过程之所以这么高效,就是因为【分而治之】的思想。
把一个项目,分成不同的模块,不同模块交给了不同的人;大家分工协作就能快速实现这碗杂酱面。
模块化编程的特点:
- 分工实现,适合多人协作;
- 便于维护、管理、移植;
对于黑客来说,懂模块化编程,对以后分析系统、底层项目是很有意义的,也是大型项目开发的基石。
模块设计原则:高内聚、低耦合
有一个梦想,定居:【苏州】。
因为我是一个面痴,每天早上能吃一碗汤面,我就很开心啦。
苏州的汤面最考究的是面汤(汤也炒鸡好喝),汤要清而不油,味要鲜而食后口不干。
我最喜欢的做法:汤是汤,面是面,先煮好面,而后把面在配好的清汤里过一下,端上来的时候也不烫。
正如上图的面,汤是汤、面是面、大排是大排(配料),这也是模块的高内聚、低耦合。
- 高内聚:汤是汤、面是面、大排是大排(配料),相互独立;
- 低耦合:面与汤之间关联很少,一眼就能清晰的看出面和汤来。
模块化编程的核心思想,即【分而治之】。
所以,模块之间一定要界限分明(内聚:模块各元素的关联程度),自己的功能自己实现,不麻烦其它模块。
那如何实现高内聚呢?
- 功能尽可能单一,一个函数只实现一个功能,函数的源代码行数一般不超过100行;
- 一个模块实现一个功能,尽可能使用本模块的函数,不要麻烦其它模块;
耦合:模块间的数据传递、控制高系、调用高系的关联。
耦合度越高,耦合性越强,模块独立性就越菜。
耦合方式分为(实际更多):
- 非直接耦合: 两个模块之间没直接联系
- 数据耦合: 通过参数来交换数据
- 标记耦合: 通过参数传递记录信息
- 控制耦合: 通过标志、开关、名字等,控制另一个模块
- 外部耦合: 所有模块访问同一个全局变量
耦合越低,维护就越方便。如果模块之间,我可以调用你,你也可以调用我…
整个程序的关系会较乱,修改、添加一个模块,牵一发动全身,所以你先得要理清这个关系,那是很头疼的。
避免高耦合,常用的设计方法:
- 少用全局变量,通过接口访问;
- 禁止相互调用,只能单向调用,上下级关系;
- 多用接口设计,接口是唯一的调用方式;如我们去餐厅,也只会和服务员(唯一接口)打交道,不会和厨房人员交流的。
高内聚导致低耦合,低耦合就意味着高内聚。
-
内聚:模块内各元素之间的关联交互
-
耦合:模块间的依赖关联、交互关系
函数设计:不知道如何下手怎么办
我们实现程序里的算法时,其实就是写一个或者若干个函数。
有时候,我也不知道该如何下手。
没关系,我可以分析一下问题:
- 应该传什么参数给函数(作为输入参数)
- 函数处理完后,应该把什么数据作为结果返回(作为输出参数)
返回类型 函数名(函数参数)
一步步走,对一道问题完全没想法时,多半是没有分析好,这时候反复要分析。
分析好以后,知道就知道该用什么知识对答,这时候考验的是编程能力了,分析考验的是算法能力,当写好了主函数模版,接下来就思考实现某个算法的原型是怎样的,反复练习让其成为一种习惯。
加油!
我觉得参数设计是在原型设计里最主要的,设计的好,程序简洁,递归可以避免因多层函数参数入栈而引起的爆栈。
如,二分查找的函数原型:
bool binary_search( ... );
返回是否找到,要么直接返回数的下标,要么就返回一个布尔值。
千万不要在这个子函数里面,输出:找到没找到;这样会提高模块化的耦合性,这样相当于告诉别人,我是新手中的新手。
设计参数:
#define T int
bool binary_search ( T arr[], T key, int len );
// arr[]:被查找的数组
// key: 查找的值
// len: 被查找数组的长度
参数虽然正确,不过也并不好。
因为查找是不需要修改目标数据(被查找的数组),没有保护数据,所以加上 const 关键字让数据不能被修改。
key和len,运行时,因为是传值,会创建(占空间)副本给形参,我们可以改成传引用减少不必要的空间。
但如何数据量巨大,采用引用会影响效率因为引用是间接寻址,传值是直接寻址所以速度比引用、指针快。
#define T int
bool binary_search ( const T arr[], const T& key, const int& len );
// 算法不需要修改数据时,都应设计为 不可修改类型,这样的设计原则其实非常敏捷
// 传引用避免形参拷贝
还可以简化接口,如把数组长度的参数去掉:
#define T int
const int len = 10;
bool binary_search ( const T (&arr)[len], const T& key );
// 是传引用,可以检查数组是否溢出。
// 如果传进来的数组,这个数组的元素个数不等于len(10),编译就不过。从侧面避免数组溢出。
错误处理:每个函数都有错误处理
确定好了函数的原型之后,紧接着在完成这个函数的功能一开始的地方,就需要严格判断函数输入参数的合法性(防黑客)。
- 函数参数中的指针是否为NULL;
if( ptr == NULL || *ptr == '\0‘ )
- 函数参数中缓存的长度是否在合理范围;
if( len <= 0 )
如果类型是浮点数,因为实数在计算和存储时会有误差,因此本来是零的值,由于误差的原因判断为非零。所以,判定方法要改。
// 采用绝对精度判断, 原理:判断ta的绝对精度是否小于一个很小的数,如 0.000 001
double eps = 1e-6
if ( fabs(a) <= eps ) // 等于0
if ( fabs(a) - fabs(b) <= eps ) // 俩个数相等
// 当变量 a、b 在 eps 精度附近时,判断失误。还有 相对精度 和 绝对精度+相对精度 的判断方法
- 甚至还要利用C++中的RTTI对参数的类型进行检查。
二分查找为例,判断边界。
#define T int
bool binary_search ( const T arr[], const T& key, const int& len )
{
if ( len <= 0 || arr == NULL || *arr == '\0' )
// 短路表达式优化,一真必真,避免不必要的判断, 所以把最高频的放在最左边,其余同理
return false
}
在参数的设计时,如果模版参数是通用类型时,要把所有类型情况都考虑进来。
避免程序在运⾏中出错,避免各种漏洞的产生。如:
-
曾经的SSL协议中的 心脏流血漏洞,就是因为服务端程序在处理时,没有验证来⾃客户端对应的缓存⻓度有效性,造成了该漏洞的产⽣。
-
被号称漏洞核弹的 微软CVE-2017-0290漏洞,也只因在扫描引擎MsMpEng的NScript模块中没有对输入的参数类型进⾏检查,默认当做字符串来处理造成的。
如果用户输入的参数在边界判断时,发生了异常或者错误,就必须要处理,否则程序就无法继续执行了。
出错处理的方式方式很多,也很灵活。只要不遗漏对错误的处理就行。
C++、Python 这些语言在解决出错的时候多通过异常处理,不过异常在C语言里有一些问题。
在C语言中,我们只有一个返回值,但异常是一个基于栈的返回系统,返回的东西是不确定的。很多编程语言直接把所有边量都放在了堆。
我最喜欢的出错处理方式就是 goto 了。想起来,就开心。优美,简洁,适合小白。
#include<stdio.h>
int fun(void)
{
if( finshied )
goto err_1; // 一定是往 return 方向跳
if( finshied )
goto err_2;
/* goto语句 和 err的标签 之间 不能有 定义变量的操作。如 int a = 9, 但声明可 int a */
return 1;
err_1:
do something; // 只能调到当前函数, err 一般在函数分界处
err_2:
do something;
}
还可以更美好,自制一个宏。
#define check(A, M, ...) if(!(A)) {\
log_err(M, ##__VA_ARGS__); errno=0; goto error; }
check宏的使用方式,和库函数assert()一样,都是断言(断言括号里的表达式为真,程序能正常运行)。
否则,【打印错误信息】并跳转到【错误标签】error处,清理。
#define T int
bool binary_search ( const T arr[], const T& key, const int& len )
{
check( len > 0, "参数len必须大于0");
// 断言,程序正常运行,那 len 就大于 0;
// 如果断言失败,就打印错误信息(参数len必须大于0);
// 而后跳转到 error 标签,清理。
error:
do something;
return false;
}
我有许多这样,用于错误处理的宏,十分方便。
我还为这些错误处理宏,加上了颜色,输出错误信息时很美观哒。
这套错误处理宏真的好玩,像苏州面一样,要是每天都能接触到,实在是太开心啦。
模块的编译和链接
/* 当前源文件:demo.c */
#include <stdio.h>
int main(){
printf("hello, world!");
}
上面程序的作用是打印 hello, world,在编译器里我们只要点【运行】就能看到结果。
但不同文件里的模块到底是怎么链接在一起的?
我们为什么可以在当前源文件 main() 里,直接调用 printf()。
这就得从源代码生成可执行文件的内部机理聊起啦。
从源代码生成可执行文件可以分为四个步骤:
预处理(Preprocessing):处理那些源文件和头文件中以#开头的命令,比如 #include、#define、#ifdef。
- 将所有的#define删除,并展开所有的宏定义。
- 处理所有条件编译命令,比如 #if、#ifdef、#elif、#else、#endif 等。
- 处理#include命令,将被包含文件的内容插入到该命令所在的位置,这与复制粘贴的效果一样。
- 删除所有的注释 //、/* … */。
- 添加行号和文件名标识,便于在调试和出错时给出具体的代码位置。
- 保留所有的#pragma命令,因为编译器需要使用它们。
预处理的结果是生成【.i文件】。
【.i文件】也是包含C语言代码的源文件,只不过所有的宏已经被展开,所有包含的文件已经被插入到当前文件中。
当你无法判断宏定义是否正确,或者文件包含是否有效时,可以查看【.i文件】来确定问题。
在 GCC 中,可以通过下面的命令生成.i文件:
gcc -E demo.c -o demo.i // -E表示只进行预编译。
编译(Compilation):将预处理完的文件进行词法分析、语法分析、语义分析以及优化后生成相应的【汇编代码文件】。
在 GCC 中,可以使用下面的命令生成.s文件:
gcc -S demo.i -o demo.s
汇编(Assembly):将汇编代码转换成可以执行的机器指令。
汇编的结果是产生【目标文件】,在 GCC 下的后缀为.o。
链接(Linking):目标文件已经是二进制文件,与可执行文件的组织形式类似,只是有些函数和全局变量的地址还未找到,程序不能执行。链接的作用就是找到这些目标地址,将所有的目标文件组织成一个可以执行的二进制文件。
面向对象:万事万物皆对象
我是从 C 语言入门的,感觉很 nice !!
而后开始接触数据结构,用面向过程的方式实现数据结构时,发现每种数据结构和它的自带算法天然是一个整体,用面向对象的方式描述是不是更适合呢?
我觉得是,所以我去学了一下 C++。
初次接触C++,我编程还没习惯从面向过程转为面向对象,感觉很别扭…
还有概念也太抽象了,只是用一些词来解释另一些词。
语言本身就有二义性,不类比、举例的话,很难理解到这一视角下的世界观。
类:一组相似事物的统称
分门别类,也是科学研究的基本方法和途径。
人类在认识客观世界的过程就是采用了分类的方法。
世界分为:
- 生物和非生物;
- 生物分为 动物 植物 微生物等等;
- 或者是 界 门 纲 目 科 属 种。
面向对象的类,与古语上的【物以类聚,人以群分】的类、分门别类的类是相同的。
因此,当我们在定义什么才是“类”的时候,其实完全不需要和面向对象扯上关系。
类是【一组】【相似】事物的【统称】。
- 一组:在于多个,因为单个事物无法此外类;
- 相似:人类是一个类,但每个人都是不一样的、独一无二的;
- 统称:能够概括多个事物,每个人都可以统称为“人”、“男人或者女人”,但名字不是一个统称。
对象:一个真实存在的类
在程序里,类只是一个模板(Template),编译后不占用内存空间,所以在定义类时不能对成员变量进行初始化,因为没有地方存储数据。
只有在创建对象以后才会给成员变量分配内存,这个时候就可以赋值了。
这是因为类是抽象出来的,不是真实存在的。
比如,我们说人、人类、男人、女人这些类时,它们只是一个抽象的概念,其实有没有这个人呢,是没有的。
但要说,牛顿、爱因斯坦,这些对象是真的存在的。
对象时有特点、有行为的,也就产生了数据,由此只有程序实例化对象时,编译器才会储存数据。
类是一个抽象的概念,而对象是真实存在的(类)。
接口:一组相关的交互功能点定义的集合
接口的定义比较难,名词分析:
接口:一组【相关】的【交互】功能点【定义】的【集合】;
以餐馆的列有各种菜肴的清单为例:
- 相关:接口中包含的功能点是相关的;
各种菜肴都是为了满足口腹之欲(相关),是吧。
- 交互:用于不同对象的交互;
客人点菜,其实是和大厨之间的交互;一个人是自嗨,不是交互。
- 定义:没有实现;
清单里的每道菜是都可以做出来的,但客人不点,大厨是不会做的。
- 集合:多个;
清单里可不止一个菜。
简单来说,接口就像一份列有各种菜肴的清单。
为什么要有接口呢?
有的时候呀,我们并不知道客人想吃什么,但我们又想客人照我们的要求来活动。
这就是接口的用处所在,当您不知道一个对象所属的具体“类”,只知道这些对象都具备某种功能。
接口:一组相关的交互功能点定义的集合。
抽象类:基于类而抽象出来的,用于继承,不能被实例化为具体的对象
从设计的角度来看,抽象类是更高层次的抽象。
如果说普通类是从现实对象抽象出来的,那么抽象类就是基于类而抽象出来的。
有了类,为什么还要抽象类?
为什么设计一种只能继承,不能实例化的类?
答案就在于:在某些场景下普通类不够用。
例如,“苹果”、“橘子”、“香蕉”都是一个类,它们都是“水果”,这里的“水果”就是一个【抽象类】。
您可以说喜欢吃“水果”,但您真正吃“水果”的时候,要么是“苹果”,要么是“橘子”,要么是“香蕉”……但您绝不可能真正吃到一个叫作“水果”的东西。
从实现的角度来看,抽象类与普通类不同的地方在于:
- 抽象类有的存在抽象方法(方法只有声明,没有定义),子类必须自己定义这些抽象方法,而不能像普通的方法一样,通过继承就可以获得父类的方法。
从这一点来看,抽象类和接口有点类似。
那抽象类和接口有什么区别?
为什么有了接口,还要有抽象类?
因为,
- 抽象类本质上还是类,强调一组事物的相似性,包括属性和方法的相似性;
- 而接口只强调方法的相似性,并且仅仅体现在方法声明上的相似性,而没有方法定义上的相似性。
例如。假设我们设计一个游戏,其中使用“苹果”、“橘子”、“香蕉”来做“补血”, “苹果”、“橘子”、“香蕉”都有“颜色”和“重量”这样的属性,但每种水果的补血方式是不一样的。
在这种情况下,使用抽象类可以很好地表达,我们设计一个抽象类“水果”,将“颜色”、“重量”作为“水果”的属性,“获取颜色”、“获取重量”、“减少重量”等方法作为“水果”的方法,将“补血”作为“水果”的抽象方法。这样设计能够大大减少“苹果”、“橘子”、“香蕉”几个普通类的实现工作量,它们只需要实现“补血”方法,其他的属性和方法都只需继承“水果”类即可(代码复用)。
而如果采用接口的方式实现,则“苹果”、“橘子”、“香蕉”每个类都需要自己增加“颜色”、“重量”属性,增加“获取颜色”、“获取重量”、“减少重量”、“补血”等方法,工作量和代码量大大增加。
如上分析,抽象类是一个介于类和接口之间的概念,同时具备类和接口的部分特性。
抽象类:基于类而抽象出来的,用于继承,不能被实例化为具体的对象
封装:保护隐私、隔离关注点,减低复杂度
封装的好处举个例子就明白了。
我们的房子是类的实例(对象),室内的装饰与摆设只能被它的主人欣赏、使用,如果没有四面围墙的遮挡,室内所有人的活动就暴露无疑。
所以,房子这个对象必须加上封装(四面围墙),嘿嘿,不然晚上活动会影响别人的…
public: 不封装,公开的
protected: 对外不公开,但对家人(子类)公开
private:私有的,每个人都有自己的小秘密是不能告诉任何人的
需要保密的时候,用封装。
继承:生物的遗传
继承本身很好理解,和我们日常生活中的“继承”概念基本一样:子承父业!所以,我们可以看到在面向对象的编程语言里面,有了“父类”、“子类”的概念。
但是我个人认为“继承”这个说法并不确切,一般我们理解“继承”都是继承产业、继承财产。
但在面向对象的领域中,并不是“子类”继承了“父类”的产业,而是继承了“父类”的特点,具体来说,就是继承了“属性“和”方法“。
所以,我认为“继承”更加贴切的说法是类似生物学上的“遗传”,按照中国话的说法就是“龙生龙,凤生凤,老鼠生来会打洞”,面向对象的继承意味“子类”遗传了 “父类”的某些属性和方法。
但就像生物学上的进化论一样,有遗传就有变异,正因为有了变异,才会有新的物种产生;有了变异,面向对象才出现了子类。
学好继承记住三句话(如果子类继承于父类):
- 子类拥有父类非 private 的属性、功能;
- 子类具有自己的属性和功能,即子类可以扩展父类没有的属性和功能;
- 子类还可以以自己的方式实现父类的功能(方法重写);
继承的优点:
- 继承使得所有子类公共部分都放在了父类(代码复用),另外,继承可使得修改或者扩展继承而来的实现都较为容易。
继承的缺点:
- 父类变,子类不得不变;
- 因为父类和子类有很大联系,也增加了耦合性。
对象之间有继承关系的时候,用继承。
多态:指向父类的指针或引用,可以调用子类对象
- 如果您没有学过设计模式,我写了对于您的理解也是片面的;
- 如果您学了设计模式,那就不用看我写的了。
所以,所以,我们跳过吧!!!