编程语言(2)—类型和运算符

程序=数据+计算。类型确定了数据的定义、数据支持的计算。是程序的基础。

类型可分为静态类型和动态类型。绝大多数类型是静态类型，编译期确定(常见的如C++的模版类型、sizeof(int)、typeid(int))。动态类型特指接口和多态, 对象的类型需运行时确定。例如C++具有虚函数的多态类, golang的interface{}和通过接口访问struct对象, 以及java的普通类(java的类普通方法均需通过虚函数表调用)。

本文介绍C、C++、JAVA、Go、Python的类型和运算符。

C语言

C语言类型主要有

1. 整型int
2. 浮点型float, double
3. 字符型char
4. 枚举类型enum
5. 数组int[]
6. 指针int*，包含函数指针int (* p)(int, int)
7. 结构体struct
8. 共用体Union，
9. 空类型void

C 语言支持的运算符，按优先级从高到低排列

1. () [] -> .，括号、数组下标、成员访问
2. ! ~ ++ -- - +，逻辑非、按位取反、自增、自减、取负、正号; * & (type) sizeof 解引用、取地址、类型转换、大小计算
3. * / % 乘法、除法、取模
4. + - 加法、减法
5. << >> 左移、右移
6. < <= > >= 小于、小于等于、大于、大于等于
7. == != 等于、不等于
8. & 按位与
9. ^ 按位异或
10. | 按位或
11. && 逻辑与
12. || 逻辑或
13. ?:
14. = += -= *= /= %= <<= >>= &= ^= 赋值及复合赋值
15. , 逗号

具体类型

整型，整型几乎支持所有运算，包括加减乘除算数运算，左移右移，大于等于比较运算，按位运算，逻辑运算(0表示false，其余整型表示true)

int  //基本整型，4字节

short int  // 短整型，2字节
short

long int  // 长整型，8字节。
long

unsigned int // 无符号整型，即正整数

int a = 10, b = 5;
printf("%x %x \n", a&b, a|b);
printf("%x %x \n", a&&b, a||b);
// 输出
0 f 
1 1

浮点型，浮点型不支持左移右移、按位运算。支持算术、逻辑、比较运算。

float  // 单精度浮点型，4字节。
double  // 双精度浮点型，8字节。

字符型，字符型实际等于8位无符号整型，整数支持的运算它都支持，运算等价于ACCSI码整数运算

char  // 字符型，1字节，

// 可以用整数定义char
char c = 68; 

枚举类型，C语言的枚举类型同样等价于整型，整数支持的运算它都支持

enum Color {RED, GREEN, BLUE};

#include <stdio.h>

enum Color {
    RED = 10,    
    GREEN,  
    BLUE 
};

int main() {
    enum Color Color1 = RED;
    enum Color Color2 = GREEN;
    printf("%d %d\n", Color1, Color2);
    printf("%d %d %d\n", Color1||Color2, Color1|Color2, Color1<<2);
    return 0;
}
// 输出
10 11
1 11 40

数组，数组本身支持[index]索引查询。另外，数组名相当于数组第一个元素的地址

int arr[10];

#include <stdio.h>

int main() {
    int arr1[5] = {1, 2, 3, 4, 5};
    int arr2[5] = {1, 2};
    int arr3[] = {1, 2, 3, 4, 5};

    printf("%d %d %d\n", arr1[0], arr2[1], arr3[2]);
    printf("%x %d %d\n", arr1, *arr1, *(arr1+2));
    return 0;
}
// 输出
1 2 3
2d941bd0 1 3

指针，指针本身是一个64位的整型。但不支持乘除、移位、按位运算。支持加减，逻辑运算。当然还支持*解引用运算

int *p;

结构体, 结构体支持使用.找到成员变量, 结构体指针则使用->

struct Person {
    char name[50];
    int age;
};

共用体，共享内存。共用体的size是size最大的成员变量的size。共用体运算同结构体。

union Data {
    int i;
    float f;
    char str[20];
};

void类型, 主要应用于void指针。void指针支持加减，逻辑运算。但不支持*解引用运算

void *ptr;

函数指针。函数指针除了支持指针运算，还支持使用()执行函数

int add(int a, int b) {
    return a + b;
}

