Java和C++的對照

本條目為Java語言和C++語言之間的比較。

## 設計目標

C++和Java語言之間的不同可以追溯到它們各自的傳統，它們有著不同的設計目標。

- C++ 被設計成主要用在系統性應用程式設計上的語言，對C語言進行了擴展。基於C語言這個為執行效率設計的過程式程式設計語言，C++添加了對這些特性的支持：靜態類型的面向對象程序設計的支持、異常處理、RAII以及泛型。另外它還添加了一個包含泛型容器和算法的C++庫函數。
- Java 最初被設計用來支持網路計算。它依賴一個虛擬機來保證安全和可移植性。Java包含一個可擴展的庫以提供一個完整的下層平台抽象。Java是一種靜態面向對象語言，它使用的語法和C++類似，但並不與之兼容。為了使更多的人到使用更易用的語言，它進行了全新的設計。

不同的開發目標導致C++和Java這兩種語言的不同的規則以及設計上的平衡點不同。如下列出不同點：

C++｜Java

除了一些比較少見的情況之外和C語言相容｜沒有對任何之前的語言向前相容。但在語法上受C/C++的影響很大

一次編寫多處編譯｜一次編寫多處運行

允許過程式程式設計、面向對象程序設計、泛型程序設計、函數式程序設計｜必須使用面向對象的程式設計方式

允許直接調用原生的系統庫｜要通過JNI調用，或者JNA

能直接使用底層系統接口｜在一個保護模式下的虛擬機中運行

只提供物件的類型和類型名｜是反射的，允許元程式設計和運行時的動態生成代碼

有多種二進制相容標準（例如：微軟和Itanium/GNU）｜一種二進制相容標準，允許運行時庫的正確性檢查

可選的自動邊界檢查.（例如：vector 和 string 這兩個容器的 at 方法）｜一般都有做邊界檢查。HotSpot (java)（Sun 的虛擬機實現）可以去掉邊界檢查

支持原生的無符號數學運算｜不支持原生的無符號數學運算

對所有的數字類型有標準的範圍限制，但字節長度是跟實現相關的。標準化的類型可以用 typdef 定義 (uint8_t, ..., uintptr_t)｜在所有平台上對所有的基本類型都有標準的範圍限制和字節長度

支持指針，引用，傳值調用｜基本類型總是使用傳值調用。物件以可以為空的引用的方式傳遞（相當於在C++里使用指向 `class` 或者 `struct` 參數的指標）。

顯式的記憶體管理，但有第三方的框架可以提供垃圾搜集的支持。支持析搆函式。｜自動垃圾搜集（可以手動觸發）。沒有析構函式的概念，對 `finalize()` 的使用是不推薦的

支持類class，結構struct，聯合union，可以在堆疊或者堆里為它們動態分配記憶體｜只支持類別，只在堆中為物件分配記憶體。Java SE 6在棧為一些物件分配記憶體的使用了逃逸分析的優化方法

允許顯示的覆蓋（也叫重寫）類型｜嚴格的類型安全，除了變寬的類型轉換。Java 1.5開始支持自動類型包裝和解包裝(Autoboxing/Unboxing)

C++函式庫包括：語言支持，診斷工具，常用工具，字串，本地化，容器，演算法，迭代器，數值，輸入/輸出，C函式庫。Boost庫提供了更多的功能，包括執行緒和網路I/O。使用者必須在一大堆（大部分互相不相容）第三方GUI或者其他功能庫中進行選擇｜函式庫在每次 Java 發布新版本的時候都會更新並增強功能。1.6版本支持：本地化，日誌系統，容器和迭代器，演算法，GUI 程式設計（但沒有用到系統的GUI），圖形，多執行緒，網路，平台安全，自省機制，動態類別加載，阻塞和非阻塞的I/O，對於XML、XSLT、MIDI也提供了相關接口或者支持類別，資料庫，命名服務（例如 LDAP），密碼學，安全服務（例如 Kerberos），列印服務，WEB 服務。SWT 提供了一個系統相關的GUI的抽象

