繼上篇文章：Java和C++在細節上的差異:枚舉與反射

 六、接口與內部類：

1. 接口和抽象類：Java通過interface關鍵字來表示接口，接口中不能包含非靜態域字段，所有的域成員均是公有的抽象方法，如Comparable接口，如果希望利用Arrays.sort方法，數組的成員必須實現該接口。抽象類中包含抽象方法，和接口一樣抽象類也不能被實例化。

1) 接口不能被實例化，但是可以聲明接口的變量指向其實現類的對象。

2) 每個類只能有一個超類，但是可以實現多個接口。

以下為Java的接口和抽象類的定義方式：

public interface Comparable { 
int compareTo(Object other); 
} 
 
public interface Comparable<T> { 
int compareTo(T other); 
} 
 
abstract class Employee implements Comparable { 
public abstract int compareTo(Object other); 
} 

在C++中同樣存在接口和抽象類的概念，也和Java一樣不能被實例化，但是并沒有相應的關鍵字存在，而是以一種潛在規則的方式存在，見如下代碼：

//Comparable對象聲明的方法中只有純虛方法存在(析構函數除外)，且沒有任何成員變量。 
class Comparable { 
public: 
virtual ~Comparable() {} 
//compareTo為純虛方法 
virtual int compareTo(Comparable& other) = 0; 
} 
 
//Employee對象中存在部分純虛方法，且可以有成員變量存在。 
class Employee { 
public: 
virtual int compareTo(Comparable& other) { return 0; } 
virtual int backgroud() = 0; 
 
private: 
int _age; 
} 

在C++的實現中，基于接口編程，同時導出C接口的工廠方法對于跨編譯器極為重要，該方式比較類似于Windows中的COM技術。

C++支持多重繼承，因此也存在虛基類(菱形結構)等問題帶來的負面影響，既子類的兩個父類中同時存在相同簽名的虛方法。見如下代碼：

class TcpServerTask { 
public: 
virtual void run() {} 
} 
 
class SentObjectTask { 
public: 
virtual void run() {} 
} 
 
class TcpServerSentTask : public TcpServerTask, public SentObjectTask { } 

2. 對象克隆： Object對象中存在protected類型的clone方法，該方法將會完成子類對象clone的缺省操作，既對象域字段的淺拷貝，如果該對象的成員均為原始類型，如int、float等，或者為不可變類型，如String。這樣的淺拷貝將能夠達到對象clone的預期。換言之，如果對象內部存在可變對象的引用，淺拷貝將會帶來原始對象和cloned對象引用相同對象引用的問題。如果希望避免該問題的發生，子類需要實現Cloneable接口。這里需要指出的是Cloneable接口并未提供clone方法，只是提供了一種契約簽名。子類真正做的還是重載Object方法中的clone方法，由于Object中該方法為protected方法，所以caller不能直接調用它，只能將子類的clone方法聲明為共有類型，caller才能調用。

//該實現類使用淺拷貝已經可以滿足其需要了 
public class implements Cloneable { 
//這里已經提升了clone方法的級別為public。 
public Employee clone() throws CloneNotSupportedException { 
return (Employee)super.clone(); 
} 
} 
//深拷貝clone方法，必須clone對象內部所有可變的實例域,其中這些可變類 
//必須全部都實現了自己的clone方法，否則將會跑出異常。 
public class Employee implements Cloneable { 
public Employee clone() throws CloneNotSupportedException { 
//缺省clone完成了域字段的按位淺拷貝。 
Employee cloned = (Employee)super.clone(); 
cloned.hireday = (Date)hireday.clone(); 
} 
private Date hireday; 
} 

注：數組對象可以通過Array的clone(public)方法完成元素的拷貝。

