001 面向对象和面向过程的区别封装继承多态

冷不防 2023-01-14 07:00 91阅读 0赞

# 一、面向对象是什么 #

**面向对象** (Object Oriented,OO) 的思想对软件开发相当重要，它的概念和应用甚至已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD 技术、人工智能等领域。面向对象是一种 **对现实世界理解和抽象的方法**，是计算机编程技术发展到一定阶段后的产物。

**面向过程** (Procedure Oriented) 是一种 **以过程为中心** 的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是 **封装、继承、类**。

无论是在软件开发还是在实际工作中，深入地理解软件开发的思想都非常有必要。

# 二、从一场比赛说起 #

在一个软件村里  
有一名资深「面向过程」程序员——老过  
和一名「面向对象」信徒——阿对  
同时受雇于一家挨踢店

有一天老板突发奇想  
决定让这两名程序员进行一次比赛  
获胜者将获得一个限量的  
360 度全自动按摩椅编程  
比赛开始了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70]

不一会，他俩都写出了几乎相同的代码

class Bill{ 
    
    // 获取总价
    fun getPrice(): Double { 
    val unit = getUnit()
    val number = getNumber()
    val price = unit * number
    return price
        }
    
    // 获取单价
    fun getUnit(): Double { 
            ...
        }
    
    // 获取数量
    fun getNumber(): Int { 
            ...
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 1]  
老过看到新需求，微微一笑  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 2]  
他决定让新的收银方式继承 Bill 类  
先在 Bill 类中新增 discount 方法  
并将其开放open

open class Bill{ 
    
        fun getPrice(): Double { 
            val unit = getUnit()
            val number = getNumber()
            val price = unit * number
            return discount(price)
        }
    
        // 处理打折优惠
        open fun discount(price: Double): Double{ 
            return price
        }
    
        fun getUnit(): Double { 
            ...
        }
    
        fun getNumber(): Int { 
            ...
        }
    
    }

普通的收费方式在 discount

函数中直接返回价格

七夕节的收费方式则继承此类

在 discount 函数中实现打 77折

class LoversDayBill : Bill(){ 
        override fun discount(price: Double): Double { 
            return price * 0.77
        }
    }

当老过和阿对同时将程序交给老板时  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 3]  
老过已经开始幻想自己将来坐在按摩椅上的舒服日子  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 4]  
听到新需求老过一阵头大不由在群里吐槽  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 5]

吐槽归吐槽老过在 getPrice 函数中再次增加了条件判断

class Bill { 
    
        fun getPrice(): Double { 
            val unit = getUnit()
            val number = getNumber()
            val price = unit * number
            if (todayIsLoversDay()) { 
                return price * 0.77
            }
            if (todayIsMiddleAutumn() && price > 399) { 
                return price - 200
            }
            if (todayIsNationalDay() && price < 100) { 
                // 生成 0 ~ 9 随机数字，如果为 0 则免单。即：十分之一概率免单
                val free = Random().nextInt(10)
                if (free == 0) { 
                    return 0.0
                }
            }
            return price
        }
    
        fun getUnit(): Double { 
            ...
        }
    
        fun getNumber(): Int { 
            ...
        }
    
        fun todayIsLoversDay(): Boolean { 
            ...
        }
    
        fun todayIsMiddleAutumn(): Boolean { 
            ...
        }
        
        fun todayIsNationalDay(): Boolean { 
            ...
        }
    }

看着越来越复杂的  
Bill 类和 getPrice 方法  
老过眉头紧锁他深知事情远没有结束  
中秋和国庆一过  
他还需要到这个复杂的类中  
删掉打折的方法  
天知道老板还会再提  
什么天马行空的需求

无论是新增或删除代码，在这个过长的类里做修改都是件不太愉快的事。为了在一个很长的函数中找到需要修改的位置，「面向过程」使得老过不得不浏览大量与修改无关的代码，小心翼翼地修改后，又要反复确认不会影响到类的其他部分。

老过在心底里默默地祈祷这个类不再需要修改提交了自己的程序

阿对收到新需求时  
先是新增了中秋节支付类

class MiddleAutumePrice : Bill() { 
        override fun discount(price: Double): Double { 
            if (price > 399) { 
                return price - 200
            }
            return super.discount(price)
        }
    }

再增加了国庆节支付类：

class NationalDayBill : Bill() { 
        override fun discount(price: Double): Double { 
            if (price < 100) { 
                // 生成 0 ~ 9 随机数字，如果为 0 则免单。即：十分之一概率免单
                val free = Random().nextInt(10)
                if (free == 0) { 
                    return 0.0
                }
            }
            return super.discount(price)
        }
    }

