编程之禅 浅谈封装

作为一个整天与代码打交道的人，你真的会coding吗？ 今天依旧来反思一下自身。

---

伊始

大一的时候，刚接触到了C语言，一门神奇的语言。老师就教导我们要多敲例子，照着书本敲就可以了。可能当时并没有真正的理解老师的意思，所以就只是照着课本敲，（尴尬的是，我真的就只是照着课本上一字一字的敲，-_-!!!）也因此养成了一种换习惯。那就是在接触到一个新语言的时候，总是情不自禁的缺乏思考的描摹。所以脱离了课本的我并不能完成什么比较独立的项目。

学而不思则罔，死而不学则殆！

当我认识到这一点的时候，已经过去很久了。我尝试着撇弃记忆中的代码段。而是尽量采取思考为主的方式来学习。效果虽然不是很明显，但也算是略见成效了。
但是这种方式并不是应用任何的场景。如下：

刚开始学习一门语言的时候,我们对语法什么的并不是特别的熟悉,所以我们需要练习很多的例子,来快速的熟悉它.但在这个过程中很容易跑偏.因为我往往会忽略掉我仅仅是为了熟悉语法而来练习例子的.这就非常的尴尬了.但是呢,思考式的学习,并不是非常的适合这个场合因为我们对基本的语法都不熟悉的话,怎么在此基础上创造自己的呢?

渐晰

上面讨论了一下模仿和思考的矛盾和重要的地方,我没有彻底的说明白到底哪个更重要.因为每个人的程度都不一样,所以根本没有一个标准来衡量.我能做的就是一个建议吧.这同时也是说给我自己听的.

当认识到了不能再单纯的抄例子的时候,不妨独立的思考解决方案吧.

浅谈面向对象和面向过程

作为一个fresh coder.我个人的技术很有限.所以下面说的话可能不恰当,也可能是错误的.大家看看就可以了.倘若某段话和你有共鸣,不妨笑笑嘛.

仅仅是解释概念性的封装，很枯燥也没有任何的乐趣。所以下面我就拿几个小例子来聊聊。

比如说我们要完成一个实现加法运算。

C 语言实现

#include<stdlib.h>
#include<stdio.h>

int add(int a , int b)
{
    return a+b;
}
int main()
{
    int i = 1;
    int j = 2;
    int result = 0;
    result = add(i,j);
    printf("%d\n",result);
    return 0;
}

C语言是典型的面向过程的程式性语言。程序的基本单元是函数，一个函数完成一个或多个功能（为了更好的维护，建议一个函数完成一个功能）。我们也可以通过组合多个函数来完成一个比较巨大的功能。

Java实现

package com.mark.utils

class AlgorithmUtils {

    /**
    * 静态的实现加法运算
    */
    public static int add(int a,int b){
        return a+b;
    }
}

package com.mark.test

class TestAlgorithmUtils {

    /**
    * 测试加法运算的入口方法
    */
    public static void main(String []args){
        int i = 1;
        int j = 2;
        int result = AlgorithmUtils.add(i,j);
        Sysem.out.println("计算结果是："+result);
    }
}

相信大家可以明显的发现，使用Java完成相同的功能。功能和使用是分离的。

面向对象的思维方式是高度抽象以及模块化设计的典范

在不同的“端”，我们专注于不同的点。程式耦合性低，易于维护。但是缺点也是很明显的，对于小程序而言，这样的设计无疑是很庞大而且成本很高。

Python实现

Python有自己独特的地方，支持面向对象的编程，也支持面向过程的编程。所以为了更好的演示，这里写两个，对比一下吧。

面向过程

def add(a,b):
    return a+b;

if __name__=="__main__":
    i = 1
    j = 2
    result = add(i,j)
    print u'计算结果为%s'%str(result)

面向对象方式

# 这里把类写死了，平时的开发可以不是这样的
class AlgorithmUtils:
    __init__(self,a,b):
        self.a = a
        self.b = b

    def add(self,a,b):
        return self.a+self.b

if __name__ =="__main__":
    util = AlgorithmUtils()
    i =1
    j =2
    result = util.add(i,j)
    print u'计算结果是：%s'%str(result)

对于使用面向对象还是使用面向过程的争论已经很多年了，谁也没有彻底的征服谁。毕竟各有各的优点，各有各的缺点。

我觉得，使用哪种方式并不应该是我们讨论的重点，怎么因地适宜的选取合适的方式，才是关键。

封装的艺术

不管是面向对象编程，还是面向过程编程，自己写方法（函数）是不可避免的。但是我们不妨反思一下，“你真的会封装吗”。

还记得有一位大师说过：

优雅的实现，有时候仅仅是需要一个函数。

我觉的这句话真的是很严谨的一句话，这里表面上是说优雅的实现，但是侧重点仍然在“有时候”这三个字。点透了面向对象和面向过程 应该怎样配合。

面向过程的函数封装

面向过程，程序的基本单位就是一个个的函数了。我们大部分人设计一个函数的时候，并没有真正的考虑清楚函数需要什么。却是仅仅完成了当前的预期的功能。虽然这样确实可以满足需求。但是这样的程序并不是很健壮。

设计原则：

先思考完成功能会用到什么参数，变量。哪些临时变量是不可缺少的，哪些参数是不必须的。设计的规范决定着函数的“命运”。

面向对象的封装

面向对象的编程方式很大程度上取决于对象的属性。也就是说实体本身具备的属性。
比如说“开车”这个词，“开”是车的动作还是人的动作？
“转弯”是人的动作还是车的动作？

设计原则：

先弄明白要完成一个怎么样的功能，以面向对象的方式分层，找出实体。
然后就是根据实体特有的属性来完成方法的设计。在封装方法的过程中参数的选择同样是一个重点。基本上参数都应该是实体特有的属性。但也不全是如此。这点还需要我们自己去斟酌决定！

小结

说了这么一大堆，貌似仍旧是在瞎扯。毕竟能力有限，很多时候还需要去领悟。编程世界，需要的是独立思考，独立学习，团队合作的能力！

不要不走心的敲代码了，换种活法，也许你会更优秀！