int main() {
    // 定义函数指针，指向返回 int，接收两个 int 参数的函数
    int (*func_ptr)(int, int) = add;

    printf ("%d\n", *func_ptr);
    int result = func_ptr(10, 20);
    printf("%d\n", result);

    return 0;
}

// 输出
182948169
Result: 30

转型

C语言没有RTTI运行时类型信息, 因此C语言没有动态类型。如果函数参数需要传接口, C语言一般选择void*。所有指针先转为void*传给函数, 在函数内再转型回来。

C语言支持隐式转型和强制转型。强制转型和隐式转型都发生在编译期。

C语言运算符的两侧必须是相同类型，如果不是，就会尝试隐式转型。隐式转型规则，隐式转型主要针对整型和浮点型。隐式转型规则是size小的转为size大的，例如char转为int，int 转换为 unsigned/float, float 转换为 double

#include <stdio.h>
 
int main()
{
    int i = -2;
    unsigned int j = 1;
    printf ("%d\n", (i + j) >= 0 );
    return 0;
}

// 输出.原因，在执行(i + j)时，i转为unsigned int再和j加。0在这里转成了unsigned int
1

C语言的转型有很复杂，比如下面的例子。因此尽量保证类型的统一。,使用stdint.h库里的int32_t、uint32_t

int i = -2;
unsigned int j = 1;
printf ("%d\n", ((int)i + (int)j) >= 0 );  // 输出0
printf ("%d\n", ((int)i + j) >= 0 );  // 输出1

C++

C++兼容C语言的类型、操作符和转型，另外，还支持class定义、类重载运算符、动态类型和静态模版类型

1. class 定义, C++ 通过定义class，实现了面向对象（封装、继承、多态）。通过拷贝构造和移动构造, 合并了对象创建和初始化（相比C的struct, 配合new和delete关键字）。通过重载操作符,实现类型比较、赋值等功能。通过虚函数和虚函数表, 实现RTTI和动态类型。
2. 静态模版类型。C++模版大大增强了编译期类型能力, 除了虚函数调用和动态类型操作(如dynamic_cast, typeid(动态对象指针)), C++的类型信息和操作完全在编译期完成, 相比C语言无性能损失、无额外空间占用。

类型定义举例

#include <iostream>

class Point {
public:
    int x, y;

    Point(int a = 0, int b = 0) : x(a), y(b) {}

    // 重载赋值运算符
    bool operator==(const Point& other) {
        return x == other.y && x == other.y;
    }

    // 重载输出运算符
    friend std::ostream& operator<<(std::ostream& os, const Point& p) {
        os << "(" << p.x << ", " << p.y << ")";
        return os;
    }
    // 重载加法运算符
    Point operator+(const Point& other) {
        return Point(x + other.y, x + other.y);
    }
};

int main() {
    Point p1(3, 4);
    Point p2(1, 4);
    std::cout << p1 << std::endl;  // 输出：(3, 4)
    printf("%d\n", p1==p2);
    Point p3 = p1 + p2;
    std::cout << p3 << std::endl;
    return 0;
}

// 输出
(3, 4)
0
(7, 7)

C++ 支持bool型，bool型基本等同于1bit的整型，支持加减、移位等运算符，默认false(0)

C语言只能通过malloc申请进程堆内存，把地址给指针，并通过free释放内存。C++提供了new关键字在堆内存创建对象，new后面可以跟int, float, char, 数组等基本类型，也可以跟自定义类型。对应的释放关键字是delete。new相比malloc，可以通过调用构造函数实现对象初始化。

在值和指针类型之上，C++增加了引用类型。引用相当于const指针, 但简化了使用。初始化引用时即实现对原值的绑定，对引用的修改等价于对原值的修改。C++的指针和引用使用规则

1. 若某函数不创建对象，不具有对象的所有权，只修改对象，函数参数传裸指针
2. 若函数不修改对象，只读对象，传const&
3. 若函数创建对象同时具有对象的所有权, 使用std::unique_ptr和make_unique。若要转移所有权, 使用std::move(unique_ptr)。
4. 如果某对象只要创建一次, 需要被共享访问, 尤其是多线程共享， 对象无法预知何时不再被使用时, 使用std::shared_ptr和make_shared。

shared_ptr 例如

class DataProcessor {
public:
    void setData(std::shared_ptr<Data> data) { 
        m_data = data;  // 多个Processor共享同一份Data
    }
private:
    std::shared_ptr<Data> m_data;
};