「面向对象」让阿对最喜欢的一点是  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 6]

有一个好消息要告诉大家！  
当老板兴高采烈地说出这句话时  
老过和阿对都露出了心惊胆战的表情  
这句话往往意味着要更改需求  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 7]

老过反抗道  
但他并没有说出心里另一个小九九  
实在不想再去给 Bill 类添加代码了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 8]

这次修改老过花了较长的时间才完成

class Bill { 
        val gifts = listOf("flower", "chocolate", "9.9 discount")
    
        fun getPrice(): Double { 
            val unit = getUnit()
            val number = getNumber()
            val price = unit * number
            if (todayIsLoversDay() && isCouple()) { 
                if (price > 99) { 
                    val lucky = Random().nextInt(gifts.size)
                    println("Congratulations on getting ${gifts[lucky]}!")
                }
                return price * 0.77
            }
            if (todayIsMiddleAutumn() && price > 399) { 
                return price - 200
            }
            if (todayIsNationalDay() && price < 100) { 
                // 生成 0 ~ 9 随机数字，如果为 0 则免单。即：十分之一概率免单
                val free = Random().nextInt(10)
                if (free == 0) { 
                    return 0.0
                }
            }
            return price
        }
        
        fun getUnit(): Double { 
            ...
        }
    
        fun getNumber(): Int { 
            ...
        }
    
        fun todayIsLoversDay(): Boolean { 
            ...
        }
    
        private fun isCouple(): Boolean { 
            ...
        }
    
        fun todayIsMiddleAutumn(): Boolean { 
            ...
        }
    
        fun todayIsNationalDay(): Boolean { 
            ...
        }
    }

看着那个只属于七夕节的 gifts 变量  
老过像看着自己白衬衫上的油渍一样难受

以后每次收费时都会生成一个  
只有七夕节才会用到的变量  
都是因为老板的需求太奇葩  
才让这个程序看起来乱糟糟的  
由于这个类做了修改  
本来已经测试通过的代码又得重测一遍

阿对打开了 LoversDayBill 类  
将其修改如下

class LoversDayBill : Bill() { 
        
        val gifts = listOf("flower", "chocolate", "9.9 discount")
        
        override fun discount(price: Double): Double { 
            if (!isCouple()) return price
            if (price > 99) { 
                val lucky = Random().nextInt(gifts.size)
                println("Congratulations on getting ${gifts[lucky]}!")
            }
            return price * 0.77
        }
    
