3. Java中的对象变量和C++中对象指针的关系：
Java中的对象变量实际上类似与C++中的对象指针，Java中的对象变量实质上就是指向对象的对象指针，在对象变量变量中保存的是对象在内存中的实际地址.
因此，Java中两个对象的赋值不能用=，因为=号只是将两个变量指向同一个对象在内存中的地址。因此在这两个对象之间进行==比较时也只是比较这两个变量是否指向的是内存中的同一个对象，并不是比较两个对象的值是否相等！要比较两个对象是否相等，则需要使用equals方法！
因此在Java的类中的类访问器中不能直接返回一个可改变对象的引用，下面的代码说明了这一点：
import java.util.*;
publicclass EmployeeTest{
public static void main(String[] args)
{
Employee harry = new Employee("Harry Brown",,,,);
Date d = harry.getHireDay(); System.out.println(d); double tenYearsInMilliSeconds = *365.35****;
d.setTime(d.getTime()-(long)tenYearsInMilliSeconds); System.out.println(harry.getHireDay());
}
} class Employee
{
public Employee(String n, double s,
int year, int month, int day)
{
name = n;
salary = s;
GregorianCalendar calendar
= new GregorianCalendar(year, month - , day);
// GregorianCalendar uses 0 for January
hireDay = calendar.getTime();
} public String getName()
{
return name;
} public double getSalary()
{
return salary;
} public Date getHireDay()
{
return hireDay;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / ;
salary += raise;
} private String name;
private double salary;
private Date hireDay;
}
Wed Feb 03 00:00:00 CST 2010
这段代码的main函数中返回了一个可改变对象的引用，那么这个引用和这个可改变对象指向了同一块的内存对象，那么通过这个引用就可以修改这个内存对象！因此，这种所谓的“访问器”实际上破坏了封装性,解决方法是在返回可改变对象时先clone一个这个对象的副本，然后返回这个副本的引用。这样所有对这个返回引用的操作都执行在这个副本上，原来的对象并没改变：
public Date getHireDay()
{
return (Date)hireDay.clone();
}
结果:
4 . Java 和 C++ 在对象构造方面的差异:
Java中的实例域可以进行显示初始化，而C++中的数据域是不能显示初始化的！但C++在构造函数中可以提供一个数据域初始化列表!
Java代码:
public class TestConstruct
{
public static void main(String[] args)
{
TestConstruct tc = new TestConstruct();
System.out.println(tc.GetName());
}
public String GetName()
{
return name;
}
private String name = "Jim Green";
}
输出结果:
Jim Green
C++ 代码:
#include <iostream>#include <string> using namespace std; class Person
{
public:
Person(String& aname)
{
name = aname;
}
private:
string name = "Miracle Jiang";
} int main(void)
{ return ;
}
输出结果:
TestConstruct.cc::: warning: non-static data member initializers only available with -std=c++ or -std=gnu++ [enabled by default]
string name = "Miracle Jiang";
Java 类中的构造函数之间可以相互调用，可以将公共构造部分放到一个构造函数中，其他特殊构造函数共同调用这个公共构造函数，使用this(...)，C++中的构造函数之间不可以相互调用，但可以将所有公共构造部分放在一个成员函数init中，所有的构造函数调用这个构造函数。
下面这段代码来自《Core Java》一书，描述了不同的类的初始化方式:
1 /**
2 @version 1.00 2000-01-27
3 @author Cay Horstmann
4 */
5
6 import java.util.*;
7
8 public class ConstructorTest
9 {
public static void main(String[] args)
{
// fill the staff array with three Employee objects
Employee[] staff = new Employee[3];
staff[0] = new Employee("Harry", 40000);
staff[1] = new Employee(60000);
staff[2] = new Employee();
// print out information about all Employee objects
for (int i = 0; i < staff.length; i++)
{
Employee e = staff[i];
System.out.println("name=" + e.getName()
+ ",id=" + e.getId()
+ ",salary=" + e.getSalary());
}
}
}
class Employee
{
// three overloaded constructors
public Employee(String n, double s)
{
name = n;
salary = s;
}
public Employee(double s)
{
// calls the Employee(String, double) constructor
this("Employee #" + nextId, s);
}
// the default constructor
public Employee()
{
// name initialized to ""--see below
// salary not explicitly set--initialized to 0
// id initialized in initialization block
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public int getId()
{
return id;
}
private int id;
private static int nextId;
// object initialization block
{
id = nextId;
nextId++;
}
// static initialization block
static
{
Random generator = new Random();
// set nextId to a random number between 0 and 9999
nextId = generator.nextInt(10000);
}
private String name = ""; // instance variable initialization
private double salary;
}
5. Java 和 C++ 析构过程的差异
不要因为Java的垃圾回收机制而忽视了资源的手动回收！
Java有自带的垃圾回收机制，手动的内内存回收是不必要的，所以Java没有显示的支持构造函数。但是有时有些对象中的资源并不一定是内存资源，而有可能是
一个文件或者其他系统资源的句柄！在这些情况下，当这些资源不再被使用的时候，对其的释放就显得很重要了。
Java 中可以为每个类提供一个finalize函数，当垃圾回收器清除对象之前，finalize函数会被调用。但实际中不能依赖这个finalize函数来实现资源的回收，因为
finalize函数会出现一些未定义的行为。建议定义一个手工的方法来释放支援，而不是完全依赖Java语言的垃圾回收机制。例如，可以在类的定义中定义一个叫
close的方法，当使用完对象之后，调用close方法以释放占用的资源.