std::shared_ptr<Data> data = std::make_shared<Data>();
DataProcessor processor1, processor2;
processor1.setData(data);
processor2.setData(data);
// 当processor1和processor2都析构后，data自动释放

C++提供右值引用，函数的右值引用参数表示要接收对象的所有权。例如某函数执行std::move(unique_ptr)将所有权转移, 函数参数传右值引用获得所有权。右值引用只能在所有权转移时使用，常见的是赋值(旧对象成员的所有权转移到新建对象), 容器构造(对象所有权从本函数转移到容器)。std::move是将左值转为右值, 目的是转移左值的所有权。

在C语言的隐式和显示转换之上，C++增加了四个显示类型转换

1. static_cast，编译期间类型转换，基于类型信息
2. dynamic_cast，运行时接口向下转型, 接口指针转为对象类型指针
3. const_cast，将const* 指针转为普通指针, 从而可以通过指针修改对象。 编译期行为
4. reinterpret_cast，等价于运行时指针强制转换

对象创建和初始化

运行期局部变量在栈上创建，全局变量和静态变量在静态区创建，new 产生的变量在堆上创建。栈变量的作用域等于函数作用域，全局变量和静态变量的作用域是进程执行期，new产生的堆变量可能逃逸，需要用户自行管理生命周期和内存释放。

确定所有权是管理堆变量生命周期的推荐方式，具有对象所有权的负责创建和析构堆对象，而其他的只有对象的读写权限，不负责生命周期管理。难以明确所有权的，使用引用计数管理，也就是shared_ptr。

std::weak_ptr弱引用，不增加引用计数；​必须通过lock()方法获取临时的shared_ptr才能访问对象。可以作为观察者, 通过尝试lock判断对象是否存在，然后访问对象。weak_ptr可用来处理循环引用，也就是如果想父对象引用子对象，子对象也引用父对象，就会造成循环引用，可以通过父对象通过weak_ptr来引用子对象, 当调用子对象时, 通过lock()判断子对象是否存在。

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
    std::cout << *ptr1 << std::endl;

    // std::unique_ptr<int> ptr2 = ptr1;                  // 错误：不能复制
    std::unique_ptr<int> ptr2 = std::move(ptr1);          // 转移所有权
    std::cout << *ptr2 << std::endl;

    std::shared_ptr<int> sp = std::make_shared<int>(30);
    std::weak_ptr<int> wp = sp;                          // 创建weak_ptr

    std::cout << "Use count: " << sp.use_count() << std::endl;

    if (auto sp2 = wp.lock()) {                           // 检weak_ptr检查资源是否有效
        std::cout << *sp2 << std::endl;
    }

    sp.reset();                                           // 释放资源
    if (wp.lock() == nullptr) {
        std::cout << "Resource no longer exists" << std::endl;
    }
}

// 输出
10
Use count: 1
30
Resource no longer exists

初始化

1. 局部变量，未初始化的为不确定值（即垃圾值）
2. 静态变量，自动初始化为 0 或 NULL（指针类型），静态变量初始化只执行一次
3. 全局变量，自动初始化为 0 或 NULL

C++类变量规则

1. 普通成员变量, 必须在构造函数中显式初始化，未初始化的普通成员变量值是未定义的（包含随机值）
2. 静态成员变量是类级别的，需要在类外初始化，自动初始化为 0 或 NULL（指针类型），静态变量初始化只执行一次
3. const变量必须在构造函数的初始化列表中初始化，初始化后不可修改
4. C++11 允许为 非静态成员变量 提供类内初始值。静态成员变量仍需在类外初始化。
5. 成员变量按 声明的顺序 初始化，与初始化列表的顺序无关。

修饰符

static, 静态变量。一个编译单元(.cpp)文件一个静态变量, 静态变量不可跨编译单元共享，因此不能作为全局变量。全局变量（外部变量）跨.cpp文件，链接多文件共享；

1. 静态函数的定义一般放到头文件里, 如果放到.cpp文件，头文件被其他.cpp引用时, 由于静态函数无法变链接，其他.cpp文件会发生函数链接错误。

const，表示常量，不可改变量。

1. 修饰函数表示函数不可修改类成员变量, 可通过mutable关键字修改。

