其实，

常见痛点：在日常开发中。团队经常因为代码重复而导致维护成本飙升Bug 难以定位还有新成员上手慢。缺乏有效的复用策略会让项目迭代速度受限，甚至出现“复制粘贴”式的代码腐败。

# Python def calculate_tax: return amount * rate tax1 = calculate_tax tax2 = calculate_tax

// TypeScript function calculateTax: number { return amount * rate;} const tax1 = calculateTax;const tax2 = calculateTax;

// Java public double calculateTax { return amount * rate;} double tax1 = calculateTax;按理说，double tax2 = calculateTax;

函数级复用

痛点：大量业务逻辑散落在不同文件中。修改同一规则时必须手动搜索并逐个更新，极易遗漏。

函数调用

函数是最直接的复用单元，将重复逻辑封装后统一调用即可。怎么说呢，

高阶函数

痛点：在处理集合或回调时经常写出相似的遍历代码。导致代码膨胀且难以测试，说起来，

高阶函数通过把行为抽象为参数。实现更灵活的复用，

// TypeScript - 函数作为参数
const numbers =;const doubled = numbers.map;// map 接受函数作为参数

# Python - 返回函数
def multiplier:
def multiply:
return x * factor
return multiply
times2 = multiplier # 返回新函数
print) # 输出 10

// Java - 函数作为参数
List numbers = Arrays.asList;List doubled = numbers.stream
.map // map 接受 lambda 表达式
.collect);

// C++ - std::function + lambda
#include 
#include 
void applyToAll(std::vector& vec,std::function func) {
for {
x = func;}
}
说到std:，vector numbers = {1,2,3};applyToAll{ return x * 2;})，// 传入 lambda

通过把「行为」而非「数据」抽象出来高阶函数显著降低了重复代码量。

结构化复用

痛点：业务模型经常出现「属性相似、行为不同」的情况。直接复制类会导致层次混乱、难以

类和对象

类提供了封装数据和方法的能力，对象是类的实例，实现了行为与状态的统一管理。

# Python
class Calculator:
def add:
return a + b
def multiply:
return a * b
calc = Calculator
result = calc.add

// TypeScript
class Calculator {
从add来看，number {
return a + b;}
multiply: number {
return a * b;}
}
const calc = new Calculator;const result = calc.add;

// Java
public class Calculator {
public int add{ return a+b;话说回来，}
public int multiply{ return a*b;}
}
Calculator calc = new Calculator;int result = calc.add;

// C++
class Calculator{
从public来看，int add{ return a+b;}
int multiply{ return a*b;}
}，Calculator calc;int result = calc.add;

继承 & 接口/协议

痛点：当多个类需要共享相同方法时如果仅靠复制，会产生「同一 bug 必须修补多处」的问题。

继承让子类直接使用父类实现；接口和协议则提供行为契约，使得不同实现可以在同一段代码里互换。

# Python - 协议
from typing import Protocol
class Drawable:
def draw -> str: ...
class Circle:
def draw -> str:
return "Drawing circle"
def render:
print)
render) # Circle 自动满足协议，无需显式声明

// TypeScript - 接口多态
interface Animal { speak: string;怎么说呢，}
class Dog implements Animal { speak{ return "Woof";} }
function makeSound{
console.log);}
makeSound);// Woof

组合

痛点："深层继承树"往往导致子类被迫实现不相关的方法，而组合则让我们按需挑选功能模块。

# Python - 使用组合替代继承
class Engine:
def start: return "Engine started"
class Car:
def __init__:
self.engine = Engine # 包含 Engine 实例
def start:
return self.engine.start

// TypeScript - Composition 示例
class Engine { start: string { return "Engine started";
怎么说呢，} }
class Car {
private engine: Engine;constructor{ this.engine = new Engine;}
start这方面，string { return this.engine.start;}
}

类型参数化复用

痛点：面对类似「列表排序」「栈实现」等通用算法时如果每种数据类型都写一遍，会产生大量冗余且容易出现细微差异导致 bug。不过，

C++ – 编译期单态化

C++ 模板在编译阶段为每种实际类型生成独立机器码。实现零运行时开销，但会增大二进制体积。话说回来，

// 函数模板示例
template
T max{ return?a:b，}

int i = max;// 编译生成 max double d = max;老实说，// 编译生成 max

// 类模板示例：通用栈
template
class Stack{
从std:来看。vector elements;public:
void push{ elements.pushback;}
T pop{
T e=elements.back;老实说，elements.popback;return e，}
};

Stack intStack;Stack strStack;

Java – 编译期检查 + 类型擦除

The generic information disappears at runtime → <>,but compile‑time safety remains.

// 泛型方法示例
public  T first{
return items.get;} 

Integer i = first);String s = first);

The same byte‑code backs List,List。so runtime casts can still cause C​lassCastException​ .

T​S / Python – 静态检查 vs 动态运行时

The type hints help IDEs and linters catch errors early but disappear after transpilation.

// TypeScript 泛型函数
function first:T{
return items;} 

const n=first;// 推断为 number const s=first;按理说，// 推断为 string

// 编译后 JavaScript 中没有任何类型信息

# Python – 类型提示仅供 static analysis
from typing import List 

def first -> str: return items

result=first # mypy 警告 if misuse。但运行时仍然执行

宏

痛 点 ： 在 C/C++ 项目里每次需要一个小工具却要写完整函数时开发者往往 resort 到宏，但宏缺乏作用域检查，容易引入隐藏错误。

// C 宏定义 

int r=MAX;// 注意括号防止意外求值顺序

// C++ 宏示例 

int s=SQUARE;// 展开后变成 *)

# Python 装饰器示例 def timing: def wrapper: import time start=time.time result=func print-start}s\") return result return wrapper

@timing def process: import time;time.sleep

process # 自动打印执行时间

// TypeScript 装饰器
function timing{
const original=descriptor.value;descriptor.value=function{
const s=Date.now;const r=original.apply;console.log-s}ms`);return r，};} 

class Service{ @timing process{ /* ... */ } }

注 解 与装饰器外观相似。却只提供元数据，不直接 行为。例如 Java 的 @Override 用于编译期检查，而 Spring 的 @Autowired 在运行时完成依赖注入。

# Python 导入示例 import math # 导入整个模块 print)

from datetime import datetime print)

import requests # 第三方库 resp=requests.get

// TypeScript 导出 / 导入
export function calcTax:number{return amount*0.07;}
export interface User{ name:string;} 

import {calcTax,User} from \"./utils\";import express from \"express\";// 第三方库

// Java 包与导入
package com.example.utils;

public class Calculator{ public static int add{return a+b;} }

// 使用 import com.example.utils.Calculator;不过，int sum=Calculator.add;

// C++ 包含头文件与模块 

import std.core;// 新式模块导入 import mymodule;// 项目自定义模块

---