在C++中由于并不存在Object這樣的單根結構的框架，因此C++是以另外一種方式表現該問題的，既缺省拷貝構造和缺省等于操作符重載。和Java類似，這兩個方法也是member bitwise拷貝的，但這是由編譯器在生成對象模型時自動完成的缺省行為，如果該類重載了拷貝構造函數和等于操作符，在需要copy的時候則會調用重載后的方法，類的實現者應該在這兩個方法中完成深拷貝。C++中還可以通過將這兩個方法顯示的聲明為private類型的方法來禁用這種對象之間的copy行為，一旦出現，編譯器將會在在編譯器報錯。在C++中還存在一個explicit的關鍵字，可以有效的防止編譯器通過自行推演隱式的調用對象的拷貝構造函數和等于操作符函數，見如下代碼：

//該類將會使用缺省的copy constructor，因此也會出現兩個對象 
//引用相同_name變量地址的問題。 
class Employee { 
private: 
char* _name; 
}; 
//該類由于將這兩個方法私有化，一旦出現對象的隱式拷貝構造， 
//將會導致編譯錯誤。 
class Employee { 
private: 
Employee(Employee& other); 
const Employee& operator= (Employee& other); 
private: 
char* _name; 
}; 
//將會調用重載后的這兩個函數 
class Employee { 
Employee(Employee& other); 
const Employee& operator= (Employee& other); 
private: 
char* _name; 
}; 

注：C++中有一種被稱為引用計數的技術，經常會用在這個地方，以便提高對象copy的效率。

3. 接口與回調：嚴格意義上講，回調這個屬于更多的應用于C/C++這些支持基于過程編程的語言，Java中的回調是通過接口的方式來實現的，由于在接口的實現類中可以附帶更多的信息，因此其表達能力要由于C/C++中的函數指針，見如下代碼：

public class Thread { 
public Thread(Runnable r) {} 
} 
 
public class MyTask implements Runnable { 
public MyTask(int taskID) { 
_taskID = taskID; 
} 
 
public void setOk(bool ok) { 
_ok = ok; 
} 
 
public void run() {} 
} 
 
public static void main(String[] args){ 
MyTask t = new MyTask(5); 
Thread thrd = new Thread(t); 
t.setOk(true); 
thrd.start(); 
} 

這里的Runnable參數既為接口，Thread對象在啟動的時候會調用該接口實現對象的run方法，但是在調用之前可以給該實現類傳入更多的狀態等相關數據，以便在線程類調用run方法時可以得到更多的信息。
以下為回調函數在C/C++中的實現：

typedef int(*TestCallback)(int,int); 
int testCaller(TestCallback cb,int a,int b) { 
return cb(a,b); 
} 
 
int testCallback(int a,int b) { 
return a * b; 
} 
 
int main() { 
TestCallback cb = testCallback; 
return testCall(cb,5,6); 
} 

在C++中還可以通過模板以更加松散的方式完成類似Java的基于接口的回調(Java的回調方式，C++完全可以做到)，見如下代碼：

template<typename T> 
class Thread { 
public: 
Thread(T* r) _r = r {} 
void start() { if (_r) _r->run(); } 
private: 
T* _r; 
} 

在以上的實現中，T無需是某個接口的實現類，只要保證該類型包含run()方法即可，注意：C++中的模板是引用才編譯的方式，如果沒有任何Thread<T>的聲明，不會導致任何編譯錯誤，只有當聲明的類型對象中不包含run()方法時才會導致編譯錯誤。

4. 內部類：Java中內部類可以為私有內部類，既只有外部類可以訪問該內部類，而Java外部類的可見性只有包可見和public兩種。C++中的內部類比較類似于Java中的靜態內部類，只是一種作用域限制的行為，以下為Java非靜態內部類的說明：

1) 內部類可以訪問外部類的所有域成員和域字段，這也同樣包括私有的字段和成員。

2) Java的編譯器在構造外部類調用內部類構造方法時，自動將外部類的this變量作為一個隱式參數傳給了內部類的構造函數，內部類則在構造函數中保留了this變量的引用，該行為為編譯器隱式行為。

