这是一套为新生设计的面向对象编程教学代码，涵盖 C++, C#, TypeScript 和 Go 等多种语言，逐步深化 OOP 的核心概念。

1. 理解类的基本概念 (C++)
2. 掌握接口思想和多态 (C#)
3. 了解 Go 的设计哲学 (接口的隐式实现和嵌入)
4. 为什么组合比继承更好

---

目录: 01-cpp-basics/

核心概念:

• ✅ 类的定义和成员变量
• ✅ 访问控制 (public, private, protected)
• ✅ 构造函数和析构函数
• ✅ 继承
• ✅ 编译时多态 (函数重载)
• ⚠️ 简单演示虚函数现象（不深入实现）

文件:

• device.h - 设备类的层级定义
• main.cpp - 演示代码
• 可直接编译运行: g++ main.cpp -o main 或在 VS Code 中调试

为什么从 C++ 开始？

• C++ 是最底层的，最接近硬件
• 学生可以直观理解内存、继承等概念
• 为理解其他语言的 OOP 思想打基础

---

目录: 02-csharp-interface/

核心概念:

• ✅ 接口思想（这是重点！）
• ✅ 一个类实现多个接口 (多重实现)
• ✅ 多态的真正含义
• ✅ 抽象类与接口的区别
• ✅ 面向接口编程

文件结构 (支持 Linux/Windows):

├── Interfaces.cs       # 接口定义
├── DeviceClasses.cs    # 具体类实现
├── AbstractClasses.cs  # 抽象类演示
├── Utilities.cs        # 工具函数
├── Program.cs          # 多个示例程序类
└── *.csproj            # 项目配置

使用方式:

1. 完整演示 (默认):

   dotnet run
   

   这将运行 Program 类中的完整演示

2. 学生实验 (取消注释运行单个示例):

   在 Program.cs 中，每个示例都被注释包围：

   /*
   class Example1_MultipleInterfaces
   {
       static void Main() { ... }
   }
   */
   

   步骤:

   1. 注释掉现有的 Program 类的 Main() 方法
   2. 取消某个示例的注释
   3. 运行 dotnet run

3. 调试支持:

   • 完全兼容 VS Code 调试
   • 可设置断点，单步执行
   • 查看变量值，理解执行流程

为什么用 C# 讲接口？

• C# 的接口语法清晰直观
• 支持多接口实现，演示"能力"组合
• 顶级语句被移除，便于学生学习传统的 OOP 结构
• 跨平台运行（Linux, Windows, macOS）

关键示例:

• Example1: 多接口实现 (SmartPhone 同时实现 IChargeable, IPhotographer, ICallable)
• Example2: 充电站 (接受任何 IChargeable 设备)
• Example3: 摄影工作室 (接受任何 IPhotographer 设备)
• Example4: 接口数组 (统一管理不同类型的对象)
• Example5: 抽象类 (MediaPlayer 的不同实现)

---

目录: 03-typescript-prototype/

核心概念:

• ⚠️ JavaScript 的函数式继承
• ⚠️ 原型链的工作原理
• ✅ TypeScript 的 class 语法糖

说明: 这个阶段可根据时间灵活调整。

• 如果时间充足：详讲原型链和构造函数
• 如果时间紧张：快速过一遍，强调"TypeScript class 本质是原型链"

---

目录: 04-go-composition/

核心概念:

• ✅ Go 没有继承，没有虚函数
• ✅ 接口的隐式实现 (无需 implements 声明)
• ✅ 结构体嵌入 (组合而非继承)
• ✅ 'has-a' 关系优于 'is-a' 关系

文件结构 (独立 Go 项目):

├── main.go                      # 演示入口和总结
├── 01_implicit_interfaces.go    # 接口的隐式实现
├── 02_struct_embedding.go       # 结构体嵌入（组合）
└── go.mod                       # Go 模块

运行方式:

cd 04-go-composition
go run .

教学重点:

两个核心概念：

1. 接口的隐式实现 (01_implicit_interfaces.go):

   • 没有 implements 关键字
   • 只要实现了所有方法，就自动满足接口
   • 同一个接口可以被不同的类型实现
   • 例：File, Socket, Buffer 都可以是 Writer
   • 展示代码的解耦能力

2. 结构体嵌入 (02_struct_embedding.go):

   • 在一个结构体中嵌入另一个结构体
   • 继承嵌入类型的所有字段和方法
   • 可以重写（覆盖）嵌入类型的方法
   • Duck 既能 Fly (来自 Bird)，又能 Swim (来自 SwimAbility)
   • 展示灵活的能力组合

为什么最后讲 Go？

• Go 最直白地展现现代设计思想
• 没有继承强制学生用组合
• 接口的隐式实现体现"鸭子类型"
• 帮助学生理解为什么组合比继承更好

---

• C++: GCC/Clang 或 MSVC
• C#: .NET 8.0 或更高版本
• Go: Go 1.21 或更高版本
• VS Code: 配置相应的调试器

# C++
cd 01-cpp-basics
g++ main.cpp -o main
./main

# C#
cd 02-csharp-interface
dotnet run

# Go
cd 04-go-composition
go run main.go

# C++ (PowerShell)
cd 01-cpp-basics
g++ main.cpp -o main.exe
.\main.exe

# C#
cd 02-csharp-interface
dotnet run

# Go
cd 04-go-composition
go run main.go

---

目标: 理解接口和多态

任务:

1. 打开 02-csharp-interface/DeviceClasses.cs
2. 添加新类 Laptop 实现 IChargeable 和 IPhotographer
3. 在 Program.cs 中创建实例并测试

提示:

class Laptop : Device, IChargeable, IPhotographer
{
    public int BatteryLevel { get; private set; } = 60;
    public int MegaPixels { get; private set; }
    
    // 实现接口...
}

目标: 理解接口的隐式实现

任务:

1. 打开 04-go-composition/01_implicit_interfaces.go
2. 添加新类型 Database 实现 Writer 和 Reader
3. 在 main.go 中创建实例并测试

提示:

type Database struct {
    Name  string
    Table string
}

func (db *Database) Write(data string) error {
    // 实现 Writer 接口
    return nil
}

func (db *Database) Read() (string, error) {
    // 实现 Reader 接口
    return "", nil
}

目标: 理解 struct 嵌入和组合

任务:

1. 打开 04-go-composition/02_struct_embedding.go
2. 添加新类型 Fish (只能游泳，不能飞行)
3. 添加新类型 Eagle (只能飞行，不能游泳)
4. 对比这三种新类型的差异

提示:

type Fish struct {
    Animal
    SwimAbility
    // 没有 Wings
}

type Eagle struct {
    Animal
    Wings
    // 没有 SwimAbility
}

---

概念	C++	C#	Go
继承	✅ 单继承	✅ 单继承	❌ 无继承
接口	❌ 虚函数	✅ 正式接口	✅ 隐式接口
多实现	❌ 不支持	✅ 支持	✅ 支持
多态	✅ 虚函数	✅ 接口/抽象类	✅ 接口
访问控制	✅ public/private/protected	✅ public/private	✅ Exported/unexported
哲学	面向继承	面向接口	面向组合

---

• 类的基本结构 (成员变量、方法)
• 访问修饰符的作用
• 继承的原理和多态的实现
• 接口定义的是"能力"，不是"本质"
• 一个类可以实现多个接口
• 组合比继承更灵活
• 面向接口编程的好处
• 不同语言对 OOP 的不同理解

---

• 第1周: C++ 基础 (1-2 课时)
• 第2周: C# 接口深入 (2 课时)
• 第3周: TypeScript/Go (1-2 课时)

1. 从简到难: C++ → C# → Go
2. 回顾对比: 每个阶段都回顾之前的概念
3. 实际例子: 用学生能理解的例子（手机、游戏等）
4. 代码演示: 即时编辑和运行代码，让学生看到效果
5. 鼓励实验: 让学生自己修改代码，观察结果

• ❌ 认为继承是实现代码复用的唯一方式
• ❌ 将接口和虚函数混为一谈
• ❌ 认为 Go 的隐式接口是"动态类型"
• ❌ 不理解"组合"和"继承"的实质区别

• ✅ 组合也可以复用代码，而且更灵活
• ✅ 虚函数是 C++ 实现接口的方式，但不是接口本身
• ✅ Go 的隐式接口是静态类型检查，只是在编译时进行
• ✅ 继承是"是什么"关系，组合是"有什么"关系

---

// launch.json 示例
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": ".NET Core Launch",
            "type": "coreclr",
            "request": "launch",
            "preLaunchTask": "build",
            "program": "${workspaceFolder}/02-csharp-interface/bin/Debug/net8.0/02-csharp-interface.dll",
            "args": [],
            "cwd": "${workspaceFolder}",
            "stopAtEntry": false
        }
    ]
}

