如何通俗易懂地举例说明「面向对象」和「面向过程」有什么区别

从一场比赛说起
在一个软件村里
有一名资深「面向过程」程序员——老过
和一名「面向对象」信徒——阿对
同时受雇于一家挨踢店
有一天老板突发奇想
决定让这两名程序员进行一次比赛
获胜者将获得一个限量的
360 度全自动按摩椅
编程比赛开始了

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

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

老过看到新需求，微微一笑

class Bill{

    fun getPrice(): Double {
        val unit = getUnit()
        val number = getNumber()
        val price = unit * number
        if (todayIsLoversDay()) {
            return price * 0.77
        }
        return price
    }

    fun getUnit(): Double {
        ...
    }

    fun getNumber(): Int {
        ...
    }

    fun todayIsLoversDay(): Boolean {
        ...
    }
}

他决定让新的收银方式继承 Bill 类

先在 Bill 类中新增 discount 方法

并将其开放
普通的收费方式在 discount

​函数中直接返回价格

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

在 discount 函数中实现打 77折

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 {
        ...
    }

}

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

老过已经开始幻想自己将来

坐在按摩椅上的舒服日子

听到新需求

老过一阵头大

不由在群里吐槽

吐槽归吐槽

老过在 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)
    }
}

「面向对象」让阿对最喜欢的一点是

有一个好消息要告诉大家！当老板兴高采烈地说出这句话时老过和阿对都露出了心惊胆战的表情这句话往往意味着要更改需求

老过反抗道

但他并没有说出心里另一个小九九

实在不想再去给 Bill 类添加代码了

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

 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 {
        ...
    }
}

当老板看完老过和阿对的代码后

再次兴奋地提出新需求时

老过顿时晕了过去…

比赛真是太焦灼了

最后赢得奖励的是？

第三个参赛者

老板的傻儿子

他完全不会写程序

但他使用 Ctrl+C，Ctrl+V

拷贝了阿对的代码

转载于如何通俗易懂地举例说明「面向对象」和「面向过程」有什么区别