面向对象编程核心：封装、继承、多态与Java/Python/C++对比

1. 先从一道面试题说起：面向对象到底在解决什么

1.1 没有面向对象，代码会变成什么样

我先抛一个场景，大家体会一下就懂了。假设你要写一个点餐系统，功能很简单：用户选菜、下单、结账、打印小票。如果用面向过程的思路，你会怎么写？大概率是这样：先定义一堆全局变量，menu 存菜单，order 存当前订单，user 存用户信息，然后再定义 add_to_order()、checkout()、print_receipt() 这些函数去操作它们。整个程序跑起来是没问题，但问题藏在你后面要改需求的时候。

比如产品经理突然说，我要加一个“满 30 减 5”的优惠券功能。这时候你得跑到 checkout() 里面去改计算逻辑，还得可能去改 print_receipt() 怎么展示优惠信息，如果全局变量被多个函数共享，你还要小心翼翼排查哪个函数不小心把 order 的状态改了。这个改动听起来简单，但实际动起手来，满地都是雷。这就是面向过程写法的天花板：数据和操作是分离的，改一个功能前，你永远要先在脑子里理清“哪些函数用到了哪些数据”，一旦项目超过某个规模，你的脑容量就跟不上了。

1.2 封装、继承、多态到底在解决什么问题

面向对象的核心思路，就是把“数据”和“操作这些数据的方法”捆绑在一起，形成一个独立的单元，这个单元就是对象。你说这有什么了不起的？了不起的地方在于，它把代码的边界画清楚了。你不需要知道一个对象内部怎么实现的，你只需要调用它的方法就行。这个概念理解到位了，后面学的 private、public、继承、多态 全都能串起来。

我用外卖柜举个例子。你平时取外卖的时候，只看到柜子的取餐口，你不需要知道柜子后面的电路怎么走、货架怎么排、温控怎么调，你只需要扫码、开柜门、拿走外卖。柜子把内部复杂性藏起来了，只给你暴露了几个必要操作，这就是封装。外卖柜有大格、中格、小格，虽然尺寸不同，但打开柜门的逻辑是一样的，可以说它们继承了同一个“柜门控制”的模板，这是继承。而你作为取餐的人，不管是大的还是小的柜门，你的操作永远是“扫码打开”，你不会去分辨这是哪个规格的柜子，这种“对不同类型的对象，用同一个动作就生效”的能力，就是多态。

1.3 为什么 Java、Python、C++ 都在讲面向对象

这就是这个主题有意思的地方。Java 几乎是纯面向对象的语言，除了 int、double 这些基本类型，万物皆对象，你写任何代码都绕不开类的概念；Python 则更灵活，它是一门“一切皆对象”的动态语言，甚至函数本身也是对象，但它不强迫你用面向对象的方式来组织代码，你可以用脚本式写法快速摊一张业务逻辑；C++ 就更复杂了，它同时支持面向过程和面向对象，还带了模板、多继承这些更硬核的机制，很多底层系统的架构方式又完全不同。

但这三种语言殊途同归，都提供了类、对象、继承、多态这些承载面向对象思想的语法。学习的时候，最忌讳的就是只学某一种语言而对思想本身没概念。我这篇笔记会同时用三种语言对照着讲，因为我自己当年踩过的坑，就是“在 Java 里会写 class，换到 C++ 突然连构造函数都不会写了”，这些对比的价值，比死记语法大得多。

2. 类和对象：三种语言的第一行代码

2.1 语法对照：从 class 关键字开始

面向对象的代码，最基本的单位是类。类可以理解成一张设计图纸，而对象就是根据这张图纸造出来的真实产品。图纸定义了有哪些属性（数据）和方法（功能），但你不住在图纸里，你住的是按图纸盖出来的房子。

先看三种语言定义同一个“用户”类的差异。Java 是这样写的：