public class Employee { 
public class InnerClass { 
bool test() { 
//這里的_jobYears為外部類域字段。 
return _jobYears > 10; 
} 
} 
 
public Employee(int jobYears,String name) {  
_name = name;  
_jobYears = jobYears;  
_salary = 0; 
} 
 
public void raiseSalary() { 
//編譯器的會將以下構造隱式替換為InnerClass inner = new InnerClass(this); 
//因為Java在為其編譯的時候發現InnerClass為非靜態內部類，則自動添加了以下構造： 
//public InnerClass(Employee e) 
InnerClass inner = new InnerClass(); 
if (test())  
_salary += 1000; 
} 
private String _name; 
private int _jobYears; 
private int _salary; 
} 

注：針對以上事例，內部類InnerClass可以通過Employee.this._jobYears的全稱來顯式的代替_jobYears > 10 中的_jobYears。反過來在raiseSalary方法中可以通過this.new InnerClass()語法格式更加明確的創建InnerClass的對象。

public class Employee {  
public class InnerClass {  
bool test() {  
//這里的_jobYears為外部類域字段。  
return Employee.this._jobYears > 10;  
}  
}  
  
public Employee(int jobYears,String name) {   
_name = name;   
_jobYears = jobYears;   
_salary = 0;  
}  
  
public void raiseSalary() {  
//這里也可以不使用this作為內部該內部類對象的外部類對象  
//引用，可以根據需要替換為其他外部類對象的引用，如：  
// Employee other = new Employee();  
// InnerClass innser = other.new InnerClass();  
InnerClass inner = this.new InnerClass();  
if (test())   
_salary += 1000;  
}  
......  
}  

注：在外部類的作用域之外調用public內部類的語法為 OutClass.InnerClass。

3) 局部內部類的可見范圍僅僅限于聲明該局部類的函數內部，見如下代碼：

public void start() { 
class TimePrinter implements ActionListener { 
public void actionPerformed(ActionEvent e) { 
Date now = new Date(); 
System.out.println("At the tone,the time is " + now); 
//beep為外部類的域字段 
if (beep) 
Tookkit.getDefaultToolkit().beep(); 
} 
} 
ActionListener l = new TimePrinter(); 
new Timer(interval,l).start(); 
} 

局部類同樣可以訪問函數內部的局部變量，但是要求該變量必須是final的。

public void start(final bool beep) { 
class TimePrinter implements ActionListener { 
public void actionPerformed(ActionEvent e) { 
Date now = new Date(); 
System.out.println("At the tone,the time is " + now); 
//beep為外部函數的局部變量。 
if (beep) 
Tookkit.getDefaultToolkit().beep(); 
} 
} 
ActionListener l = new TimePrinter(); 
new Timer(interval,l).start(); 
} 

為了規避局部類只能訪問final局部變量的限制，既一次賦值之后不能再被重新賦值。但是我們可以通過數組的方式進行巧妙的規避，在下例中數組counter對象本身是final的，因此他不可以被重新賦值，然而其引用的數組元素則可以被重新賦值，見下例：

public void test() { 
final int[] counter = new int[1]; 
for (int i = 0; i < dates.length; ++i) { 
dates[i] = new Date() { 
public int compareTo(Date other) { 
//這里如果counter不是數組，而是被定義為final int counter， 
//則會導致編譯失敗。 
counter[0]++; 
return super.compareTo(other); 
} 
} 
} 
} 

C++中同樣可以做到這些，其規則和Java的主要差異為C++的內部類無法直接訪問外部類的任何成員。

class OuterClass { 
public: 
void testOuter() { 
class FunctionInnerClass { 
public: 
void test() { 
printf("This is FunctionInnerClass.\n"); 
} 
}; 
FunctionInnerClass innerClass; 
innerClass.test(); 
} 
}; 
 
int main() 
{ 
OuterClass outer; 
outer.testOuter(); 
return 0; 
} 

4) 匿名內部類，其基本規則和局部內部類相似，差別在于該內部類不能有聲明構造函數，這主要是因為Java要求類的構造函數和類名相同，而匿名內部類自身沒有類名，因此在new新對象的時候，傳入的構造函數參數為超類的構造函數參數。C++中不支持匿名類。見下例：