volatile，告诉编译器不要对该变量进行优化。常用于 多线程编程 或 硬件编程，避免编译器对变量的访问进行优化。

extern，声明变量或函数在其他文件中定义。它不分配存储空间，只是告诉编译器该变量在其他地方定义过。链接时全局变量在多个文件共享。

mutable 用来修饰类中的成员变量，即使类的对象是 const 类型，成员变量仍然可以被修改。

C++ 编译类型推导

C++ 编译期静态类型推导

C++ 14 允许 Lambda 参数使用 auto 类型推导

auto lambda = [](auto x, auto y) { return x + y; };
int a = lambda(3, 5);     // 8
double b = lambda(2.5, 3); // 5.5

支持返回类型推导, decltype(auto)

// 返回类型自动推导
auto add(int a, int b) { return a + b; }

// 保留引用语义
int x = 10;
decltype(auto) ref = (x); // int& 类型

constexpr，修饰函数和表达式，尝试在编译期就给出计算结果

class Circle {
public:
    constexpr Circle(double r) : radius(r) {}
    constexpr double area() const { return radius * radius * 3.1415; }
private:
    double radius;
};

constexpr Circle c(2.0);
static_assert(c.area() > 12.0, "");

结构化绑定

std::pair<int, std::string> data{42, "Alice"};
auto [id, name] = data; // id=42, name="Alice"

C++ 模版编程

既然讲到类型, 就离不开C++模版编程, 编译期类型

::value 和::type

::value 和 ::type 是两种常见的成员访问形式，用于从 ​类型特性（Type Traits）​ 或 ​元函数（Metafunctions）​ 中提取信息

::value 用于从 ​类型特性 中提取一个 ​编译时常量值​（通常是布尔值），表示某种类型或条件的静态属性。

• 类型检查：检查类型是否符合特定条件（如是否是整数、指针、类类型等）。
• ​数值提取：获取类型关联的静态数值（如数组维度、对齐值等）。

#include <type_traits>

// 检查 T 是否是整数类型
static_assert(std::is_integral<int>::value, "int 是整型");  // 通过

// 获取类型的对齐值
constexpr size_t align = std::alignment_of<double>::value;  // 通常是 8

::type 用于从 ​元函数 中提取一个 ​类型，常用于类型转换或条件编译。

• ​类型转换：生成与输入类型相关的新类型（如移除引用、添加常量等）。
• ​条件分支：通过 std::enable_if 控制模板的启用或禁用。

#include <type_traits>

// 移除类型的引用
using NakedType = std::remove_reference<int&>::type;  // NakedType = int

// 条件启用模板
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
foo(T value) { return value * 2; }

在模板中访问 ​依赖名称（Dependent Name）​ 的 ::type ​必须 使用 typename 关键字，以明确告知编译器这是一个类型而非静态成员。

template <typename T>
void func() {
    // 正确：typename 告诉编译器 std::remove_reference<T>::type 是类型
    using NakedT = typename std::remove_reference<T>::type;

    // 错误：缺少 typename，编译器认为 ::type 是静态成员
    using WrongT = std::remove_reference<T>::type;
}

模版匹配规则

类模板的匹配优先级为：

1. ​完全特化版本​（全参数指定）。
2. ​部分特化版本​（部分参数特化）。
3. ​主模板。

// 主模板
template <typename T, typename U>
struct MyClass { /* 通用实现 */ };

// 部分特化：当 U 是 T 的指针时
template <typename T, typename U>
struct MyClass<T, U*> { /* 指针特化 */ };

// 完全特化：当 T=int, U=double 时
template <>
struct MyClass<int, double> { /* 完全特化 */ };

int main() {
    MyClass<int, double> a;    // 使用完全特化
    MyClass<float, int*> b;    // 使用部分特化
    MyClass<char, bool> c;     // 使用主模板
}

函数匹配规则

1. ​非模板函数​（如果有精确匹配）。
2. ​最特化的模板函数​（通过参数推导和约束判断）。
3. ​通用模板函数。

// 通用模板
template <typename T>
void foo(T) { std::cout << "通用模板\n"; }

// 特化版本（对指针类型）
template <typename T>
void foo(T*) { std::cout << "指针特化\n"; }

// 非模板函数
void foo(int*) { std::cout << "非模板函数\n"; }