java复制public class User {
    private String name;
    private int age;

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

    public void introduce() {
        System.out.println("大家好，我是" + name + "，今年" + age + "岁");
    }
}

Python 的版本会精简很多：

python复制class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"大家好，我是{self.name}，今年{self.age}岁")

C++ 的版本，注意构造函数的初始化列表写法：

cpp复制#include <iostream>
#include <string>

class User {
private:
    std::string name;
    int age;

public:
    User(std::string name, int age) : name(name), age(age) {}

    void introduce() {
        std::cout << "大家好，我是" << name << "，今年" << age << "岁" << std::endl;
    }
};

我见过不少新手第一次看到这三种写法，直接懵掉：为什么 Python 的构造方法是 __init__，Java 的构造方法跟类同名，C++ 也是跟类同名但前面没有 void？其实大家做的事情完全一样，都是在“创建对象的时候把数据填进来”。Python 的 self、Java 的 this、C++ 的隐式 this 指针，指的都是“当前这个对象自己”。

2.2 构造函数与析构：对象的生命周期管理

构造函数解决的是“对象一出生就必须是可用的”这个问题。比如上面的 User 类，如果你允许别人创建一个没有名字的用户，那后面 introduce() 打印出来的内容就没法看了。构造函数强制你在创建对象的时候就把 name 和 age 传进来，从机制上杜绝了“半成品对象”。

Python 里 __init__ 虽然名字是初始化方法，但它不是严格意义上的构造函数，因为对象实际上在 __new__ 里就创建了，__init__ 只是完成初始化。这个概念你暂时不用太抠，99% 的业务场景里，你把 __init__ 当构造函数用没有任何问题。

C++ 和 Java 还有一个区别，就是对象销毁的逻辑。C++ 有析构函数，对象生命周期结束时会自动调用，用来释放资源，比如关闭文件、释放堆内存。Java 没有析构函数的概念，对象何去何从完全交给垃圾回收器（GC）来管理，你只管 new，不用管 new 出来的东西什么时候消亡。Python 也有 __del__，但它的触发时机不可控，依赖引用计数，所以你在生产环境里基本不要依赖它做关键清理工作。

2.3 创建对象：C++ 栈对象、堆对象与其他语言的区别

这个知识点我当年在 C++ 里栽过跟头，多说几句。C++ 里创建一个对象有两种方式：

cpp复制User user("张三", 18);   // 栈上创建，生命周期自动管理，函数结束时自动销毁
User* userPtr = new User("李四", 20);  // 堆上创建，需要手动 delete
delete userPtr;

栈上创建的对象，函数一结束就自动调用析构函数，非常干净。但它的生命周期限制在花括号范围内，如果你需要把一个对象传到别处、或者让它的生命周期跨越多个函数，就得用堆上创建，用指针传递。同时记住，new 出来的对象必须手动 delete，否则内存泄漏。Java 和 Python 里你永远只写 new 或直接调用类构造，不用管对象在堆上什么时候被回收，这是两种截然不同的编程心智。

3. 封装：private 不是摆设

3.1 访问控制的三个级别

封装说起来好像很简单，就是“把变量设为 private，不让外面直接访问”，但真到写代码的时候，你会发现很多人压根没想明白为什么要这么做。举个最简单的例子：User 类有 age 字段，如果没有访问控制，你可以直接写 user.age = -100，一个负 100 岁的用户就诞生了。你当然可以拍脑袋说“我写代码的时候小心点”，但实际项目里，一个类可能被几十处代码使用，你管不住所有人。

Java 和 C++ 都有三个访问控制级别：public 完全公开，protected 只对子类和同包（Java）可见，private 只能类内部访问。我把它们放在一起看：

Python 在这个表里比较特殊，它没有真正的编译器强制的访问控制，所以用了下划线约定来“劝退”外部访问。但理解价值是一样的：类把内部状态保护起来，外部只能通过公开方法操作，这样你可以在方法里做校验、做拦截，而不是让数据裸奔。