public void start(final bool beep) { 
ActionListener l = new ActionListener() { 
public void actionPerformed(ActionEvent e) { 
Date now = new Date(); 
System.out.println("At the tone,the time is " + now); 
//beep為外部函數的局部變量。 
if (beep) 
Tookkit.getDefaultToolkit().beep(); 
} 
} 
new Timer(interval,l).start(); 
} 

5) 靜態內部類，其功能和C++中的嵌套類非常相似，但是和Java自身的非靜態內部類之間還是存在一些差異，如靜態內部類不能直接訪問外圍類的對象引用域字段，但是可以訪問外部類的static域字段(包括private)。在Java中只有內部類可以被定義為static的，外圍類是不可以這樣定義的。

public class TestMain { 
private static boolean classField = false; 
private boolean objectField = false; 
static class InnerClass { 
public void test() { 
//這里由于classField是靜態域字段，所以靜態內部類可以直接訪問， 
//但是對于objectField對象域字段而言，由于靜態內部類中沒有包含 
//外部類的引用，因此不能直接訪問objectField. 
if (classField)  
System.out.println("Hello."); 
} 
} 
 
public static void main(String[] args) { 
classField = true; 
new InnerClass().test(); 
} 
} 

以下示例中的內部類只能是靜態內部類，因為該外部類的靜態方法在返回內部類的實例時，無法將一個外部類的對象引用傳遞給該內部類，因為必須要求該內部類為靜態內部類，否則將會報編譯錯誤。

public class TestMain { 
static class InnerClass { 
public void test() { 
System.out.println("Hello.\n"); 
} 
} 
 
private static InnerClass createInnerClass() { 
return new InnerClass(); 
} 
public static void main(String[] args) { 
createInnerClass().test(); 
} 
} 

如果InnerClass不是靜態內部類，則需要將上例改寫為：

public class TestMain { 
class InnerClass { 
public void test() { 
System.out.println("Hello.\n"); 
} 
} 
 
private static InnerClass createInnerClass() { 
//為了確保InnerClass可以得到外部類的對象引用。 
return new TestMain().new InnerClass(); 
} 
public static void main(String[] args) { 
createInnerClass().test(); 
} 
} 

6) 代理類：通過以下代碼step by step解釋代理類的機制

import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Proxy; 
import java.util.Arrays; 
import java.util.Random; 
 
public class TestMain { 
public static void main(String[] args) { 
Object[] elements = new Object[1000]; 
for (int i = 0; i < elements.length; ++i) { 
Integer v = i + 1; 
//h(調用處理接口)是代理類的核心處理單元。由于代理類對象只是包含了InvocationHandler 
//這樣一個對象實例，并且是存放于超類Proxy中的，而實際的被代理實例必須存放于InvocationHandler 
//的實現類中，如這里的Integer對象v。其中的核心代理代碼也是在InvocationHandler子類的 
//invoke方法中完成的。 
InvocationHandler h = new TraceHandler(v); 
//1. 第一個參數表示ClassLoader，這里使用缺省加載器，因此傳入null即可。 
//2. 第二個參數表示該代理類需要implement的接口數組(Java中可以實現多個接口)。 
//3. 調用處理器接口，是代理類如果實現代理的核心，后面會介紹該類。 
//4. 將該代理類作為Integer的代理存入數組。 
elements[i] = Proxy.newProxyInstance(null, new Class[] {Comparable.class}, h); 
} 
Integer key = new Random().nextInt(elements.length) + 1; 
//1. 由于代理類也都實現Comparable接口，因此可以用于Arrays.binarySearch中。 
//2. 對代理類進行二分查找的比較時，將會直接調用代理類的compareTo方法。 
//3. 該自動生成的Proxy的子類，其中的compareTo方法會將所有外部調用的信息，連同 
// 方法名一并傳給其內部調用處理器對象的invoke方法，并調用該方法(invoke). 
//4. 這里Proxy子類會將所有實例化時指定接口(Comparable)的方法(compareTo)，以及 
// Object中toString、equals和hashCode方法的調用都會傳遞給調用處理器的invoke方法。 
//5. 因此在輸出結果中不僅可以看到compareTo方法的調用被打印出，toString也可打印。 
int result = Arrays.binarySearch(elements, key); 
if (result >= 0) 
System.out.println(elements[result]); 
} 
} 
 