int main() {
    int* p = nullptr;
    foo(p);  // 输出：非模板函数
    foo(42); // 输出：通用模板
}

C++20 引入 ​概念（Concepts）​，允许更直观地约束模板参数，改变匹配逻辑：

template <typename T>
requires std::integral<T>  // 约束 T 为整数类型
void process(T value) { /* 整数处理 */ }

template <typename T>
requires std::floating_point<T>  // 约束 T 为浮点类型
void process(T value) { /* 浮点处理 */ }

int main() {
    process(42);    // 匹配整数版本
    process(3.14);  // 匹配浮点版本
}

SFINAE（替换失败并非错误

SFINAE（替换失败并非错误）是C++模板元编程中的核心原则，其核心思想是：​在模板实例化过程中，如果替换（Substitution）模板参数导致无效代码，编译器不会报错，而是将该候选从重载集中剔除，继续寻找其他合法候选。

• 当调用一个函数或使用类模板时，编译器会尝试推导模板参数，并生成具体的代码（实例化）。
• 如果替换模板参数后生成的代码无效​（例如访问不存在的成员、类型不兼容），编译器不会抛出错误，而是静默忽略该候选，继续尝试其他可能的重载或模板。
• 若替换成功但实例化后的代码在函数体内报错​（如无效操作），编译器仍会报错。

可以直接设置根据不同类型提供不同的实现

#include <type_traits>

// 仅对整数类型有效
template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
process(T value) {
    // 整数处理逻辑
}

// 仅对浮点类型有效
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
process(T value) {
    // 浮点处理逻辑
}

int main() {
    process(42);    // 调用整数版本
    process(3.14);  // 调用浮点版本
    // process("hello");  // 无匹配候选，编译报错
}

模版特化

template <typename T, typename Enable = void>
class Container;  // 主模板未定义

// 特化：仅支持可迭代类型
template <typename T>
class Container<T, typename std::enable_if<has_iterator<T>::value>::type> {
    // 实现...
};

std::enable_if

std::enable_if的作用是条件编译，

基于 SFINAE（Substitution Failure Is Not An Error）原则。它允许根据类型特性或编译时条件启用或禁用特定的函数重载或模板特化。

std::enable_if<Condition, T>::type：如果 Condition 为 true，则 std::enable_if 的 type 成员是 T；否则，std::enable_if 没有 type 成员，这会导致模板实例化失败。

#include <type_traits>

// 仅对整数类型有效
template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
foo(T value) {
    // 实现整数处理
}

// 仅对浮点类型有效
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
foo(T value) {
    // 实现浮点处理
}

编译时和运行时的一个优势是，编译期能知道类型信息。
C++ type_traits提供std::is_integral 是用于在编译时检查某个类型是否为 ​整型（整数类型）​。

以下类型std::is_integral返回tree

​有符号整型：signed char, short, int, long, long long
​无符号整型：unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long

std::is_floating_point：检查浮点类型

std::is_arithmetic：检查算术类型（整型 + 浮点型）。

std::is_signed：检查类型是否有符号。

模版实例化失败

1. 类型不满足模版约束

template <typename T>
void print(T value) {
    value.print(); // 若 T 无 print() 成员函数，实例化失败
}

struct Data { /* 无 print() 方法 */ };

int main() {
    Data d;
    print(d); // 错误：'Data' 没有成员 'print'
}

使用 static_assert 提前验证类型：

template <typename T>
void print(T value) {
    static_assert(has_print_method<T>, "T must have print()");
    value.print();
}

使用 ​C++20 概念（Concepts）​ 约束模板参数：

template <typename T>
requires requires(T t) { t.print(); }
void print(T value) {
    value.print();
}

2. 模版参数不匹配

template <typename T, int N>
class Array { /* ... */ };

int main() {
    Array<std::string, -5> arr; // 错误：非类型模板参数 N 为负数
}

3. 依赖名称未正确解析

template <typename T>
void process() {
    T::value_type data; // 若 T 无 value_type 成员，实例化失败
}

struct MyType { /* 无 value_type 定义 */ };

int main() {
    process<MyType>(); // 错误：'value_type' 未声明
}

使用 typename 明确依赖名称

typename T::value_type data;

模版头文件

JAVA