3.2 加了 getter/setter 就有意义吗

实操中，很多人一听说要封装，就开始写 getter 和 setter，把所有字段都弄成 private，再加一堆 getXxx() 和 setXxx()。这个操作只学到了形式，没学到精髓。封装的意义不在于你加了 getter/setter，而在于你在 setter 里拦住了非法数据：

java复制public void setAge(int age) {
    if (age < 0 || age > 150) {
        throw new IllegalArgumentException("年龄不合法");
    }
    this.age = age;
}

Python 里更优雅的写法是用 @property 装饰器，把方法包装成属性：

python复制class User:
    def __init__(self, name, age):
        self.name = name
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        if value < 0 or value > 150:
            raise ValueError("年龄不合法")
        self._age = value

我自己的建议是：如果字段没有额外的校验逻辑、没有联动逻辑，就不需要写 getter/setter，直接用公开字段反而更简洁。等需求变了，再加 @property 或 setter 也不迟，Python 属性访问的语法不变，改起来成本很低。但 Java 里为了避免以后大改，我通常习惯一开始就给字段加 private，给关键字段配上访问器，C++ 里同理。

3.3 封装带来的边界感

封装还有一个隐藏福利，就是“边界感”。当你把订单类、用户类、支付类划分清楚之后，你会发现自己写代码的时候变得更从容了。改一个类内部的东西，不需要担心波及另一个类。这就是为什么说面向对象特别适合大型项目，因为在人多手杂的团队环境里，封装等于给所有成员划了道线，谁越线谁背锅。

4. 继承与组合：代码复用到底靠什么

4.1 继承：把公共代码往上提

继承解决的问题很简单：抽公共代码。假设你写了 Dog 和 Cat 两个类，发现它们都有 name 字段、eat() 方法、sleep() 方法，这时候你可以定义一个 Animal 父类，让两个子类去继承它：

java复制class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println("汪汪");
    }
}

C++ 的继承写法是 class Dog : public Animal，Python 是 class Dog(Animal)。三个语言的一个共同要求是：子类构造时，必须先调用父类的构造函数，Java 用 super()，C++ 用初始化列表 : Animal(name)，Python 用 super().__init__(name)。为什么？因为父类的字段也需要初始化，你不调谁调？

4.2 菱形继承问题：C++ 的经典大坑

这绝对是 C++ 面试的高频考点。菱形继承长这样：

cpp复制class A { public: virtual void foo() {} };
class B : public A {};
class C : public A {};
class D : public B, public C {};

D 继承 B 和 C，B 和 C 又都继承 A，模型图上就是一个菱形。这时候 d.foo() 到底调用 B 的 A、还是 C 的 A？编译器直接报歧义错误。这就是 C++ 单继承和 Java/Python 不太一样的地方：Java 直接不让一个类多继承多个类，它用接口来解决多能力组合的问题；Python 用 MRO（方法解析顺序）自动决定调用路径，通常不会有歧义；C++ 则需要你主动写成 class B : virtual public A 虚继承来绕坑。

我见过不少 C++ 新人被这个坑搞到怀疑人生。我的建议很简单：设计继承结构时，层级不要超过三层，能不碰多继承就不碰多继承。用接口（Java）、抽象基类（C++）、组合（所有语言）来替代大多数多继承的场景，省下的时间远超你钻研虚继承机制的时间。

4.3 组合优先于继承：一次真实的翻车记录

继承不是银弹，我自己的一个项目就栽过。当时设计一个消息通知系统，我顺手就做了个继承体系：BaseMessage → TextMessage → OrderMessage → OrderStatusMessage，总共四五层。后来需求来了，要加一种既不继承 OrderMessage、但又需要订单信息的消息类型，我一看这个继承链，怎么放都难受，最后只能硬着头皮再加一层。结果就是改一个父类，波及整个继承树上所有的类，每次动 BaseMessage 都要把所有子类通读一遍，改完还心里发虚。