class TraceHandler implements InvocationHandler { 
//由于Proxy的子類是動態生成的，其具體的實現也是編譯器動態生成后傳給JVM的。 
//因此這里是整個代理機制中唯一存放被代理對象的地方。 
public TraceHandler(Object t) { 
target = t; 
} 
 
//在此例中，該方法是被Comparable接口中的compareTo方法調用的，該實現邏輯是位于該 
//動態生成的Proxy子類中，如  
//public MyProxy extends Proxy implements Comparable { 
// int compareTo(Object other) { h.invoke(...); } 
@Override 
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
//打印出實際被調用方法的名稱和參數值。 
System.out.print(target); 
System.out.print("." + method.getName() + "("); 
if (args != null) { 
for (int i = 0; i < args.length; ++i) { 
System.out.print(args[i]); 
if (i < args.length - 1) 
System.out.print(", "); 
} 
} 
System.out.println(")"); 
//交給被代理類做實際的比較。 
return method.invoke(target, args); 
} 
private Object target = null; 
} 
/* 輸出結果如下： 
500.compareTo(128) 
250.compareTo(128) 
125.compareTo(128) 
187.compareTo(128) 
156.compareTo(128) 
140.compareTo(128) 
132.compareTo(128) 
128.compareTo(128) 
128.toString() 
128 */ 

#p#

七、異常和斷言：

1. 異常處理：

1) 異常規范表示對于"已檢查"(checked)異常，如FileNotFoundException等，既在程序運行期間可以預測到的邏輯問題引發的異常，對于該類異常，需要在包含該異常的函數聲明部分標識出來，該函數可能會引發此類異常，如：

public Image loadImage(String s) throws IOException, MalformedURLException 

如果在loadImage中仍然存在其他"已檢查"，但是沒有在函數的異常規范中聲明出來，那么將會導致編譯失敗，因此對于函數中所有"已檢查"必須按照Java異常規范的要求，在函數的聲明中予以標識。對于該函數(loadImage)的調用者而言，在調用該函數時，必須將其放入try塊中，同時在catch字句中捕捉異常規范中標識的異?；蛩麄兊某悺?br /> 對于"運行時異常"(unchecked or runtime),由于大多是程序Bug或JVM問題所致，因此不可預測性極強，如ArrayIndexOutOfBoundException，對于該類異常無需在函數的異常規范部分予以聲明。

在C++標準中也同樣存在異常規范的說法，如

File* loadFile(const char* s) throw std::bad_error 

所不同的是C++沒有明確的要求如果函數內部拋出了該異常，則必須在函數聲明的異常規范部分予以聲明，對于函數調用者而言也同樣沒有這樣的規定，必須捕獲其中的異常，因此異常規范在目前的C++編譯器中只是一種提示性的聲明。Java和C++在異常規范方面還存在的另一個區別是，C++中，如果函數沒有throw字句，那么該函數仍然可以拋出任何異常，但是對于Java的"已檢查"(checked)異常則必須通過throws字句聲明。

2) 如何拋出異常，在此方面，Java和C++沒有太大的差異，唯一的不同是Java拋出的異常必須是Throwable的實現類，C++中則沒有這樣的限制，也不存在這樣的異常接口。見如下代碼：

public void howToThrowException() { 
if (someErrorOccurred) 
//1. 通過throw關鍵字直接拋出指定異常類型的對象即可。 
throw new MyCheckedException(); 
} 

3) 異常捕捉：由于Java中所有的異常均繼承自Throwable，所以catch(Throwable e)可以捕捉所有類型的異常，無論該異常是否為checked or unchecked異常，但是C++中并不存在這樣的異常祖先接口，因此如果想達到這樣的效果需要使用catch(...)關鍵字，這同樣表示捕捉所有的異常。