大部分運算符可以運算符重載｜運算子的意義一般來說是不可變的，例外是`+`和`+=`運算子被字串多載了

完全的多重繼承，包括虛擬繼承｜類別只允許單繼承，需要多繼承的情況要使用接口

支持編譯期模板｜Java中的泛型被用來達到和C++模板類似的效果，但由於類型消除它們不能在編譯期間從代碼被編譯成字節碼

支持函式指標，函式物件，lambda(C++11)和接口｜沒有函式指標機制。替代的概念是接口，Adapter 和 Listener也是被廣泛使用的

沒有標準的代碼內嵌文檔機制。不過有第三方的軟體（例如 Doxygen）｜Javadoc 標準文檔生成系統

`const` 關鍵字用來定義不可改變的常量和成員函式｜`final` 提供了一個限制版本的 `const`，等價於 type、`const` 的物件指標或者 `const`的基本類型數據。沒有 `const` 成員函式，也沒有`const` type、指標的等價物

支持 `goto` 語句｜支持循環標簽(label)和語句塊

源代碼可以寫成平台無關的（可以被 Windows、BSD、Linux、Mac OS X、Solaris 等編譯，不用修改），也可以寫成利用平台特有的特性。通常被編譯成原生的機器碼｜被編譯成Java虛擬機的字節碼。和Java平台相關，但是源代碼一般來說是不依賴作業系統特有的特性的

C++ 是一門強大的語言，設計用在系統程式設計方面。Java語言是設計成簡單易用易學習，並有一個強大的跨平台的庫。Java函式庫對一個函式庫來說相當的大。但Java並不會提供所在平台的所有特性和接口。C++函式庫簡單健壯，提供容器和關聯數組的支持。

## 語言特性

### 語法

- Java語法是上下文無關文法，可以用一個簡單的LALR語法分析器來分析。而分析C++就複雜多了；例如 `Foo&lt;1&gt;(3);`，如果 Foo 是一個變數，那麼它是一個比較的運算式，但如果 Foo 是一個類範本的名字，那麼它會創建一個物件。
- C++允許名字空間級別的常量，變數和函數. 而所有這樣的 Java 聲明必須在一個類或者介面當中。
- 在 C++ 的聲明中，一個類名可以用來聲明一個此類物件的值。Java 裡沒辦法做到這點，在Java裡對象不是值。在 Java 的聲明中，一個類名聲明的是對此類的一個物件的引用。而在 C++ 裡與之等價的做法是用 "*" 來聲明一個指標。
- 在 C++ 裡，"."操作符將一個物件作為一個左指令引數來訪問這個物件的成員。因為對象在 Java 裡不是值，所有的對象都通過引用來訪問，剛才的做法在 Java 裡是無法實現的。在 Java 裡，"." 操作符是將一個物件的引用作為左指令引數來訪問這個物件的成員，在C++中和這種做法等價的是 `->`。

C++｜Java

```cpp
class Foo {          // 定义 Foo 类
public:
    int x;           // 成员变量

    Foo(): x(0) {    // Foo 的构造函数
    }                //  初始化 x

    int bar(int i) { // 成员函数 bar()
        return 3*i + x;
    }
};
```

```java
class Foo {               // 定义 Foo类
    public int x = 0;     // 成员变量,
                          //  以及其值的初始化
    public Foo() {        // Foo的 构造函数
    }

    public int bar(int i) {// 成员方法 bar()
        return 3*i + x;
    }
}
```

```cpp
Foo a;
// 定义 a 为一个 Foo 类的对象,
// 使用其缺省的构造函数
// 如果你想要用其他的构造函数,
// 你可以用 "Foo a(args);" 
```

```java
Foo a;
// 定义 a 为一个 Foo 类的对象的引用
a = new Foo();
// 使用缺省的构造函数初始化
// 如果你想要用其他的构造函数,
// 你可以用 "Foo a = new Foo(args);" 
```