后来我把方案从继承改成了组合：用一个 Message 类，里面塞一个 OrderInfo 对象作为成员，需要订单信息就持有，不需要就不持有。代码一下子清爽了。继承表达的是“is-a”关系，狗是一种动物，没问题；组合表达的是“has-a”关系，车有引擎、人有手机，这才是大多数业务场景的真实关系。如果你的代码里出现了一个“是 XXX”关系很牵强的类，强烈建议优先考虑组合。

5. 多态：让代码“认物不认人”

5.1 编译期多态：函数重载与模板

多态其实就是“同一个动作在不同对象上表现出不同行为”。在代码层面，它分两种形态。第一种是编译期多态，主要体现在函数重载和泛型上。

比如你写一个 print 函数，它既能接收整数又能接收字符串，你不需要给它们取不同的名字，借助重载就行：

cpp复制void print(int value) { std::cout << "整数: " << value << std::endl; }
void print(std::string value) { std::cout << "字符串: " << value << std::endl; }

调用方只需写 print(123) 和 print("hello")，编译器会根据实参类型自动选择版本。Java 的 System.out.println 就是典型的重载狂魔，它重载了几十个版本，你怎么传都有对应的方法。Python 不支持传统意义的函数重载，但它的动态类型特性，让同一个函数天然能接收多种类型，这点我们后面再说。

5.2 运行期多态：虚函数、抽象类与鸭子类型

真正体现面向对象优势的，是运行期多态。它的核心机制是：代码里写的是父类类型的引用或指针，实际运行时指向的是某个子类对象，调用方法时执行的是子类版本。

Java 的接口是最干净的多态表达。比如支付功能的抽象：

java复制interface Payment {
    void pay(double amount);
}

class Alipay implements Payment {
    public void pay(double amount) {
        System.out.println("支付宝支付" + amount + "元");
    }
}

class WechatPay implements Payment {
    public void pay(double amount) {
        System.out.println("微信支付" + amount + "元");
    }
}

// 业务代码
public void process(Payment payment, double amount) {
    payment.pay(amount);
}

调用方 process 只认识 Payment 接口，它压根不关心你传进来的是支付宝还是微信。后续新增一个 UnionPay 类，只要实现了 Payment 接口，process 一行代码都不用改。这个特性在业界叫“开闭原则”——对扩展开放，对修改关闭。新增功能靠新增类，而不是改既有代码。

Python 实现同样效果，甚至连接口都不需要：

python复制class Alipay:
    def pay(self, amount):
        print(f"支付宝支付{amount}元")

class WechatPay:
    def pay(self, amount):
        print(f"微信支付{amount}元")

def process(payment, amount):
    payment.pay(amount)

这就是所谓的“鸭子类型”：如果它叫起来像鸭子、走起路像鸭子，那它就是鸭子。process 函数不关心传入对象的类型，只关心它有没有 pay 方法。写起来爽，但代价是少了很多编译期检查，你传个没实现 pay 的对象进来，运行到那一行才会报错。

C++ 的实现用抽象类和虚函数：

cpp复制class Payment {
public:
    virtual void pay(double amount) = 0;  // 纯虚函数
    virtual ~Payment() = default;
};

class Alipay : public Payment {
public:
    void pay(double amount) override {
        std::cout << "支付宝支付" << amount << "元" << std::endl;
    }
};

这里 = 0 标记纯虚函数，让 Payment 变成抽象类，不能直接实例化，只能被继承。override 关键字是给编译器看的，声明“我要重写父类的虚函数”，如果你拼写错了、或者父类根本没有这个虚函数，编译器会报错，这能提前拦住很多笔误。

5.3 多态到底省了什么

