Java虽然是个面向对象的语言，也声称“Everything is object”- 一切都是对象。但是，我觉得还不够纯粹和彻底，和ruby或者python比较一下就知道了。在Java中，数字和布尔类型就不被看做对象，而是被称为primitive类型。不过也不见的就不好，本文也不是想对此评论和分析。本文是想阐述Java的数据类型。

Java的数据类型

Java的数据类型分为两类：primitive和reference类型。我们可以从hold数据这个角度来说。primitive类型可以hold数字和布尔数据；reference类型可以hold对象，接口和数组类型的数据的指针。可以想象后一种数据比较复杂，往往是一段数据，不像primitive的数据是比较单纯的数据单元，比如int，float和boolean。

除了数据构成之外，它们在数据上的操作也大不相同。比如下面的代码，main函数里面的a和b可以进行加减运算。而x，y你就不能做加减，你只能通过他们引用或者说访问他们的数据元素。再想想对于对象引用的变量，你可以调用对象的方法。primitive类型的数据上你是不能做方法调用的。

你也许听说过primitive的值不能共享，而reference的值可以。什么意思呢？就是说，比如下面的代码(List 1)的aboutDataSharing，你认为会输出什么呢？

 从下面的输出你就可以看出，c和d没有共享数据，而r和s就共享数据了。

 
  
  1. c=11, d=9  
  2. r={2, 3}  
  3. s={2, 3}  
 
  
值传递还是引用传递
 
  
理解了上面的区别以后，我们再看看函数方法的参数传递。先看一个例子：
 
  
List 1
 
  
 
  
  1. package com.javasaloon.basis; 
  2.  
  3. public class PrimitiveAndReference { 
  4.     public static void main(String[] args) { 
  5.         aboutParamTransporting(); 
  6.         aboutDataSharing(); 
  7.     } 
  8.  
  9.     private static void aboutDataSharing() { 
  10.         int c = 10; 
  11.         int d = c; 
  12.         c++; 
  13.         d--; 
  14.         System.out.printf("c=%d, d=%d \n", c, d); 
  15.  
  16.         int[] r = new int[] { 1, 2 }; 
  17.         int[] s = r; 
  18.         r[0]++; 
  19.         s[1]++; 
  20.         System.out.printf("r={%d, %d} \n", r[0], r[1]); 
  21.         System.out.printf("s={%d, %d} \n", s[0], s[1]); 
  22.     } 
  23.  
  24.     private static void aboutParamTransporting() { 
  25.         int a = 1; 
  26.         int b = 2; 
  27.         swap(a, b); 
  28.         System.out.printf("a=%d, b=%d \n", a, b); 
  29.         int[] x = new int[] { 10, 20 }; 
  30.         int[] y = new int[] { 30, 50 }; 
  31.         swap(x, y); 
  32.         System.out.printf("x={%d, %d} \n", x[0], x[1]); 
  33.         System.out.printf("y={%d, %d} \n", y[0], y[1]); 
  34.     } 
  35.  
  36.     private static void swap(int[] is, int[] js) { 
  37.         int[] x = is; 
  38.         is = js; 
  39.         js = x; 
  40.     } 
  41.  
  42.     private static void swap(int i, int j) { 
  43.         int x = i; 
  44.         i = j; 
  45.         j = x; 
  46.     } 
  47.  
  48. } 
 
  
 
  
你不妨先想一下上面的aboutParamTransporting方法的输出结果。如果是用c语言写的上面的swap方法呢？
 
  
对于两个int的swap是没有区别的，他们都是值传递。但是对于两个int数组的swap
 
  
就不会一样，这也正是值传递和引用传递的区别。int数组变量x和y虽然是引用，
 
  
也可以被看做是数组的指针。但是java的方法中参数的传递是应用值的传递。Java
 
  
里面没有c语言一样的地址指针，这也是Java安全的基础，更是Java垃圾回收或者说
 
  
内存自动管理的关键。看看下面的结果吧：
 
  
 
  
  1. a=1, b=2  
  2. x={10, 20}  
  3. y={30, 50}  
 
  
Equals 和 == 的区别
 
  
理解了上面的例子，我们再看看Equals和==的区别。从概念上看，primitive和reference类型的数据都能进行==的比较，而且是值的比较。对于primitive来说，就是它hold的值得比较；而对于reference的比较，来说就是指针的比较，而不是它指向的对象数据的比较。如果两个reference的变量==之后得到true，说明他们共同指向同一段数据区也就是同一个对象，接口或者数组。那么，怎么进行对象数据的比较呢？这样你就得用对象的Equals方法了。Object类是所有Java类的父类，它给出了一个默认的实现，就是比较reference值，也就是说，如果你没有自己重写这个Equals方法，那么这两个比较操作的结果是一样的。如果你不想这样，你可以自己重写Equals方法。对于数组的数据的比较，你只能一个一个的遍历比较，也可以说是自己实现，只不过，数组reference变量上没有Equals方法，你也没办法扩展和重写。这样说明Java的面向对象的方面不够纯粹和彻底。
 
  
参考阅读：

 
  
Java的 Specification:  http://docs.oracle.com/javase/specs/