```cpp
Foo b = a;
// 拷贝 a 的內容到一个新的 Foo 类的变量 b 当中;
// 另一种可以选择的語法是 "Foo b(a)" 或者 "Foo b{a}"
```

```java
Foo b = a.clone();
// 拷贝所有a这个实例的成员到b,当且仅当,
// Foo 实现了一个 public 的 clone() 方法,
// 并且 clone() 返回一个新的这个对象的拷贝
```

`a.x = 5; // 修改 a 對象`｜`a.x = 5; // 修改 a 對象`

```cpp
cout << b.x << endl;
// 輸出 0,因為 b 和 a 是兩個物件
```

```java
System.out.println(b.x);
// 輸出 0,因為 b 和 a 是兩個物件
```

```cpp
Foo *c;
// 定義 c 為指向一個 Foo 類物件的指標(初始值是
// 未定義的;可能指向任何地方)
```

```java
Foo c;
// 定義 c 為一個指向 Foo 物件的指標
// (如果 c 是一個類的成員,那麼初始值為空;
// 如果 c 是一個區域變數那麼你在使用之前必須
// 對它進行初始化)
```

```cpp
c = new Foo();
// 將 c 綁定為一個新的 Foo 物件的引用
```

```java
c = new Foo();
// 將 c 綁定為一個新的 Foo 物件的引用
```

```cpp
Foo *d = c;
// 將 d 綁定為和 c 同一個對象的引用
```

```java
Foo d = c;
// 將 d 綁定為和 c 同一個對象的引用
```

```cpp
c->x = 5;
// 修改 c 指向的對象
```

```java
c.x = 5;
// 修改 c 指向的對象
```

```cpp
a.bar(5);  // 對 a 調用 Foo::bar()
c->bar(5); // 對 *c 調用 Foo::bar()
```

```java
a.bar(5); // 對 a 調用 Foo.bar()
c.bar(5); // 對 c 調用 Foo.bar()
```

```cpp
cout << d->x << endl;
// 輸出 5,因為 d 引用的物件和 c 一樣
```

```java
System.out.println(d.x);
// 輸出 5,因為 d 引用的物件和 c 一樣
```

- 在 C++ 裡，定義一個指向常量的指標（唯讀指標）是可能的，也就是說，你不能修改這個指標指向的物件的內容。函數和方法也都保證不會修改用 "const" 關鍵字的指標指向的物件的內容,是強制常量正確性的。在 Java 裡這是不可能做到的，你可以定義一個引用為 "final"（就像在 C++ 裡定義一個指標"常量"），但這只是阻止你重新綁定這個引用；你還是可以修改這個 "final" 引用指向的物件的。

C++｜Java

`const Foo *a; // 你不能通過 a 修改 a 指向的對象`｜`final Foo a; // 你可以通過 a 修改 a 指向的物件`

`a = new Foo();`｜`a = new Foo(); // 只能在構造函數裡`

```cpp
a->x = 5;
// 非法
```

```java
a.x = 5;
// 合法, 你仍然可以修改這個物件
```

```cpp
Foo *const b = new Foo();
// 你可以定義一個 "const" 指標
```

```java
final Foo b = new Foo();
// 你可以定義一個 "final" 引用
```

```cpp
b = new Foo();
// 非法, 你不能對它再次綁定
```

```java
b = new Foo();
// 非法, 你不能對它再次綁定
```

```cpp
b->x = 5;
// 合法,你還是可以修改這個物件
```

```java
b.x = 5;
// 合法,你還是可以修改這個物件
```

- C++ 支持 `goto` 語句；Java 強制結構化流程控制（structured control flow），依賴break標籤 和 continue標籤 語句來提供類似於 `goto` 的部分。一些評論者指出這些標籤化的流程控制打破了結構化程式設計的單退出點的。點.
- C++ 提供了一些 Java 缺乏的低級特性。在 C++ 裡，指標可以用來操作特定的記憶體位置，這是在寫低級作業系統模組的時候必須用到的。類似的，許多 C++ 編譯期支持內聯彙編，在 Java 裡，這樣的代碼只能放在外來的庫中，而且在調用的時候只能通過JNI來訪問這些外來庫提供的介面.