JAVA所有类型和函数都是写到类中，类名和文件名相同。main函数是在主类中定义的static函数。JAVA没有全局变量，因为所有变量都是在类中。

JAVA基本类型变量存储在栈中，引用类型变量存储在堆中。引用类型变量使用new创建，jvm的垃圾回收模块负责对象回收。JAVA的变量都会初始化，不会有随机值。

JAVA类最大的特点是动态加载（按需加载），类静态变量和静态模块随着类加载而初始化和执行，如果某类无须被加载，则不会执行该类中的静态变量和静态块。**

1. 类的加载通常是在访问类的静态成员（如静态字段、静态方法）或创建类的实例时触发的。
2. 类加载器会在需要时加载类，不会提前加载。

JAVA运算符基本和C++一致，除了

1. 取消指针和引用相关运算符，包括*, ->, &

JAVA类型默认值是0, JAVA的boolean型不再和整型互通

基本数据类型, 存储值本身, 参数会选择传值本身

数据类型	存储大小（字节）
byte	1
short	2
int	    4
long	8

float	4
double	8
char	2 (unicode范围)
boolean	依赖 JVM 实现

引用类型, 存储对象的引用。引用类型默认值是null, 参数会选择传引用

// 类
class Dog {
    String name;
    int age;
}

// 接口
interface Animal {
    void sound();
}

// 数组
int[] numbers = {1, 2, 3, 4};

// 枚举
enum Color {
    RED, GREEN, BLUE
}

JAVA提供包装类型为基本数据类型提供引用, 默认值是null

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long	
float	Float
double	Double	
char	Character	
boolean	Boolean

public class Main {
   public static void main(String[] args) {
      Integer x = 100;
      Integer y = 200;
      Integer z = null;
      System.out.println(x.compareTo(y));
      System.out.println(x.equals(y));
      System.out.println(z==null);
   }
}
// 输出
-1
false
true

JAVA包装类型的常用函数

Integer.valueOf(int i) // 返回表示基本类型的Integer对象
Integer x = Integer.valueOf(100);

Integer x = 10;
int y = x.intValue(); // 返回包装对象的 int 值, 同样还有doubleValue等

Integer x = 10;
Integer y = 20;
System.out.println(x.compareTo(y)); // 比较

boolean equals(Object obj)  // 比较两个对象的值是否相等。

JAVA 通过(type)实现显式转换

class Animal {}
class Dog extends Animal {}
Dog dog = new Dog();
Animal animal = dog;  // 子类对象自动转换为父类引用

Animal animal = new Dog();
Dog dog = (Dog) animal;  // 强制将父类引用转换为子类类型, 向下转型

if (animal instanceof Dog) {  // instanceof 检查对象是否是某个类型
    Dog dog = (Dog) animal;
}

JAVA中，所有类都直接或间接继承自 Object 类。Object类提供的成员方法, 也就是任何都有以下方法，也可以重载以下方法

public boolean equals(Object obj)

public native int hashCode()

protected native Object clone() throws CloneNotSupportedException

public String toString()

变量访问控制和修饰

Java中，如果需要使用其他包中的类，必须利用import显式地导入它们。import 语句只能导入类，而不能导入方法、字段

Java 的访问控制包括四种权限：

1. public：类或成员可以被任何类访问。
2. protected：类或成员可以被同一个包中的类或子类访问。
3. default（无修饰符）：类或成员只能被同一个包中的类访问。
4. private：类或成员只能在当前类内部访问。

包名通常采用 小写字母，以避免与类名的命名冲突。

包名通常使用 反向域名，例如 com.example.myapp。这种做法避免了不同公司或组织的包名冲突。

除了类，java的变量和函数也有访问修饰符

// public：变量可以被任何其他类访问，无论它们在同一包中还是不同的包中。
public int x;
// protected：变量可以被同一包中的类或继承自该类的子类访问
protected int y;
// default（无修饰符）：变量的默认访问权限是包级访问（包私有）。
int z; 
// private：变量只能在当前类内部访问
private int a;

static，声明为 static 为静态变量，属于类。

final，声明为 final 的变量是常量，初始化之后不能再修改。final修饰函数表示该函数不能被重写

volatile 变量会告诉 Java 虚拟机（JVM）每次访问该变量时都要从内存中读取，而不是从缓存中读取。通常用于多线程编程中，确保变量的可见性。