        fun isCouple(): Boolean { 
            ...
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 9]

当老板看完老过和阿对的代码后  
再次兴奋地提出新需求时  
老过顿时晕了过去…

比赛真是太焦灼了  
最后赢得奖励的是？

第三个参赛者老板的傻儿子  
他完全不会写程序  
但他使用 Ctrl+C，Ctrl+V  
拷贝了阿对的代码

# 三、面试常见考点 #

在面试中，面向对象的常见考察点是三个基本特征：封装、继承、多态。

## 封装 ##

封装也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

## 继承 ##

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来类的情况下对这些功能进行扩展。通过继承创建的新类称为「子类」或「派生类」，被继承的类称为「基类」、「父类」或「超类」。  
要实现继承，可以通过 继承和组合 来实现。

## 多态性 ##

多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单说就是一句话：允许将子类类型的指针赋值给父类类型的指针。  
实现多态，有两种方式，覆盖和重载。两者的区别在于：**覆盖在运行时决定，重载是在编译时决定。并且覆盖和重载的机制不同**。例如在 Java 中，重载方法的签名必须不同于原先方法的，但对于覆盖签名必须相同。

我对面向对象的理解：**面向对象的编程方式使得每一个类都只做一件事。面向过程会让一个类越来越全能，就像一个管家一样做了所有的事**。而面向对象像是雇佣了一群职员，每个人做一件小事，各司其职，最终合作共赢！

# 四、引申阅读 #

最后，我们谈谈面向对象有什么好处？

《大话设计模式》中大鸟给小菜讲的故事非常经典：

“话说三国时期，曹操带领百万大军攻打东吴，大军在长江赤壁驻扎，军船连成一片，眼看就要灭掉东吴，统一天下，曹操大悦，于是大宴众文武，在酒席间，曹操诗性大发，不觉吟道：‘喝酒唱歌，人生真爽……’众文武齐呼：‘丞相好诗！’于是一臣子速命印刷工匠刻版印刷，以便流传天下。”

“样张出来给曹操一看，曹操感觉不妥，说道：‘喝与唱，此话过俗，应改为‘对酒当歌’较好！’于是此臣就命工匠重新来过。工匠眼看连夜刻版之工，彻底白费，心中叫苦不迭。只得照办。”

“样张再次出来请曹操过目，曹操细细一品，觉得还是不好，说：‘人生真爽‘太过直接，应改问语才够意境，因此应改为‘对酒当歌，人生几何……’当臣子转告工匠之时，工匠晕倒……”

**大鸟**：“小菜你说，这里面问题出在哪里？”  
**小菜**：“是不是因为三国时期活字印刷还未发明，所以要改字的时候，就必须要整个刻板全部重新刻。”  
**大鸟**：“说得好！如果是有了活字印刷，则只需更改四个字就可，其余工作都未白做。岂不妙哉。  
一、要改，只需更改要改之字，此为可维护；  
二、这些字并非用完这次就无用，完全可以在后来的印刷中重复使用，此乃可复用；  
三、此诗若要加字，只需另刻字加入即可，这是可扩展；  
四、字的排列其实可能是竖排可能是横排，此时只需将活字移动就可做到满足排列需求，此是灵活性好。”

“而在活字印刷术出现之前，上面的四种特性都无法满足，要修改，必须重刻，要加字，必须重刻，要重新排列，必须重刻，印完这本书后，此版已无任何可再利用价值。”

**小菜**：“是的，小时候我一直奇怪，为何火药、指南针、造纸术都是从无到有，从未知到发现的伟大发明，而活字印刷仅仅是从刻版印刷到活字印刷的一次技术上的进步，为何不是评印刷术为四大发明之一呢？原来活字印刷是思想的成功，面向对象的胜利。”

\----------------------------以下是原答案-------------------------------

与面向对象相对应的，即存在于早期版本 C 语言中的面向过程。

面向过程开发的过程，有点类似于树状调用函数，树状的根节点主程序对函数进行层层调用。

比如，main 函数要进行排序，那就调用 sort，sort 再去调用对应的，然后排好序后要进行输出，再调用输出。所谓面向过程中的过程，指的就是排序，输出这一个个的对应的“行为”，即过程是你每次进行的操作。

## **面向过程的问题有：** ##

*  复用性不佳  
    按过程来的话，不同过程中相似的代码也不好进行复用，前半段的过程中用到的逻辑，在后半段再次使用的话需要再写一遍，如果是相同的逻辑，修改也会出现很多复杂问题。
 *  拓展性不易  
    举个例子，相同的逻辑，如果要有两份相似逻辑，那在面向过程中，就很多时候需要写两份。
 *  耦合度高  
    有一个比喻很合适，说面向过程是蛋炒饭，面向对象是盖浇饭，即，面向过程很难将内容剥离开，都混在了一起，要改一个东西，往往会改全文；而面向对象改的时候就改得比较少。但面向过程也有好处，迭代快速开发，在一些如 48 小时比赛写个程序的，快速迭代，按过程分割就比较适合面向过程。

## **面向对象，和面向过程的区别在于：** ##

面向对象是以元素，是以事物为主体。只要你能将一样东西抽象成一样物品，就可以作为你一段代码的载体。

比如，MVC，把一样东西的数据，页面，控制，各抽象成一个东西，分开耦合，不同的对象之间只提供对应的接口，联系也基于对应的接口。把每个对象封装成一个类，就是面向对象要做的事情。

首先复用性极佳，你如果要编写重复逻辑，直接使用同一个类就好了。

其次耦合性非常低，修改逻辑时候只需要修改对应的接口内的内容就好了。  
同时代码逻辑也更好理解，更好维护。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70]: /images/20221022/eed5655843524eba9220150843f242be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 1]: /images/20221022/d358faabfa7b46e8a421c09f14f54b1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 2]: /images/20221022/d6b9798f833c4d388e70326389e43953.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 3]: /images/20221022/52dff79956d342568158f976b57d14ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 4]: /images/20221022/b0269567f1b1447f90df04a43ed9034a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 5]: /images/20221022/05b239343e004511867b54ef84edcef5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 6]: /images/20221022/aa0eb2d8cf4443b3b2dbd08c14769099.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 7]: /images/20221022/8e08c63ea6df48f58e647798367d4467.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 8]: /images/20221022/c7db7603ded54571b85149e99ee28c48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 9]: /images/20221022/4e08da2e2f9545d8bb28b01d52917913.png