多态最大的价值，不是让代码看起来“高级”，而是把“变化”跟“不变”隔离。支付流程不变的是：先支付、后记录；变化的是：支付渠道各有各的实现。你只要把变化点抽象成接口或虚函数，业务主流程就稳定了。这招在插件系统、策略模式、状态模式里全是核心套路。我自己写代码时判断是否该用多态，有一个简单标准：如果你在一个方法里看到连续五六个 if else 判断类型分支，那这里大概率就该抽接口了。

6. 实操案例：用面向对象重构一个记账小工具

6.1 需求拆解与类设计

前面概念讲了一堆，咱们来点实打实的。需求很简单：做一个记账工具，支持记录收入和支出，写备注，统计总收入和总支出。如果用面向过程的写法，你会用三个数组分别存类型、金额、备注，再加几个函数去操作它们。现在我们用面向对象的思路来设计，目标只有一个：让新增功能的时候，改动最小。

我按职责拆了三个类：

• Record：一条记账记录，包含类型（收入/支出）、金额、备注。
• AccountBook：账本，内部维护一个记录列表，提供 add_record 和 get_total_income、get_total_expense 等方法。
• Main：程序入口，负责与用户交互。

为什么要把 Record 单独抽出来？因为记账记录有自己完整的数据结构和校验逻辑，比如金额不能是负数、类型只能是收入和支出两种，这些规则放在 Record 内部最合适。AccountBook 只负责管理记录的增删查，不需要关心单条记录的合法性。

6.2 Java 版本完整实现

先看 Java 的 Record 类：

java复制public class Record {
    public enum Type {
        INCOME, EXPENSE
    }

    private final Type type;
    private final double amount;
    private final String note;

    public Record(Type type, double amount, String note) {
        if (amount <= 0) {
            throw new IllegalArgumentException("金额必须大于0");
        }
        this.type = type;
        this.amount = amount;
        this.note = note;
    }

    public Type getType() { return type; }
    public double getAmount() { return amount; }
    public String getNote() { return note; }

    @Override
    public String toString() {
        return (type == Type.INCOME ? "收入" : "支出") + " " + amount + "元 " + note;
    }
}

然后 AccountBook：

java复制import java.util.ArrayList;
import java.util.List;

public class AccountBook {
    private final List<Record> records = new ArrayList<>();

    public void addRecord(Record record) {
        records.add(record);
    }

    public double getTotalIncome() {
        double total = 0;
        for (Record r : records) {
            if (r.getType() == Record.Type.INCOME) {
                total += r.getAmount();
            }
        }
        return total;
    }

    public double getTotalExpense() {
        double total = 0;
        for (Record r : records) {
            if (r.getType() == Record.Type.EXPENSE) {
                total += r.getAmount();
            }
        }
        return total;
    }

    public void printAll() {
        for (Record r : records) {
            System.out.println(r);
        }
    }
}

最后是入口类：

java复制public class Main {
    public static void main(String[] args) {
        AccountBook book = new AccountBook();
        book.addRecord(new Record(Record.Type.INCOME, 10000, "工资"));
        book.addRecord(new Record(Record.Type.EXPENSE, 2500, "房租"));
        book.addRecord(new Record(Record.Type.EXPENSE, 300, "餐饮"));

        book.printAll();
        System.out.println("总收入: " + book.getTotalIncome());
        System.out.println("总支出: " + book.getTotalExpense());
    }
}

注意 Record 的构造函数里那个 if (amount <= 0) 校验，这就是封装。你从外部创建一条记录时，金额不合法直接抛异常，从机制上防止脏数据进入账本。

6.3 Python 与 C++ 版本的关键差异

Python 的版本可以更简洁，而且得益于动态语言的灵活，甚至可以用 dataclass 简化代码：

python复制from dataclasses import dataclass
from enum import Enum


class Type(Enum):
    INCOME = "收入"
    EXPENSE = "支出"


@dataclass
class Record:
    type: Type
    amount: float
    note: str

    def __post_init__(self):
        if self.amount <= 0:
            raise ValueError("金额必须大于0")


