Java和C++在细节上的差异:接口与内部类

继上篇文章：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字句中捕捉异常规范中标识的异常或他们的超类。
对于"运行时异常"(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++在细节上的差异:枚举与反射