Java和C++在细节上的差异(三) - JAVA

r);
13 private:
14 char* _name;
15 };
16 //将会调用重载后的这两个函数
17 class Employee {
18 Employee(Employee& other);
19 const Employee& operator= (Employee& other);
20 private:
21 char* _name;
22 };
注：C++中有一种被称为引用计数的技术，经常会用在这个地方，以便提高对象copy的效率。

3. 接口与回调：严格意义上讲，回调这个属于更多的应用于C/C++这些支持基于过程编程的语言，Java中的回调是通过接口的方式来实现的，由于在接口的实现类中可以附带更多的信息，因此其表达能力要由于C/C++中的函数指针，见如下代码：
1 public class Thread {
2 public Thread(Runnable r) {}
3 }
4
5 public class MyTask implements Runnable {
6 public MyTask(int taskID) {
7 _taskID = taskID;
8 }
9
10 public void setOk(bool ok) {
11 _ok = ok;
12 }
13
14 public void run() {}
15 }
16
17 public static void main(String[] args){
18 MyTask t = new MyTask(5);
19 Thread thrd = new Thread(t);
20 t.setOk(true);
21 thrd.start();
22 }
这里的Runnable参数既为接口，Thread对象在启动的时候会调用该接口实现对象的run方法，但是在调用之前可以给该实现类传入更多的状态等相关数据，以便在线程类调用run方法时可以得到更多的信息。
以下为回调函数在C/C++中的实现：
1 typedef int(*TestCallback)(int,int);
2 int testCaller(TestCallback cb,int a,int b) {
3 return cb(a,b);
4 }
5
6 int testCallback(int a,int b) {
7 return a * b;
8 }
9
10 int main() {
11 TestCallback cb = testCallback;
12 return testCall(cb,5,6);
13 }

在C++中还可以通过模板以更加松散的方式完成类似Java的基于接口的回调(Java的回调方式，C++完全可以做到)，见如下代码：
1 template
2 class Thread {
3 public:
4 Thread(T* r) _r = r {}
5 void start() { if (_r) _r->run(); }
6 private:
7 T* _r;
8 }
在以上的实现中，T无需是某个接口的实现类，只要保证该类型包含run()方法即可，注意：C++中的模板是引用才编译的方式，如果没有任何Thread的声明，不会导致任何编译错误，只有当声明的类型对象中不包含run()方法时才会导致编译错误。

4. 内部类：Java中内部类可以为私有内部类，既只有外部类可以访问该内部类，而Java外部类的可见性只有包可见和public两种。C++中的内部类比较类似于Java中的静态内部类，只是一种作用域限制的行为，以下为Java非静态内部类的说明：
1) 内部类可以访问外部类的所有域成员和域字段，这也同样包括私有的字段和成员。
2) Java的编译器在构造外部类调用内部类构造方法时，自动将外部类的this变量作为一个隐式参数传给了内部类的构造函数，内部类则在构造函数中保留了this变量的引用，该行为为编译器隐式行为。
1 public class Employee {
2 public class InnerClass {
3 bool test() {
4 //这里的_jobYears为外部类域字段。
5 return _jobYears > 10;
6 }
7 }
8
9 public Employee(int jobYears,String name) {
10 _name = name;
11 _jobYears = jobYears;
12 _salary = 0;
13 }
14
15 public void raiseSalary() {
16 //编译器的会将以下构造隐式替换为InnerClass inner = new InnerClass(this);
17 //因为Java在为其编译的时候发现InnerClass为非静态内部类，则自动添加了以下构造：
18 //public InnerClass(Employee e)
19 InnerClass inner = new InnerClass();
20 if (test())
21 _salary += 1000;
22 }
23 private String _name;
24 private int _jobYears;
25 private int _salary;
26 }
注：针对以上事例，内部类InnerClass可以通过Employee.this._jobYears的全称来显式的代替_jobYears > 10 中的_jobYears。反过来在raiseSalary方法中可以通过this.new InnerClass()语法格式更加明确的创建InnerClass的对象。
1 public class Employee {
2 public class InnerClass {
3 bool test() {
4 //这里的_jobYears为外部类域字段。
5 return Employee.this._jobYears > 10;
6 }
7 }
8
9

Java和C++在细节上的差异(三) (二)