// launch.json 示例
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch",
            "type": "go",
            "request": "launch",
            "mode": "debug",
            "program": "${workspaceFolder}/04-go-composition",
            "env": {},
            "args": []
        }
    ]
}

---

学生应该记录:

1. C++ 阶段:

   • 访问控制的作用
   • 虚函数如何实现多态
   • 内存分配方式

2. C# 阶段:

   • 接口的语法和语义
   • 为什么一个类可以实现多个接口
   • 多态如何解耦代码

3. Go 阶段:

   • 为什么不需要继承
   • 如何用接口定义能力
   • 组合的优势

---

Q: 为什么要学这么多种语言？ A: 每种语言都代表了 OOP 思想的不同诠释。学习多种语言能帮你理解 OOP 的本质，而不是某个语言的特定语法。

Q: 为什么 Go 没有继承？ A: Go 的设计者认为继承会创建复杂的继承树，而组合（嵌入）+接口足以应对所有场景，反而更清晰灵活。

Q: Go 的接口隐式实现是什么意思？ A: 在 C#/Java 中，你要写 class Dog : IAnimal { }。在 Go 中，你只需写对应的方法，Go 会自动认为你实现了这个接口。无需声明。

Q: struct 嵌入和继承有什么区别？ A: 继承是"是什么"(is-a)，嵌入是"有什么"(has-a)。Duck 不是 Bird，而是有 Bird 的能力（和其他能力）。

Q: 我不懂 Go，能教吗？ A: 可以。04-go-composition 的代码很简洁，只有接口和嵌入两个概念，讲解的是设计思想而不是 Go 语法细节。

---

• Robert C. Martin: "Clean Code" (关于设计原则)
• Gang of Four: "Design Patterns" (设计模式)
• Go Blog: "Effective Go" (Go 的设计哲学)

---

作者: Created for OOP Teaching
版本: 1.0
最后更新: 2026-01-19