Java中的数据类型和值传递

Java中的数据类型

Java提供了两种数据类型：一种是基本类型（原始类型），一种是引用类型。

Java是一种强类型语言，这就意味着必须为每一个变量声明一种类型。

在 Java 中，有 8 种基本数据类型（primitive type），其中有 4 种整型（byte、short、int、long）、2 种浮点型（float、double）、1 种用于表示Unicode编码的字符单元的字符类型 char 和 1 种用于表示真值的 boolean 类型。

Java对基本数据类型特殊对待，是由于用 new 创建对象（特别是小的、简单的变量）并不是非常有效，因为 new 将对象置于“堆”里。对于这些类型，Java 采纳了与 C 、C++相同的方法，不是用 new 创建变量，而是创建一个并非句柄的“自动”变量。这个变量容纳了具体的值，并置于栈中，能够更高效地存取。 Java 决定了每种主要类型的大小，不随着机器结构的变化而变化，这是 Java 程序具有很强移植能力的原因之一。Java 没有任何无符号类型（unsigned）。

此外，Java有 5种引用类型（对象类型）：类、接口类型、数组类型、枚举类型、 注解类型。

基本数据类型位数和范围

类型	位数	最小值	最大值	默认值
byte	8	-128（-2^7）	127（2^7-1）	0
short	16	-32768（-2^15）	32767（2^15 - 1）	0
int	32	-2,147,483,648（-2^31）	2,147,483,647（2^31 - 1）	0
long	64	-9,223,372,036,854,775,808（-2^63）	9,223,372,036,854,775,807（2^63 -1）	0L
float	32	-	-	0.0f
double	64	-	-	0.0
boolean	1	只有两个取值：true 和 false	-	false
char	16	\u0000（即为0）	\uffff（即为65,535）	\u0000

基本数据类型和引用数据类型的比较

基本数据类型	引用数据类型
在栈中进行分配	在堆中进行分配,堆的读写速度远不及栈
变量名指向具体的数值	变量名指向存数据对象的内存地址,即变量名指向hash值
变量在声明之后java就会立刻分配给他内存空间	它以特殊的方式(类似C指针)指向对象实体（具体的值），这类变量声明时不会分配内存，只是存储了一个内存地址
基本类型之间的赋值是创建新的拷贝	对象之间的赋值只是传递引用
“==”和“!=”是在比较值	“==”和“!=”是在比较两个引用是否相同，需要自己实现equals()方法
基本类型变量创建和销毁很快	类对象需要JVM去销毁

 

Java中的值传递

方法的参数分为实际参数和形式参数。

• 形式参数：定义方法时写的参数。
• 实际参数：调用方法时写的具体数值。

Java中只有值传递，没有引用传递。
一般情况下，Java在传递参数的时候，基本数据类型传递值的拷贝，引用数据类型传递引用的地址值。

举例说明

1. 基本数据类型

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

// 交换两个数的值
public static void swap(int num1, int num2) {
    int temp = num1;
    num1 = num2;
    num2 = temp;
}

运行结果：

num1 = 10
num2 = 20

为什么 num1 和 num2 的值没有交换呢？

执行流程：
（1）主函数进栈，num1、num2初始化。
（2）调用swap方法，swap( )进栈，将main方法中的num1和num2的值，复制一份给swap中的参数 。
（3）swap方法中对自己栈内存中的 num1、num2 的值进行交换。
（4）swap方法运行完毕，swap方法中的num1和num2的值已经交换，但不影响主函数中的数据。
（5）swap方法出栈。
（6）主函数出栈。

2. 引用数据类型

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5};
    
    swap(arr);
    
    System.out.println("arr[0] = " + arr[0] + ", arr[4] = " + arr[4]);
}

// 将数组的第一个元素和最后一个元素交换
public static void swap(int[] arr) {
   int temp = arr[0];
   arr[0] = arr[arr.length -1];
   arr[arr.length - 1] = temp;
}

运行的结果：

arr[0] = 5, arr[4] = 1

为什么数组被改变了呢？

执行流程：

（1）主函数进栈，int[ ] arr初始化。
（2）调用change方法，change( )进栈，将main函数中的arr数组地址值，复制一份给自己参数arr。
（3）change方法中，根据地址值，找到堆中的数组，并将第一个元素的值改为5，最后一个元素改为1。
（4）change方法运行完毕，堆内存数组中第一个元素的值已经改变。
（5）change方法出栈。
（6）主函数出栈。

BUT！请看String类型的操作：

public static void main(String[] args) {
    String name = "Bob";

    change(name);

    System.out.println("name = " + name);
}

// 修改 name
public static void change(String name) {
    name = "Alice";
}

执行的结果：

name = Bob

为什么 name 没有改变呢？

这就神奇了！！！

String的API中有这么一句话：“their values cannot be changed after they are created”
意思是：String的值在创建之后不能被更改。

也就是说：对String对象的任何修改 等同于 重新创建一个对象，并将新的地址值赋值给name。

重点是要分清楚 对象引用 和 对象 的区别，name只是对象的引用，并不是对象，只是用它来指向真实的对象，方便操作指向的对象。

所以，就是 swap方法中的 name = "Alice" 等同于 name = new String("Alice");

其他引用类型的效果都是一致的，只是String类型的特殊性，看起来不是创建新对象。