软件工程 3:模块化设计

内核 专栏收录该内容
12 篇文章 0 订阅

 


软件工程 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 );

// &是传引用,(&arr)[len]是传数组的引用,可以检查数组是否溢出,只接收 len 个元素的数组。
// 如果传进来的数组,这个数组的元素个数不等于len(10),编译就不过。从侧面避免数组溢出,但引用是C++支持的,C并不支持这种写法。

 


错误处理:每个函数都有错误处理

确定好了函数的原型之后,紧接着在完成这个函数的功能一开始的地方,就需要严格判断函数输入参数的合法性(防黑客)。

  • 函数参数中的指针是否为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;
}

我有许多这样,用于错误处理的宏,十分方便。

我还为这些错误处理宏,加上了颜色,输出错误信息时很美观哒。

这套错误处理宏真的好玩,像苏州面一样,要是每天都能接触到,实在是太开心啦。

这套宏,也分享给远方的你。

错误处理模块:自动化错误处理、实现异常机制

#include<stdio.h>
#include<errno.h>	/* 调用 errno 	  */
#include<string.h>  /* 调用 strerror() */
#define clean_errno() (errno == 0 ? "None" : strerror(errno))
// 看懂这句代码,需要了解 errno、strerror() 
// errno 是一个数字,errno = 1 是操作不允许,errno = 2 是没有这样的文件或目录,在 errno.h 文件里一共定义了 124 个常见错误 [1, 124]
// errno 本身只是一个数字,如果想知道这串数字的含义是什么,可以通过 strerror() 函数,比如 errno = 2,strerror(errno) 会返回 【Error: No such file or directory】

#define log_err(M, ...) fprintf(stderr,\
        "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__,\
        clean_errno(), ##__VA_ARGS__)
// log_err相当于一个调试器,当程序出现错误时,输出 那个文件名(__FILE__)、错误的行数(__LINE__)、错误的原因(strerror(errno)),以及提示信息(这个是我们调用的时候写的)
        
#define check(A, M, ...) if(!(A)) {\
    log_err(M, ##__VA_ARGS__); errno=0; goto error; }
// check(同assert),断言check括号里的内容为真,否则打印错误信息并跳转到 error 处清理
   
#define check_mem(A) check((A), "内存不足。")
// check_mem() 可以用于检测内存,如果 A == false,就输出【内存不足】,并进行一次跳转

int main( )
{
   FILE *fp = fopen("file.abc","r");		// 打开一个压根不存在的文件
   if( fp == NULL ) 						// 因为文件不存在,所以打不开,指针为空
     check(fp, "提示信息:fp == NULL呀~" );
     // 使用我们的错误处理宏 check(), 语法类似 assert()
     
   int *a = (int *)malloc(19979797797984);	// 申请一个编译器给不了的空间
   if( a == NULL ) 							// 因为内存不够,所以没申请到,指针为空
     check_mem(a);							// 和 check() 一样,只不过不需要给提示信息了
     
error:									    // 错误处理标签, do something,如
   	if( fp != NULL )
   		free(fp), fp = NULL;
   		
   	if( a != NULL )							
   		free(a), a = NULL; 
   		
	// 特别说明:在我们的程序里,某个函数往往申请了不止一个空间
	// 如果有一个空间申请失败,我们就 return -1 的话,那前面申请的空间就还没释放
	// 所以,释放空间最好使用 goto 统一处理
    return -1;  // 如果写 return 占位,那函数就结束了
    
    // 特别补充:这种统一错误标签(只有一个error标签)其实不灵活。
    // 因为错误处理也可以检测异常,如果某个地方有问题,那程序跳过这个地方即可,接着运行下面的代码,比如上面的代码,就因为打不开文件,所以程序越过申请空间这步,直接返回了。
    // 使用多个错误处理标签就可以实现异常
    
    /* 异常应该写成这样
     * if( fp == NULL ) 
     *     goto err_1;	
     * 					
     * err_1:
     *     do something.
     * 
     * // fp有问题,没关系,接着运行
     * 
     * if( a == NULL ) 		
     *     goto err_2;
	 *
	 * err_2:
	 * 	  do something
	 * 
	 * P.S. 如果代码出错了,可能是 goto err_i语句 和 err_i 的标签 之间有【定义变量】。如 int a = 9, 这是不可以的,但声明可 int a
     */
     
	fclose(fp);    fp = NULL;
	free(a);       a = NULL;
	return 0;
}

check 宏类似 assert,都是断言为真,只不过功能更加丰富,为出错处理而设计的。

goto 只能实现函数内部的跳转,不能实现跨函数跳转。

在一些错误处理中,在一个深度嵌套的函数调用中发生了错误,需要放弃当前任务,从多层函数调用中返回,并且在较高层级的函数中继续执行(或许是在 main() 函数中)。

要做到这一点,可以让每个函数都返回一个状态值,由函数的调用者检查并做相应处理,不过一层层的检查比较麻烦,setjmp 宏和 longjmp 函数 可以实现【非本地局部跳转】,也就是跨函数跳转

无论使用什么样的错误处理方式,都不要忘记发现程序中错误的最好方法其实是执行程序,对代码进行逐条跟踪,这样可以【观察数据在函数中的流动】,同时【检查出类似于上溢和下溢错误】、【数据转换错误】、【NULL 指针错误】、【错误的内存单元】、【用 = 代替 ==】、【运算优先级错误】、【逻辑运算】等错误。

 


模块的编译和链接

/* 当前源文件: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 的属性、功能;
  • 子类具有自己的属性和功能,即子类可以扩展父类没有的属性和功能;
  • 子类还可以以自己的方式实现父类的功能(方法重写);

继承的优点:

  • 继承使得所有子类公共部分都放在了父类(代码复用),另外,继承可使得修改或者扩展继承而来的实现都较为容易。

继承的缺点:

  • 父类变,子类不得不变;
  • 因为父类和子类有很大联系,也增加了耦合性。

对象之间有继承关系的时候,用继承。

 


多态:指向父类的指针或引用,可以调用子类对象

  • 如果您没有学过设计模式,我写了对于您的理解也是片面的;
  • 如果您学了设计模式,那就不用看我写的了。

所以,所以,我们跳过吧!!!

  • 4
    点赞
  • 0
    评论
  • 9
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 像素格子 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值