4) 異常鏈：當異常第一次拋出并且被catch住的時候，catch塊中的代碼可以再次拋出捕捉到的異常，同時也可以為了使上層業務邏輯能夠得到更加清晰的判斷，在第一次捕捉到異常后重新定義一個新的異常并再次拋出。有的時候，如果上層邏輯在需要的時候依然可以看到原始異常，將會對錯誤的處理更加合理。在Java中可以通過異常鏈的方式達到這樣的效果，見如下代碼：

public void testExceptionChain() throws MyCustomizedFileException { 
try { 
FileInputStream in = new FileInputStream("myfile"); 
} catch (FileNotFoundException e) { 
//定義了新的，準備再次被拋出的異常對象。 
Throwable te = new MyCustomizedFileException("access file error."); 
//將原始異常鏈接到該異常對象的內部，以供之后需要時通過getCause()方法重新獲取。 
te.initCause(e); 
throw te; 
} 
} 
 
public static void main(String[] args) { 
try { 
testExceptionChain(); 
} catch (MyCustomizedFileException e) { 
//獲取該異常對象的原始異常。 
Throwable te = e.getCause(); 
System.out.println(te.getClass().getName()); 
} 
} 
/* 輸出結果如下： 
FileNotFoundException 
*/ 

5) finally字句：在Java的異常機制中存在finally這樣的關鍵字，其塊中的代碼無論異常是否發生都將會被執行，從而可以確保函數內部分配或者打開的資源都能在函數內部進行釋放或者關閉，如Socket連接、DB連接，見如下代碼：

public void testFinally() { 
InputStream in = null; 
try { 
in = new FileInputStream("myfile"); 
} catch (IOException e) { 
//TODO: do something for this exception. 
} finally { 
in.close(); 
} 
//Do the following code. 
} 

在以上的代碼中，無論try塊中異常是否發生，finally塊中的代碼"in.close()" 都將會在函數退出之前或catch處理之后被執行，從而保證了FileInputStream對象能夠在函數退出之前被關閉。然而這樣的做法仍然可能導致一些影響代碼流程的問題，如果try塊中的代碼沒有產生異常，而是在finally中的in.close引發了異常，那么整個try{}catch{}finally{}代碼塊之后的代碼將不會被執行，而是直接退出該函數，同時拋出in.close()引發的異常給該函數的調用者。修正代碼如下：

public void testFinally() { 
InputStream in = null; 
try { 
in = new FileInputStream("myfile"); 
} catch (IOException e) { 
//TODO: do something for this exception. 
} finally { 
try { 
in.close(); 
} catch (IOException e) { 
} 
} 
//Do the following code. 
} 

在C++中，由于對象是可以在棧上聲明并且分配空間的，當棧退出后會自行調用該對象的析構函數，因此該對象的資源釋放代碼可以放在類的析構函數中。該方式對于一個多出口的函數而言也是非常有效的，特別是對于加鎖和解鎖操作需要在同一個函數中完成，為了防止在某個退出分支前意外的漏掉解鎖操作，可以采用該技巧，見如下代碼：

template<typename LockT> 
class ScopedLock { 
public: 
ScopedLock(T& lock) : _lock(lock) { 
_lock.lock(); 
} 
 
~ScopedLock() { 
_lock.unlock(); 
} 
private: 
LockT _lock; 
}; 
 
void testFunc() { 
ScopedLock s1(myLock); 
if (cond1) { 
return; 
} else if (cond2) { 
//TODO: do something 
return; 
} else { 
//TODO: do something 
} 
return; 
} 

對于以上代碼，無論函數從哪個分支退出，s1的析構函數都將調用，因此myLock的解鎖操作也會被調用。

6) 異常堆棧跟蹤：通過Throwable的getStackTrace方法獲取在異常即將被拋出的時間點上程序的調用堆棧，這樣有利于日志的輸出和錯誤的分析，見如下代碼：