synchronized 主要用于方法，确保同一时刻只有一个线程能执行该方法。

native 关键字用于声明本地方法，这些方法通过 JNI（Java Native Interface）调用非 Java 语言（如 C、C++）编写的代码。native通常用于方法声明。

反射

由于java是动态加载类, 这让java 具有利用反射动态加载类, 这催生了spring ioc框架。如果要根据字符串的内容匹配对应的类/函数，C++和go都要维护一个(string->函数)的map，但java可以直接通过类名来动态加载类。java利用反射动态加载类分两步1. 获取class类 2.加载class类

获取class对象

// 类名.class
Class<String> stringClass = String.class;
// 对象.getClass()
String str = "Hello";
Class<?> strClass = str.getClass();
// ​​Class.forName("全限定类名")
Class<?> clazz = Class.forName("java.lang.String");

利用反射调用方法，修改变量

Method method = clazz.getDeclaredMethod("methodName", parameterTypes);
method.setAccessible(true); // 访问私有方法
Object result = method.invoke(obj, args);

Field field = clazz.getDeclaredField("fieldName");
field.setAccessible(true); // 访问私有字段
field.set(obj, value);     // 设置字段值
Object value = field.get(obj); // 获取字段值

Go

Golang的运算符和C++的类似，区别主要是指针类型。Go指针类型不支持算术运算，只支持引用和解引用运算。Go指针零值是nil, 获取成员变量用.

golang可以使用 new 分配内存，并返回指针。对切片、map、channel、interface，golang可以使用make函数分配内存和初始化。

golang可以使用var xxx type声明变量，var xxx = value或xxx := value声明变量并赋值

当变量的生命周期仅限于当前函数时（不用new构造的对象），Go 会尽量将其分配到栈上。堆内存，通常分配给引用类型(slice, map, channel, pointer)或者使用new创建变量且变量的地址被传递到函数外部。

Go 变量的访问控制。全局定义的小写字母只能包内访问，大写字母可以跨包访问。访问其他包的变量需要先import。golang 提供struct组合代替继承（C++继承内部的实现就是组合）。

1. 匿名嵌入的结构体方法会被​​提升（Promote）​​到外层结构体。
2. 若外层结构体定义了同名方法，会​​覆盖​​嵌入结构体的方法

golang支持的类型

// 以下是值类型
bool	1
byte	1
int32, uint32	4
int64, uint64	8
float32	4
float64 8
array
struct
string（golang字符串不可修改，若想修改, 需要转成[]byte

Go中只有强制类型转换

var a int = 42
var b int64 = int64(a)  // 必须显式转换
var c float64 = float64(a)

golang 可以通过直接赋值将struct转为接口, 同时通过类型断言将接口转换为具体类型（动态类型）。Golang中，所有struct都实现interface{}空接口

package main

import "fmt"

func main() {
    var i interface{} = 42 // 接口存储了具体类型 int

    // 类型断言
    value, ok := i.(int)
    if ok {
        fmt.Println("Converted value:", value) // 输出：Converted value: 42
    } else {
        fmt.Println("Conversion failed")
    }
}

反射

golang 反射的目的是运行时获取对象的类型信息。一方面，golang不支持模版编程, 对象的静态类型信息也需要运行时获得（C++编译期就可以获得静态类型信息）。另一方面，动态类型信息同样需要运行时获得。(golang的这个反射不支持根据字符串动态获取对象, 和C++ 的动态类型差不多)

golang 的struct 统一实现了interface{}。interface{}包含了类型信息和对象指针。因此golang静态类型和动态类型信息都是借助interface获得。

// 获取类型信息
x := 3.14
t := reflect.TypeOf(x)  // t.Kind() 返回 reflect.Float64
fmt.Println(t.Name())   // 输出: float64

// 获取值
v := reflect.ValueOf(x)
fmt.Println(v.Float())  // 输出: 3.14

// 修改值
p := reflect.ValueOf(&x)
v := p.Elem()           // 获取指针指向的值
v.SetFloat(6.28)        // 修改原变量 x 的值
fmt.Println(x)          // 输出: 6.28

golang的多态依赖于interface{}，包括静态多态。例如json序列化提供的统一接口就是interface{}