### 語意

- C++ 允許給函數/方法的參數設置預設值，Java 不提供這個特性。但是方法重載可以達到同樣的效果。
- C++ 里最小的編譯單位是一個函數；Java 里最小的編譯單位是一個類. 在 C++ 里，函數可以被單獨編譯。在 Java 里，要編譯和維護單獨的方法需要把它們移到超類或子類或者使用其他的代碼重構的技巧。
- C++ 允許基本類型之間的一些隱式的轉換，也允許程式設計師對於使用者自定義類型相關的隱式轉換規則。在 Java 里，只有基本類型之間變寬類型的轉換可以是隱式的；其餘的轉換需要顯式的類型轉換語法。
- 這造成的一個後果是，雖然在 Java 和 C++ 里循環的條件（`if`、`while` 和 `for` 里的退出條件）預期的都是一個布爾表達式，但 `if(a = 5)` 這樣的代碼在 Java 里會導致編譯錯誤，因為沒有從整型到布爾的隱式變窄轉換。如果代碼是 `if(a == 5)` 的輸錯的情況那麼是很方便發現這個錯誤的。而目前的 C++ 編譯器一般來說只會針對這種情況產生一個警告。
- 對於傳參數給函數的情況，C++ 支持引用傳遞和值傳遞。在 Java 里，參數總是值傳遞的。但在 Java 里，所有的非基本類型的值都只是對於對象的引用（用 C++ 的術語來說，它們是智能指針）。對象在 Java 里不是作為值直接被使用的，只有對象的引用可以被直接操作；習慣於將對象當做值直接使用的 C++ 開發者經常會把這個跟引用傳遞搞混。
- Java 內建的類型在字節寬度和取值範圍上是被虛擬機定義好的；在 C++ 里，內建的類型有定義一個最小取值範圍，但是其他的部分（字節寬度）可以被映射成具體平台上支持的原生類型。
- 舉個例子，Java 字符是16位的Unicode字符，字串是由這樣的字符組成的序列。C++ 提供窄和寬兩種字符，但實際的字符寬度是和平台相關的，視所用的字符集而定。字串可以由這兩種字符中的一種組成。
- 浮點數及其操作的精度和捨入方式在 C++ 里是平台相關的. Java 提供了一個可選的strictfp，保證跨平台的一致性，不過可能會導致運行時效率比較差.
- 在 C++ 里，指針可以作為記憶體地址直接操作. Java 沒有指針 — 它只有對象引用和陣列引用，這兩者都不允許直接用來訪問記憶體地址。在 C++ 里可以構造一個指向指針的指針，而 Java 的引用只能指向對象。
- 在 C++ 里，指針可以指向函數或者方法（函數指針）。在 Java 里的等價物是對象或者接口的引用。
- 雖然有使用棧記憶體分配的對象，C++ 還是支持區域資源管理，一個用來自動管理記憶體和其他系統資源的技術，此技術支持確定性對象銷毀（deterministic object destruction）。不過，區域資源管理在 C++ 里是不被保證的；它只是一個設計模式，所以需要依賴程式設計師遵守相關的規則. Java 通過使用垃圾搜集來支持自動記憶體管理，但對於其他的系統資源（窗口，通訊埠，執行緒），如果垃圾搜集器無法決定它們是否不再被用到，那通常還是需要顯式的釋放的。
- C++ 的使用者可自定義操作符重載的特性在 Java 里是不支持的。唯一在 Java 里可以重載的操作符是 "`+`" 和 "`+=`" 操作符，在字串里重載為連接字串。
- Java 的標準應用程序接口支持反射和動態加載任意代碼。
- C++ 支持靜態和動態的庫連接。
- Java 支持泛型，其主要目的是提供類型安全的容器. C++ 支持模板，在泛型編程方面提供了更強的支持。
- Java 和 C++ 都對基本類型（也叫"內建"類型）和使用者自定義類型（也叫"複合"類型）。在 Java 里，基本類型只有值的語義，複合類型只有引用的語義. 在 C++ 里所有的值都有值語義，可以創建對於任何類型的引用，這樣就允許通過引用語義來操作對象。
- C++ 支持任意類型的多重繼承. 在 Java 里一個類只能從單個的類繼承而來，但一個類可以實現多個的接口（換句話說，它支持類型的多重繼承，但對於實現只能單繼承）。
- Java 對於類和接口是顯式區分的。在 C++ 里多重繼承和純虛函數使得定義出類似於 Java 的接口的類是可能的，不過會有少許區別。
- Java 在語言和標準庫都對多執行緒有良好的支持。`synchronized` 這個 Java 的關鍵字為了支持多執行緒應用提供了簡單而安全的的互斥鎖，但同步（synchronized）區只能用 LIFO 的順序離開。Java 也為更高階的多執行緒同步提供了健壯而複雜的庫。在 C++ 里沒有專門為多執行緒定義的記憶體模型；但第三方庫提供了和 Java 差不多的功能；不過這些 C++ 庫之間差異較大，一致性不好。
- C++ 方法可以聲明為虛函數，虛函數是在運行期根據對象的類型才確定的。C++ 方法預設情況下不是虛的. 在 Java 里，方法預設情況下是虛的，但可以使用`final`關鍵字使之聲明為非虛的。
- C++ 枚舉屬於基本類型，支持和其他整數類型之間的轉換和比較。Java 枚舉實際上是類的實例（它們從 `java.lang.Enum<E>` 擴展而來），象其他的類一樣可以定義構造函數，數據成員及方法。

