编程范式：面向对象编程、面向过程编程和面向函数编程

概念

在软件开发的世界里，面向过程和面向对象这两个概念经常被拿来比较。到底什么是面向过程编程？面向对象编程又有什么不同？为什么大家常说面向对象更高级？甚至有时候我们写出来的代码看上去是面向对象，骨子里却还是面向过程的思路——这些问题一直困扰着不少开发者。先来厘清基本定义。

面向对象编程，是一种以类或对象作为组织代码基本单元的编程范式。它把封装、抽象、继承、多态四个特性作为代码设计和实现的基石。而面向对象编程语言，就是提供类或对象的语法机制，并且有现成的语法支持这四个特性的编程语言。

面向过程编程，则是另一种范式。它以过程（可以理解为方法、函数、操作）作为组织代码的基本单元，最明显的特点是数据与方法相分离。代码像流水线一样，通过一组顺序执行的方法来操作数据，完成某个功能。面向过程编程语言，就是不支持类和对象这两个语法概念，也不支持继承、多态、封装等面向对象特性的语言。

下面用一段伪代码来直观对比一下——同样是处理用户数据文件，面向过程和面向对象的风格差异在哪。

// 面向过程风格
struct User {
    char name[64];
    int age;
    char gender[16];
};

struct User parse_to_user(char* text) {
    // 将text("小王&28&男")解析成结构体User
}

char* format_to_text(struct User user) {
    // 将结构体User格式化成文本("小王\t28\t男")
}

void sort_users_by_age(struct User users[]) {
    // 按照年龄从小到大排序users
}

void format_user_file(char* origin_file_path, char* new_file_path) {
    // open files...
    struct User users[1024]; // 假设最大1024个用户
    int count = 0;
    while(1) { // read until the file is empty
        struct User user = parse_to_user(line);
        users[count++] = user;
    }
    sort_users_by_age(users);
    for (int i = 0; i < count; ++i) {
        char* formatted_user_text = format_to_text(users[i]);
        // write to new file...
    }
    // close files...
}

int main(char** args, int argv) {
    format_user_file("/home/zheng/user.txt", "/home/zheng/formatted_users.txt");
}

// 面向对象风格
public class User {
    private String name;
    private int age;
    private String gender;

    public User(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public static User praseFrom(String userInfoText) {
        // 将text("小王&28&男")解析成类User
    }

    public String formatToText() {
        // 将类User格式化成文本("小王\t28\t男")
    }
}

public class UserFileFormatter {
    public void format(String userFile, String formattedUserFile) {
        // Open files...
        List users = new ArrayList<>();
        while (1) { // read until file is empty
            // read from file into userText...
            User user = User.parseFrom(userText);
            users.add(user);
        }
        // sort users by age...
        for (int i = 0; i < users.size(); ++i) {
            String formattedUserText = user.formatToText();
            // write to new file...
        }
        // close files...
    }
}

public class MainApplication {
    public static void main(String[] args) {
        UserFileFormatter userFileFormatter = new UserFileFormatter();
        userFileFormatter.format("/home/zheng/users.txt", "/home/zheng/formatted_users.txt");
    }
}

从代码组织方式就能看出核心区别：面向过程把方法和数据结构分开定义，数据是裸的 struct，方法是一组独立函数；而面向对象把方法和数据绑定在类里，操作数据的行为由对象自身承担。

面向对象编程相比面向过程编程有哪些优势？

能够成为主流不是没有理由的。主要优势可以归纳为三点：

1. 应对大规模复杂程序的能力更强。当系统规模膨胀、逻辑交错时，面向过程的流程式思维很容易让代码变成一团乱麻，而面向对象的封装和分层能有效控制复杂度。

2. 代码更易复用、扩展和维护。继承、多态、接口这些机制让新功能可以在不修改原有代码的基础上叠加，这在面向过程风格里很难实现。

3. 语言描述更人性化、更接近现实世界的建模方式。把数据和操作包在一起，符合人的直觉，也让协作开发时沟通成本更低。

哪些代码设计看似是面向对象，实际是面向过程的？

很多开发者即使在使用 Ja va、C++ 这类面向对象语言，写出来的代码却依然带着浓重的面向过程味儿。下面几种典型情况值得警惕。

滥用 getter、setter 方法。如果一个类的所有属性都暴露了 get/set，那这个类本质上就是一个数据结构，类本身没有行为，所有逻辑都放在外部方法里操作这些数据——和面向过程的 struct 没有本质区别。

滥用全局变量和全局方法。最常见的例子就是 Constants 类（一堆静态常量）和 Utils 类（一堆静态方法）。单例类对象也相当于全局变量。静态方法把数据和行为拆开，破坏了封装特性，是典型的面向过程风格。比如 Ja va 中的 Collections.unmodifiableList() 返回的 UnmodifiableList 虽然看起来是“不可修改”，但它只是通过抛出异常来阻止修改，本质上仍然是一个包装器，真正的数据还是暴露了 getter 方法——如果你对面向对象理解不够深，很容易落入这种“伪对象”的陷阱。

定义数据和方法分离的类。传统的 MVC 结构（现在后端常分为 Controller、Service、Repository 三层），每一层都有对应的 VO、BO、Entity。但这些 POJO 类通常只包含数据，没有任何业务方法，所有操作数据的逻辑都写在 Service 类里。这就是典型的贫血模型——看起来很面向对象，其实本质上是面向过程。而且这种开发模式目前非常普遍，很多 Web 项目都在用。

说到底，面向对象和面向过程并不是谁“高级”谁“低级”的问题。它们各有适用的场景。面向过程在小型工具、高性能计算、底层驱动里依然不可或缺；而面向对象在复杂业务系统、大型框架的构建中更有优势。关键是要理解各自的设计哲学，在合适的场景用合适的手法，而不是盲目崇拜某一种范式。

最后回到最开始的问题：为什么有时候面向对象语言里容易写出面向过程风格的代码？因为很多开发者只是机械地用了类，却没有真正把数据和行为绑定在一起，没有贯彻封装、多态这些思想。写代码时多问一句“这个对象真的有行为吗？”——这就是从学会语法到理解设计的跨越。