public void testStackTrace() { 
try { 
//TODO: call function, which may be raise some exception. 
} catch (Throwable e) { 
StackTraceElement[] frames = e.getStackTrace(); 
for (StackTraceElement f : frames) { 
System.out.printf("Filename is = %s\n",f.getFileName()); 
System.out.printf("LineNumber is = %d\n",f.getLineNumber()); 
System.out.printf("ClassName is = %s\n",f.getClassName()); 
System.out.printf("Methodname is = %s\n",f.getMethodName()); 
System.out.printf("isNativeMethod = %s\n",f.isNativeMethod() ? "true" : "false"); 
} 
} 
} 

也可以直接通過Throwable對象函數當前函數的運行棧信息，見如下代碼：

public static void main(String[] args) { 
Throwable e = new Throwable(); 
StackTraceElement[] frames = e.getStackTrace(); 
for (StackTraceElement f : frames) { 
System.out.printf("Filename is = %s\n",f.getFileName()); 
System.out.printf("LineNumber is = %d\n",f.getLineNumber()); 
System.out.printf("ClassName is = %s\n",f.getClassName()); 
System.out.printf("Methodname is = %s\n",f.getMethodName()); 
System.out.printf("isNativeMethod = %s\n",f.isNativeMethod() ? "true" : "false");  
} 
}  
/* 輸入如下： 
Filename is = TestMain.java 
LineNumber is = 3 
ClassName is = TestMain 
Methodname is = main 
isNativeMethod = false */ 

C++語言本身并未提供這樣的方法，只是提供了__FUNCTION__、__LINE__、__FILE__這樣的3個宏來獲取當前函數的函數名、行號和文件名，但是無法得到調用棧信息，如果確實需要這樣的信息，只能通過操作系統的工具包來協助完成(僅針對Debug版本)，目前Windows(vc)和Linux(gcc)都提供這樣的開發包。

2. 斷言：是主要用于開發、調試和系統集成測試期間進行Debug的一種方式和技巧，語法如下：

assert condition OR assert condition : expression 

其中assert為關鍵字，當condition為false時，程序運行中斷，同時報出指定的錯誤信息，如果使用assert的后面一種形式，expression的結果將會同時輸出，這樣更有助于錯誤的判斷，見如下兩種代碼形式：

public static void main(String[] args) { 
int a = 5; 
assert a > 10 : a; 
System.out.println("Ok."); 
} 
/* 輸出結果： 
Exception in thread "main" java.lang.AssertionError: 5 
at TestMain.main(TestMain.java:4) 
*/ 
public static void main(String[] args) { 
int[] a = null; 
assert a != null; 
System.out.println("Ok."); 
} 
/* 輸出結果： 
Exception in thread "main" java.lang.AssertionError 
at TestMain.main(TestMain.java:4) 
*/ 

在eclipse中，缺省情況下斷言是被禁用的，如果需要開啟斷言，則需要在Run(Debug) As->Run(Debug) Configurations...->Arguments->VM arguments中添加"-enableassertions" 運行期參數。如果斷言被禁用，assert中的代碼不會被執行，因此在系統發布后也不會影響程序的運行時效率。使用者也可以通過該命令行參數-ea:MyClass -ea:com.mypackage.mylib 來指定需要啟用斷言的class和package，如果啟用的是package，那么該包內的所有class都將啟用斷言。在C++中，是依靠crt中的assert(cond)函數來實現的，如果cond為false，程序將會立即停止，但是在使用前首先需要保證assert.h文件被包含進當前文件，再有就是當前編譯的程序必須是Debug版本，對于Release版本，無論Win32和Linux，斷言的語句都將不會被執行。

原文鏈接：http://www.cnblogs.com/stephen-liu74/archive/2011/08/09/2131740.html

【系列文章】

1. Java和C++在細節上的差異:泛型程序設計
2. Java和C++在細節上的差異:程序設計結構
3. Java和C++在細節上的差異:枚舉與反射