C++与Java学习对比指南

当我们同时学习 C++ 和 Java 时，语法差异是导致混淆的主要原因。以下是两者的详细语法对比，包含差异和共同点并且按学习优先级排列，帮助我们在编码时快速区分。

01. 基础程序结构

差异

C++：必须包含头文件

#include <iostream>
using namespace std; // 命名空间声明

// 可以存在全局函数和变量
void globalFunc() { 
    cout << "Hello C++" << endl; 
}

int main() {
    globalFunc();
    return 0;
}

特点 
1.支持全局函数和全局变量  
2.需要手动包含头文件（如 <iostream>）  
3.可选使用 using namespace 简化代码  

Java：所有代码必须属于类

public class Main {
    // 无法定义全局函数，需用静态方法替代
    static void globalMethod() {
        System.out.println("Hello Java");
    }
    public static void main(String[] args) {
        globalMethod();
    }
}

特点

1.所有代码必须写在类内部 
2.入口函数为

public static void main(String[] args)  

3.无全局函数，需用 static方法模拟  

共同点

1.代码块结构：两者均使用 {} 定义代码块，; 结束语句。

2.基本控制结构：if-else、for、while 等语法完全一致。

// C++ 的 for 循环
for (int i=0; i<5; i++) { /* ... */ }

// Java 的 for 循环
for (int i=0; i<5; i++) { /* ... */ }

02. 变量与类型

差异

C++

1.支持指针和引用  
2.基本类型（int、double等）直接存储值  
3.const表示不可修改的常量  

int a = 10;             // 基本类型直接存储值
int* ptr = &a;          // 指针操作
int& ref = a;           // 引用（别名）
const int B = 20;       // 常量（编译期确定）

Java

1.引用类型（如 String）指向堆内存对象  
2.基本类型（int）存储在栈，包装类（Integer）在堆  
3.final 修饰不可变变量（类似 const）  

int a = 10;             // 基本类型直接存储值
Integer obj = 20;       // 包装类对象（堆内存）
// 无指针，只有引用（类似 C++ 的指针）
String s = "Java";      // 引用类型（自动指向对象）
final int B = 20;       // 常量（类似 C++ 的 const）

共同点

1.基本数据类型：int、double、char、boolean（Java）/bool（C++）等类型含义一致。

2.类型转换：均支持显式强制类型转换。

// C++
double x = 3.14;
int y = (int)x; // 显式转换

// Java
double x = 3.14;
int y = (int)x; // 显式转换

03. 函数/方法定义

差异

 C++
1.函数可以独立于类存在  
2.参数传递支持值传递、引用传递（void func(int& x)）
 

// 函数可以独立存在
int add(int a, int b) { return a + b; }

class MyClass {
public:
    // 成员函数
    void print() { cout << "C++ Method" << endl; }
};

Java

1.所有方法必须定义在类内  
2.参数传递只有值传递（对象引用按值传递）
 

class MyClass {
    // 所有方法必须属于类
    static int add(int a, int b) { return a + b; } // 静态方法
    
    void print() { 
        System.out.println("Java Method"); 
    }
}

共同点

1.函数/方法签名：返回值类型、参数列表的语法完全一致。

2.递归支持：均支持递归调用。

// C++ 递归计算阶乘
int factorial(int n) { return (n <= 1) ? 1 : n * factorial(n-1); }

// Java 递归计算阶乘
int factorial(int n) { return (n <= 1) ? 1 : n * factorial(n-1); }

04. 类与对象

差异

C++

1.成员默认访问权限为 private  
2.构造函数使用初始化列表（: name(n)）  
3.对象可以创建在栈或堆（Dog* pDog = new Dog("Max");）
 

class Dog {
private:
    string name;        // 默认 private
public:
    Dog(string n) : name(n) {}  // 初始化列表
    void bark() { cout << name << ": Woof!" << endl; }
};
// 使用
Dog myDog("Buddy");
myDog.bark();