class AccountBook:
    def __init__(self):
        self._records = []

    def add_record(self, record: Record):
        self._records.append(record)

    def get_total_income(self):
        return sum(r.amount for r in self._records if r.type == Type.INCOME)

    def get_total_expense(self):
        return sum(r.amount for r in self._records if r.type == Type.EXPENSE)

    def print_all(self):
        for r in self._records:
            print(f"{r.type.value} {r.amount}元 {r.note}")


book = AccountBook()
book.add_record(Record(Type.INCOME, 10000, "工资"))
book.add_record(Record(Type.EXPENSE, 2500, "房租"))
book.add_record(Record(Type.EXPENSE, 300, "餐饮"))
book.print_all()
print(f"总收入: {book.get_total_income()}")
print(f"总支出: {book.get_total_expense()}")

dataclass 是 Python 3.7 以后的语法糖，自动帮你生成 __init__、__repr__ 等方法，__post_init__ 在初始化完成后执行，适合放校验逻辑。但要注意一点：AccountBook 内部的 records 如果是直接暴露给外界的列表，外部就可以随意追加非法数据，所以我把列表前面加了下划线，算是“心理上的私有”，约定队友不要直接碰。

C++ 版本需要你自己管理很多细节，比如传引用、用 const 修饰只读方法：

cpp复制#include <iostream>
#include <string>
#include <vector>

enum class RecordType { INCOME, EXPENSE };

class Record {
private:
    RecordType type;
    double amount;
    std::string note;

public:
    Record(RecordType type, double amount, std::string note)
        : type(type), amount(amount), note(note) {
        if (amount <= 0) {
            throw std::invalid_argument("金额必须大于0");
        }
    }

    RecordType getType() const { return type; }
    double getAmount() const { return amount; }
    std::string getNote() const { return note; }
};

class AccountBook {
private:
    std::vector<Record> records;

public:
    void addRecord(const Record& record) {
        records.push_back(record);
    }

    double getTotalIncome() const {
        double total = 0;
        for (const auto& r : records) {
            if (r.getType() == RecordType::INCOME) {
                total += r.getAmount();
            }
        }
        return total;
    }

    double getTotalExpense() const {
        double total = 0;
        for (const auto& r : records) {
            if (r.getType() == RecordType::EXPENSE) {
                total += r.getAmount();
            }
        }
        return total;
    }

    void printAll() const {
        for (const auto& r : records) {
            std::cout << (r.getType() == RecordType::INCOME ? "收入" : "支出")
                      << " " << r.getAmount() << "元 " << r.getNote() << std::endl;
        }
    }
};

int main() {
    AccountBook book;
    book.addRecord(Record(RecordType::INCOME, 10000, "工资"));
    book.addRecord(Record(RecordType::EXPENSE, 2500, "房租"));
    book.addRecord(Record(RecordType::EXPENSE, 300, "餐饮"));
    book.printAll();
    std::cout << "总收入: " << book.getTotalIncome() << std::endl;
    std::cout << "总支出: " << book.getTotalExpense() << std::endl;
    return 0;
}

C++ 里 const 关键字特别重要，getTotalIncome() const 明确了“这个方法不会修改对象内部状态”，编译器会帮你监督这一点。如果你在一个 const 方法里试图修改成员变量，直接编译报错。Java 里没有这个机制，Python 更是全靠自律，所以写 C++ 虽然麻烦，但很多错误确实能在编译期就暴露。

6.4 重构带来的实际变化

这个记账工具，用面向过程写也只要几十行，能跑，但你现在试着加一个需求：输出“最近 7 天的支出趋势图”。面向过程的版本，你得在全局找 records 数组在哪、getTotalExpense 在哪、然后新建一个函数去访问它们。面向对象的版本呢？我只需要在 AccountBook 类里新增一个 getLastSevenDaysExpense() 方法，内部访问 records，然后加一个测试。谁也不会受影响。这就是我们天天说“低耦合、高内聚”在实际代码里的体现。