### 資源管理

- Java 提供了自動化的垃圾搜集。在 C++ 里記憶體管理通常通過構造函數，析構函數以及智能指針。C++ 標準允許垃圾搜集，但並不強制要求；實際使用上垃圾搜集極少被用到。強制使用自動垃圾搜集導致了在 Java 里編寫實時軟體是困難的。
- C++ 可以申請任意的記憶體塊。Java 只能通過對象實例化來申請記憶體。（注意：在 Java 里，程序員可以通過創建一個字節陣列模擬申請任意的記憶體塊，不過 Java 陣列仍然是對象。）
- Java 和 C++ 在資源管理上使用不同的習語。Java 主要依賴只能回收記憶體的垃圾搜集機制，因為該機制如果用於回收使用中的非記憶體的系統資源可能是非常危險的。而 C++ 主要依賴 RAII (資源的獲取就是初始化)。這反映了這兩種語言的幾方面的不同：
- 在 C++ 里在棧里申請複合類型的對象是很平常的，一旦退出棧的範圍就會被銷毀。在 Java 里複合類型的對象總是在堆里申請的記憶體，而後被垃圾搜集器搜集（除非在虛擬機裡使用了逃逸分析技術來將堆的記憶體申請轉成棧的。）
- C++ 有析構函數，而 Java 有finalizer(finalizer). 兩者都會在對象釋放之前被調用，但是它們有顯著的不同. 一個 C++ 對象的析構函數必須被隱式（棧變量對象的情況）或者顯式地調用來釋放對象. 析構函數在對象釋放之前同步地執行. 同步，協調的反初始化以及釋放在 C++ 里滿足 RAII 的要求. 在 Java 里，對象的釋放是被垃圾搜集器隱式處理的. 一個 Java 對象的 finalizer 在它被最後一次訪問之後和在實際釋放之前的某個時間點被異步（非同步）地調用，這個調用有可能一直不產生. 非常少的對象需要 finalizer；只有那些在釋放前必須保證一些清理工作一定要做的對象來說才是需要的 — 典型的情況是：釋放對 JVM 來說是外部的資源. 在 Java 里，企圖安全同步的釋放某些系統資源，只能用顯式的 try/finally 結構來進行.
- 在 C++ 里是有可能有一個迷途指針的 – 過時的對一個已釋放的對象的引用（參照）；試圖使用一個迷途指針的結果是導致程序錯誤. 在 Java 里，垃圾搜集器不會銷毀一個正在被引用的對象.
- 在 C++ 里未初始化過的基本類型對象是有可能存在的，Java 強制要做預設初始化.
- 在 C++ 里有可能申請了一個對象，但對它沒有任何引用. 這樣的不可達對象（不可訪問內存）是無法被銷毀的，導致了記憶體洩漏. 作為對比，在 Java 里一個對象不會被回收直到它變得不可達（對於使用者程序來說）. （注意: 弱引用(弱引用）是被支持的，這個特性讓 Java 的垃圾搜集器能夠識別不同 程度的可達性.）在 Java 里垃圾搜集阻止了很多記憶體洩漏的情況，但某些情況下洩漏仍然是可能的.
- Java 更容易洩漏非記憶體資源，而 C++ 的慣用做法更不會導致這種洩漏.

### 庫

- C++ 對於許多平台相關的特性提供了跨平台的訪問方式. 從 Java 到原生的作業系統和硬體相關的函數的直接訪問需要用到JNI（Java本地接口）。

### 運行時

- C++ 通常來說會直接被編譯成機器碼，被作業系統直接執行。Java 通常會被編譯成字節碼，被Java虛擬機和解釋器或者即時編譯器編譯成機器碼然後執行。
- 因為表達方式不受限制，低級的 C++ 語言特性（例如：不被檢查的陣列訪問，原始指針，類型雙關語(type punning)不能在編譯期間或者運行期間可靠地被檢查. 相關的編程錯誤會導致低級的緩存溢出和段錯誤（記憶體區段錯誤）. 標準模板庫 提供了高級的抽象（例如 vector,list 和 map）來幫助避免這樣的錯誤.在 Java 里，低級錯誤不會發生或者會被JVM檢測到並以異常的形式報告給應用.
- Java 語言在越界訪問陣列的時候一般來說會對數組進行邊界檢查(bounds checking). 這消除了導致程序不穩定的一個可能因素，但這是以執行速度更慢一些作為代價的. 在一些情況下，編譯器分析（compiler analysis）可以檢測到不必要的邊界檢查並去掉。C++ 對於原生陣列的越界訪問沒有要求特定的處理，所以需要對於原生陣列確認不越界. 但C++ 標準庫里的一部分庫象 std::vector 也提供了可選的邊界檢查. 總的來說，Java 陣列是"總是安全；嚴格限制；開銷較多"，而 C++ 原生陣列是"可選的開銷；完全不限制；有潛在的不安全."

### 模板 vs. 泛型

C++ 和 Java 都提供泛型編程的能力，分別是模板 和 泛型(Generics in Java). 雖然它們被創造用來解決類似的問題，有類似的語法，但實際上很不一樣.

C++ 模板｜Java 泛型

類和函數都可以使用模板.｜類和方法都可以使用泛型.

參數可以是任意類型或者整型.｜參數只能是能被引用的類型（非基本類型）.

在編譯的時候對於每種類型生成類或者函數的拷貝.｜對於所有類型的參數，只有一個版本的類或者函數生成.

同一個類用不同類型生成的對象在運行期也是不同類型的｜編譯完成以後類型參數的類型是被消除的；同一個類用不同類型參數生成的對象在運行期是相同類型的.

想要用到模板類或者函數的實現代碼的話必須 include 它（只是聲明是不夠的）.｜有一個編譯好的類文件里的類或者函數的簽名就足以使用泛型了

模板可以被具體化 -- 可以為某個特定的模板參數提供單獨的實現.｜泛型不能被具體化.

模板參數可以有預設參數(default argument)（只針對對於模板類，模板函數是沒有此特性的）.｜泛型類參數無法擁有預設參數.

不支持通配符. 返回的類型經常是嵌套的 typedef 形式的.｜如果只用一次,那麼支持通配符作為類型參數.

不直接支持設置類型參數的邊界（即，不允許說明類型參數必須為某個類型的子類/父類），但超編程提供了這個特性｜支持類型參數邊界，分別以 "extends" 和 "super" 來定義上界和下界；同時允許定義類型參數之間的繼承關係

允許生成有參模板的類的實例（如 foo = new Foo, T 為參數）｜不允許生成有參模板類的實例（除非使用反射）

泛型類的類型參數無法用在 static 方法和變量上.

static 變量不在在不同的類型參數生成的類之間共享.｜static 變量在不同類型參數生成的類的對象之間是共享的.

泛型類和函數在聲明時不強制類參數的類限制. 使用錯誤的類參數會導致模板代碼"不工作". 值得注意的是，如果使用了錯誤的參數，則錯誤信息將出現在定義模板的代碼處（而非調用模板的代碼處），說明 "不支持以該類型作為參數來實例化模板". 這種錯誤信息往往難以幫助人們找出真正的問題所在（編程時究竟使用了何種 "錯誤的" 參數）. 因此，模板類或者函數的正確使用更依賴於正確的文檔. 超編程以額外的代價提供了這些特性.｜泛型類和函數在聲明的時候強制了類參數的類限制(Generic classes and functions can enforce type relationships for type parameters in their declaration). 使用一個錯誤的參數會在使用它的時候導致一個類錯誤. 在泛型代碼里操作和參數化類型只能按聲明的時候保證安全的方式來使用. 這用失去彈性的代價來換取好得多的類型方面的安全性.

模板是圖靈完全的（參見 模板超編程）.｜泛型不是圖靈完全的.

### 雜項

- Java 和 C++ 在使代碼在不同的文件分開方面使用了不同的技術. Java 使用了一個包系統，這個系統對所有的程序都要指定了文件名和路徑. 在 Java 里，編譯器負責導入可執行的類文件. C++ 使用了頭文件原始碼的包含系統來在不同的文件共享聲明.
- 編譯好的 Java 代碼一般來說比 C++ 文件小，因為Java字節碼(Java bytecode)一般來說比機器碼要更緊湊，Java 程序都不是靜態連結的.
- C++ 編譯多了一個文本預處理過程，Java 是沒有的. 因此一些使用者在他們的編譯過程之前增加了一個預處理的過程，這樣能更好的支持需要條件編譯的情況.
- 兩個語言裡陣列都是定長的. 在 Java 里，陣列是頭等對象，而在 C++ 里它們只是它們的基本類型元素的連續的序列，經常用一個指向第一個元素的指針和一個可選的長度來引用. 在 Java 里，陣列是被邊界檢查的，而且知道它們的長度，而在 C++ 里你可以將任意的序列當成一個陣列. C++ 和 Java 都提供了相關的容器類（分別為std::vector 和 java.util.ArrayList），可以改變大小.
- Java 的除法和模除操作符是定義成零截斷的. C++ 沒有定義這兩個操作符是零截斷的還是"負無窮截斷"的. 在 Java 里-3/2 總是得到 -1，但一個 C++ 編譯器可能會返回 -1 或 -2，視平台而定. C99 定義了和 Java 一樣的除法方式. 兩種語言都保證對於所有的 a 和 b(b!=0)（當 a 和 b都是整型的時候）`(a/b)*b + (a%b) == a`. C++ 版本有時候會更快，因為它允許直接使用處理器的截斷方式.
- 整型的長度在 Java 里是已定義好的(int 為 32-bit, long 為 64-bit)，而在 C++ 里整型和指針的長度是和編譯器以及應用二進位接口相關的. 因此仔細編寫的 C++ 代碼可以利用64位處理器的能力而又可以在32位處理器上工作. 但是需要很仔細的用可移植的方式編寫. 作為對比，Java 的固定整型大小使得程式設計師無法做到這樣，沒辦法利用處理器的字長會導致 Java 在64位處理器上表現較差.

## 性能

想運行一個編譯好的 Java 程序，電腦上要運行JVM；而編譯好的 C++ 程序不需要額外的應用。比較早期的 Java 版本在性能上比靜態編譯的語言如 C++ 差得很多，這是因為用 C++ 是直接編譯成一些機器指令，而當 Java 編譯成字節碼以後用 JVM 解釋執行的時候又牽涉了不少額外的機器指令。

例如：

Java/C++ 語句｜C++ 生成的代碼 (x86)｜Java 生成的字節碼

vectori++;｜mov edx,ebp+4h mov eax,ebp+1Ch inc dword ptr edx+eax、4｜aload_1 iload_2 dup2 iaload iconst_1 iadd iastore

C++ 在大部分的情況下都比 Java 要快。

有幾個數值方面的基準測試的研究爭辯說 Java 在某些情況下可能會比 C++ 的性能好得多。但有人說數值方面的基準測試對於語言的評估是不合適的，因為編譯器都可以做相關的優化，甚至可能將被測試的代碼徹底刪除。如果涉及到一個真正現實應用的程序，Java 會因為很多原因導致性能變差：

- 所有的對象都在堆里被申請。對於使用小對象的函數來說會導致很大的性能損失，因為在棧里申請記憶體幾乎沒有性能損失。
- 方法預設是虛的。這對於小對象來說會因為虛表增加好幾倍的記憶體使用。它也會引起性能損失，因為 JIT 編譯器不得不對查虛表的過程做額外的優化。
- 即使使用標準的容器依然會有很多的類型轉換，這會引起性能損失，因為需要遍歷整個繼承樹。
- 虛擬機更進一步增加了記憶體的使用，因此降低了記憶體的局部性，增加了緩存命中失敗率，從而導致整個程序變慢。
- 缺乏低級細節的操作方式使得開發者無法將程序進一步優化，因為編譯器不支持。

有人爭論說，和 Java 相比 C++也有很多劣勢：

- 指針使得優化變得困難，因為它們可能指向任意的數據。當然現在這一點也並非完全正確，因為一些現代的編譯器引入了 "嚴格別名" 的規則 並且支持 C99 的關鍵字 restrict，從而嚴格限制了指針的使用，使其只能用於指向已知的變量
- Java 的垃圾搜集和使用malloc/new來申請記憶體相比能擁有更好的緩存連貫性，因為它的申請一般來說是順序的。然而，始終有爭論認為二者同樣會導致記憶體的「零碎化」（即多次分配和回收之後記憶體空間會變得不連續），且並沒有哪一個比對方有更明顯的緩存優勢。
- 運行時編譯可能可以更好的優化代碼，因為可以利用運行時的額外的資訊，例如知道代碼是在什麼樣的處理器上運行。然而當今的情況也並非完全如此，因為目前最先進的 C++ 編譯器也會針對不同系統生成不同的目標代碼，以期充分利用該系統的計算能力

此外，有爭議的是，花在更複雜的 C++ 代碼上的 debug 時間太多，用 Java 開發完全可以把這些時間用來優化 Java 代碼。當然對於一個給定的程序來說兩種語言能優化到什麼程度也是一方面。最後，對於處理器負擔很重的情況，例如影片渲染，C++ 能直接訪問硬體，在同樣一個硬體規格下 C++ 總是會比 Java 的表現好很多。

## 所有權控制

C++不是任何一個公司或者組織的商標，不被任何個人擁有。Java原是Sun的商標，現在由甲骨文公司擁有。

C++語言由 ISO/IEC 14882 定義，是一個ISO標準，由 ISO/IEC JTC1/SC22/WG21 委員會發布。Java語言由 Java Language Specification 定義，這是一本Sun公司（已被甲骨文收購）出版的書。

## 其他

兩者的對象訪問格式也不一樣。

## 外部連結

- Java and C++ Memory Management — 一本詳盡的關於面向對象記憶體管理方面的出版物,在記憶體模型上對 Java 和 C++ 做了比較.
- How Java Differs from C — excerpt from Java in a Nutshell by David Flanagan
- Java vs. C++ resource management comparison - 一份有例子的綜合論文
- Java vs C performance... again... - 深入討論 Java 和 C++ 性能方面的差別