Java
1.成员默认访问权限为包内可见（非 private）
2.所有对象必须通过 new 在堆上创建  
3.构造函数名称必须与类名完全相同

class Dog {
    private String name;    // 必须显式声明 private
    public Dog(String n) {  // 构造函数无返回值
        name = n;
    }
    void bark() { 
        System.out.println(name + ": Woof!"); 
    }
}
// 使用
Dog myDog = new Dog("Buddy");
myDog.bark();

共同点

1.面向对象核心概念：均支持类、对象、封装、继承、多态。

2.构造函数：均使用与类名相同的构造函数初始化对象。

3.静态成员：均支持 static 修饰的静态变量和方法。

// C++ 静态成员
class Counter {
    static int count; // 声明
};
int Counter::count = 0; // 类外初始化

05. 继承与多态

差异

C++

1.支持多继承（class D : public B, public C）  
2.使用 virtual和 override实现多态  
3.析构函数通常需要声明为 virtual

class Animal {
public:
    virtual void sound() { cout << "Some sound" << endl; }
};
class Cat : public Animal { // 公有继承
public:
    void sound() override { cout << "Meow" << endl; } // 显式 override
};

// 使用
Animal* a = new Cat();
a->sound(); // 输出 Meow（多态）

Java
1.单继承类，但可多实现接口（implements）  
2.所有非静态方法默认支持多态（无需 `virtual` 关键字）  
3.使用 @Override 注解（可选但推荐）  

class Animal {
    public void sound() { System.out.println("Some sound"); }
}
class Cat extends Animal {  // 单继承
    @Override
    public void sound() { System.out.println("Meow"); }
}

// 使用
Animal a = new Cat();
a.sound(); // 输出 Meow

共同点

多态实现：均通过基类引用指向子类对象实现运行时多态。

// C++
Animal* a = new Cat();
a->sound(); // 调用 Cat 的 sound()

// Java
Animal a = new Cat();
a.sound(); // 调用 Cat 的 sound()

06. 泛型与模板

差异

C++（模板）
1.模板在编译时生成具体类型代码  
2.支持更复杂的元编程  
 

template <typename T>
class Box {
    T content;
public:
    void set(T t) { content = t; }
    T get() { return content; }
};
// 使用
Box<int> intBox;  // 编译时实例化具体类型

Java（泛型）
 1.泛型基于类型擦除实现（编译后变为 Object）  
 2.不支持基本类型泛型（需用 Integer 替代 int）

lass Box<T> {
    private T content;
    public void set(T t) { content = t; }
    public T get() { return content; }
}

// 使用
Box<Integer> intBox = new Box<>(); // 类型擦除（运行时无类型信息）

共同点：

提供类型安全的容器和算法

07. 异常处理

差异

 C++

1.不强制处理异常（可能导致程序崩溃）  
2.可抛出任意类型（如 throw 42;）

try {
    throw runtime_error("C++ Error");
} catch (const runtime_error& e) {
    cout << e.what() << endl;
} catch (...) { // 捕获所有异常
    cout << "Unknown error" << endl;
}

Java
1.受检异常（Checked Exceptions）必须被捕获或声明  
2.只能抛出 Throwable子类对象  
 

try {
    throw new Exception("Java Error");
} catch (Exception e) { // 必须明确捕获类型
    System.out.println(e.getMessage());
} finally {
    System.out.println("Cleanup");
}

共同点

try-catch-finally 结构：语法结构完全一致。

// C++
try { throw "Error"; }
catch (const char* e) { /* 处理 */ }

// Java
try { throw new Exception("Error"); }
catch (Exception e) { /* 处理 */ }
finally { /* 清理 */ }

08.内存管理

差异

C++：手动管理（new/delete），允许指针直接操作内存。

Java：自动垃圾回收（GC），无指针，引用类型自动管理。

共同点

堆与栈的分离：均区分栈内存（存储基本类型和方法调用栈）和堆内存（存储对象）。

09. 其他关键语法区别

通过对比语法细节，我们可以更清晰地理解两门语言的设计哲学，减少编码时的混淆。