7. 常见问题与排查技巧实录

7.1 深拷贝与浅拷贝：C++ 的段错误和 Python 的引用陷阱

这是我见过新手翻车最多的地方。C++ 里如果类中有指针成员，默认的拷贝构造函数只做浅拷贝，两个对象的指针指向同一块内存，析构时连续释放两次，直接段错误崩溃。Python 里更隐蔽：`

a = b 只是让 a 和 b 指向同一个对象，你改 a 的属性，b 也变了。用 copy.copy() 是浅拷贝，嵌套的对象还是共享的；要用 copy.deepcopy() 实现深拷贝。Java 里也有类似问题，clone() 默认是浅拷贝，需要自己重写。我的经验是：先搞清楚你到底需不需要拷贝，需要拷贝的话，对象里有没有引用类型的成员，有就考虑深拷贝或直接提供工厂方法。

7.2 对象比较：==、equals、is 傻傻分不清

对象相等有两种含义：引用相等（是不是同一个对象）和值相等（内容是否一致）。Java 里 == 比较引用，equals 才比较内容，所以 new String("a") == new String("a") 是 false。Python 里 is 比较引用，== 比较值。但 Python 的整数有一个小整数缓存池，a = 100; b = 100; a is b 可能是 True，换成 a = 1000; b = 1000，又可能是 False，这种坑让人防不胜防。

C++ 里没有内置的相等运算符语义，默认 == 对类是没有定义的，你需要自己重载 operator==。写业务代码时，我一般建议：比较值就看 equals/==，比较对象身份才用 is/==（引用），不要混着用。类似 Record 这种值对象，两个金额一样备注一样的记录，逻辑上就应该相等，我一般会重写 equals 或 __eq__ 方法。

7.3 对象生命周期与资源管理：谁持有、谁释放

C++ 新手最容易犯的内存错误，是“返回一个局部对象的指针”。

cpp复制User* createUser() {
    User u("张三", 18);
    return &u;  // 大错特错！u 是栈对象，函数结束就销毁了
}

这个函数返回的指针指向一块已经销毁的内存，调用方再用就是未定义行为。正确的做法是返回 User 值本身（C++11 以后移动语义非常高效，不用怕拷贝开销），或者用智能指针 std::unique_ptr<User>。Java 和 Python 虽然没有这个问题，但也有类似的“生命周期管理”概念，比如数据库连接、文件句柄，用完了不关就是泄漏。Python 里用 with 语句，Java 里用 try-with-resources，C++ 里用 RAII，核心思想都是把资源生命周期跟对象生命周期绑定，对象销毁自动释放资源。

7.4 面向对象常见错误速查表

这张表我建议大家收藏起来，遇到问题先对号入座：

8. 写在最后的个人体会

Day6 的面向对象，到这里就告一段落了。说实话，面向对象不像函数、循环那些语法，学会了就能马上用，它是一种需要慢慢“悟”的思维方式。我第一次接触的时候，觉得这些概念抽象得要命，写着写着才明白，原来面向对象不是用来炫技的，而是帮你把复杂问题拆小、把代码边界划清、让队友之间少互相干扰的工程化工具。

如果你现在还在为“什么时候该写一个类”而纠结，我的建议很朴素：先别管什么设计原则，把功能写出来，能跑；然后反问自己“要不要加功能？改起来费不费劲？费劲就抽类”。等你的类越抽越顺手，你自然就理解了为什么大家都在说面向对象是大型项目的基石。

最后再分享一个学习技巧：不要只盯着一种语言看，把同一个类用 Java、Python、C++ 各写一遍，你会有一种“原来它们是同一件事”的顿悟。语言之间的语法差异会逼着你去理解思想层面上的共同点，这正是这篇博客想帮你做到的事。