func Marshal(v interface{}) ([]byte, error)
func Unmarshal(data []byte, v interface{}) error

Python

python类型比较特别, 把类型分为两类，可变类型和不可变类型。

如果修改一个不可变对象，Python 将会创建一个新的对象。

1. 不可变类型包括整数（int）、浮点数（float）、字符串（str）、元组（tuple）等。
2. 可变类型的值可以原地修改。可变对象包括列表（list）、字典（dict）、集合（set）等, class定义的类默认是可变类型

不可变类型函数参数可以认为是值传递，可变类型函数参数可以认为是引用传递

Python变量的类型是在运行时决定的，不需要显式声明。Python 不允许隐式类型转换。

def modify(x):
    x = 10
a = 5
modify(a)
print(a)  
# 输出：5，a的值未变

def modify(lst):
    lst.append(4)
nums = [1, 2, 3]
modify(nums)
print(nums)  
# 输出：[1, 2, 3, 4]

Python的类型如下

类型	描述
int	整型 支持任意大小
float	浮点数
complex	复数，形式为 a + bj
bool	布尔值，True 和 False

str	Unicode 文本数据
NoneType	None

list	可变的有序集合  [1, 2, 3]
tuple	不可变的有序集合  (1, 2, 3)
range	表示数字范围	range(5)

set	可变集合，支持哈希操作	{1, 2, 3}
dict	可变键值对集合	{"a": 1, "b": 2}

iterator	迭代器	iter([1, 2, 3])

类型检查和转换

print(type(42))  # <class 'int'>
print(isinstance(42, int))  # True

x = int(3.5)   # 3
y = float(3)   # 3.0

lst = list((1, 2, 3))       # [1, 2, 3]
tpl = tuple([1, 2, 3])      # (1, 2, 3)
st = set([1, 2, 2, 3])      # {1, 2, 3}

Python局部变量区域可以访问全局变量，但无法修改全局变量

x = 10
def my_function():
    print(x)

my_function()

# 执行结果
10

x = 10
def my_function():
    # 修改全局变量需要在局部变量区加 global x
    print(x)
    x=20

my_function()

# 执行结果
UnboundLocalError: local variable 'x' referenced before assignment

if __name__ == "__main__"函数里可以正常修改全局变量（其余函数不行

x = 10
def my_function():
    print(x)

if __name__ == "__main__":
    x=20
    my_function()

# 输出
20

python无法对变量进行修饰，但可以通过@注解对函数进行修饰。例如@staticmethod，@classmethod

常见@注解

@classmethod 装饰器定义类方法，允许方法访问类本身，而不是实例。
@staticmethod 装饰器定义静态方法，静态方法不能访问实例和类本身
@property 用于将类的方法变成一个只读属性

python的操作符按照优先级排序为

1. 小括号()
2. 索引运算符 x[i] 或 x[i1: i2 [:i3]]
3. 属性访问 x.attribute
4. 乘方 **
5. 按位取反 ~
6. 符号运算符 +（正号）、-（负号）
7. 乘除*、/、//、%
8. 加减+、-
9. 位移>>、<<
10. 按位与 &
11. 按位异或^
12. 按位或|
13. 比较运算符==、!=、>、>=、<、<=
14. is 运算符is、is not
15. in 运算符 in、not in
16. 逻辑非 not
17. 逻辑与 and
18. 逻辑或 or
19. 逗号exp1, exp2

类似JAVA，在python中，object是所有类的基类。object类的方法

__init__(self)	初始化方法，用于对象创建后初始化属性。
__del__(self)	析构方法，用于对象销毁时清理资源。
__str__(self)	返回对象的字符串表示，通常用于打印或转换为字符串时调用。
__repr__(self)	返回对象的官方表示，通常用于调试。
__eq__(self, other)	比较对象是否相等，默认比较引用地址，可重写实现值比较。
__ne__(self, other)	比较对象是否不等，默认基于 __eq__ 结果。
__hash__(self)	返回对象的哈希值，用于哈希表等数据结构。
__getattribute__(self, name)	获取对象属性的值，所有属性访问都会调用此方法，可重写以自定义行为。
__setattr__(self, name, value)	设置对象属性的值。
__delattr__(self, name)	删除对象属性。
__dir__(self)	返回对象的属性和方法列表，供 dir() 函数使用。
__class__	返回对象的类。