001 变量与数据类型-爱代码爱编程

1. 变量

变量和内存密切相关，所谓“变量”，本质上对应了一块内存空间。创建一个变量，就相当于申请了一块内存空间来存放数据。

1.1 变量的定义与使用

定义一个符号，同时为其初始化（赋值）。 变量必须先定义和初始化，才能被使用。

int num = 10;
// 这个变量有以下几部分内容
// 1.变量允许存储的数据类型
// 2.表示变量的符号 
// 3.变量中存储的值
// 4.这个操作的含义就是把10放到num对应的内存空间中

1.2 变量的命名规则

硬性指标：
（1）一个变量名只能包含数字、字母、下划线（虽然语法上也允许使用中文/美元符$命名变量，但是强烈不推荐这样做）；
（2）数字不能用作变量名开头；
（3）变量名是大小写敏感的，即 num 和 Num 是两个不同的变量；

软性指标：
（1）变量命名要具有描述性，见名知意；
（2）变量名不宜使用拼音（但是不绝对）；
（3）变量名最好采用“名词”词性的单词命名；
（4）变量命名推荐小驼峰命名法，当一个变量名由多个单词构成时，除了第一个单词之外, 其他单词首字母都大写；
小驼峰命名法示例：

int maxValue = 100; 
String studentName = "张三";

1.3 代码示例

public class Test {
    public static void main(String[] args){
        //输出"HelloWorld"
        System.out.println("HelloWorld");
        
		int num = 10;
        
        //输出的结果为"num = 10"
        System.out.println("num = " + num);
        
        //修改变量的值
        num = 20;
        
        //输出的结果为"num = 20"
        System.out.println("num = " + num);
    }
}

注意事项：
（1）类名必须与文件名一致（硬性要求）；
（2）类名首字母最好大写（软性要求）；
（3）写大括号时，" { " 最好和类名/方法名写在一行；
（4）类名的 public 和方法中的 public static 都是必须要写的；
（5）main 中的参数必须要写，而且固定写作 String[] 类型，是一个字符串数组；
（6）System 是一个类，System 中包含一个对象 out，里面有个方法叫 println（print -> 打印，ln -> line 的缩写，println 会默认打印换行符）；
（7）“HelloWorld” 是一个字符串 字面值。

1.4 变量的形态

注意：在Java中，没有全局变量，变量无法脱离类存在。

class Test { 
	static int a; //  静态属性/类成员变量/类变量 
	int b;        //  属性/成员变量/实例变量 
	
	public static void main(String[] args){
		int c;    //  局部变量 
	} 
}

1.5 变量的作用域

变量能生效的范围，一般是变量定义所在的代码块（大括号）。

示例一：

public class Test {
    public static void main(String[] args){
        {
            int x = 10;
            System.out.println(x); // 编译通过
        }
        System.out.println(x); // 编译失败, 找不到变量 x
    }
}

运行结果：

示例二：

public class Test {
    public static void main(String[] args){
        {
            int x = 10; // 这里定义了一个变量 x, 类型是 int, 值是 10
            System.out.println(x); // 会打印 10
        }
        {
            double x = 20.0; // 这里又定义了一个变量 x, 类型是 double, 值是 20.0
                             // 和上面的变量完全无关，只是用到的符号（变量名）相同
            System.out.println(x); // 会打印 20.0
        }
    }
}

运行结果：

2.数据的类型

Java的基本数据类型分“四类八种”：整型、浮点型、字符类型、布尔类型。

注意：
（1）在 C 语言中，一个 int 占几个字节，取决于操作系统；在 Java 中，一个 int 占固定的4个字节；
（2）字符 char 的含义更加广泛，不一定是一个字母，也可能是一个汉字；
（3）在 Java 中，真、假的概念就是 true 和 false，与1、0这样的整数不相关。

类型	占内存大小/字节
byte	1
short	2
int	4
long	8
float	4
double	8
char	2
boolean	–

3. 各类型变量的简述

3.1 整型变量

代码示例：

int num = 10; // 定义一个整型变量
System.out.println(num);
//使用以下代码查看 Java 中的整型数据范围
System.out.println(Integer.MAX_VALUE); // int的最大值 
System.out.println(Integer.MIN_VALUE); // int的最小值

运行结果：

注意事项：
（1）int 表示变量的类型是一个整型；
（2）变量名是变量的标识，后续都是通过这个名字来使用变量；
（3）Java 中 “=” 表示赋值（与数学不同），意思是给变量设置一个初始值；
（4）初始化操作是可选的，但是建议创建变量的时候都显式初始化；
（5）最后不要忘记分号，否则会编译失败；
（6）“//” 表示注释，注释作为代码的解释说明部分，不参与编译运行。

什么是字节?
字节是计算机中表示空间大小的基本单位.
计算机使用二进制表示数据，我们认为8个二进制位（bit）为一个字节（Byte）.
经常使用的计算机一般为 8GB 内存，意思是 8G 个字节.
其中 1KB = 1024 Byte，1MB = 1024 KB，1GB = 1024 MB.
所以 8GB 相当于 80多亿（102410241024*8 = 8589934592）个字节.

如果运算的结果超出了 int 的最大范围，就会出现溢出的情况。

int maxValue = Integer.MAX_VALUE;
System.out.println("maxValue   = " + maxValue);
System.out.println("maxValue+1 = " + (maxValue + 1));

int minValue = Integer.MIN_VALUE;
System.out.println("minValue   = " + minValue);
System.out.println("minValue+1 = " + (minValue - 1));

3.2 长整型变量

代码示例：

long num = 20L; // 定义一个长整型变量, 初始值写作 20l 也可以（小写的L, 不是数字1）
System.out.println("num = " + num);
System.out.println(Long.MAX_VALUE); // long的最大值
System.out.println(Long.MIN_VALUE); // long的最小值

运行结果：

注意事项：
（1）基本语法格式和创建 int 变量基本一致，只是把类型修改成 long；
（2）初始化设定的值为 20L，表示一个长整型的数字，20l 也可以；
（3）使用 20 初始化也可以，20 的类型是 int，10L 的类型是 long，使用 10L 或者 10l 更好一些；
（4）Java 中 long 类型占 8 个字节，表示的数据范围 -2^63 -> 2^63 -1

3.3 双精度浮点型变量

代码示例：

double num = 30.0; // 定义一个双精度浮点型变量
System.out.println("num = " + num);
System.out.println(Double.MAX_VALUE); // double的最大值
System.out.println(Double.MIN_VALUE); // double的最小值

运行结果：

神奇的代码：

int a1 = 1;
int b1 = 2;
System.out.println("a1 / b1 = " + (a1 / b1));

double a2 = 1.0;
double b2 = 2.0;
System.out.println("a2 / b2 = " + (a2 / b2));

double num = 1.1;
System.out.println("num * num = " + (num * num));

注意事项：
（1）在 Java 中，int 除以 int 的值仍然是 int（会直接舍弃小数部分），如果想得到 0.5，需要使用 double 类型计算；
（2）Java 中的 double 虽然也是 8 个字节，但是浮点数的内存布局和整数差别很大，不能单纯的用 2 ^ n 的形式表示数据范围；
（3）Java 的 double 类型的内存布局遵守 IEEE 754 标准（和C语言一样），尝试使用有限的内存空间表示可能无限的小数，势必会存在一定的精度误差。

3.4 单精度浮点型变量

代码示例：

float num = 1.0f;
System.out.println("num = " + num);
System.out.println(Float.MAX_VALUE); // float的最大值
System.out.println(Float.MIN_VALUE); // float的最小值

运行结果：

注意事项：float 类型在 Java 中占四个字节，同样遵守 IEEE 754 标准。由于表示的数据精度范围较小，一般在工程上用到浮点数都优先考虑 double，不太推荐使用 float。

3.5 字符类型变量

代码示例：

char ch1 = 'A';
char ch2 = '呵';
System.out.println(ch1);
System.out.println(ch2);

注意事项：
（1）Java 中使用“单引号 + 单个字母”的形式表示字符字面值；
（2）计算机中的字符本质上是一个整数，在 C 语言中使用 ASCII 表示字符，而 Java 中使用 Unicode 表示字符，因此一个字符占用两个字节，表示的字符种类更多，包括中文。

3.6 字节类型变量

代码示例：

byte num = 1;
System.out.println("num = " + num);
System.out.println(Byte.MAX_VALUE); // byte的最大值
System.out.println(Byte.MIN_VALUE); // byte的最小值

运行结果：

注意事项：
（1）字节类型表示的也是整数，只占一个字节，表示范围较小（-128 -> +127）；
（2）字节类型和字符类型互不相干。

3.7 短整型变量

代码示例：

short value = 10;
System.out.println("value = " + value);
System.out.println(Short.MAX_VALUE); // short的最大值
System.out.println(Short.MIN_VALUE); // short的最小值

运行结果：

注意事项：
（1）short 占用 2 个字节，表示的数据范围是 -32768 -> +32767；
（2）short 类型表示范围比较小，一般不推荐使用。

3.8 布尔类型变量

代码示例：

boolean value = true;
System.out.println("value = " + value);

运行结果：

注意事项：
（1）boolean 类型的变量只有两种取值，true 表示真，false 表示假；
（2）Java 的 boolean 类型和 int 不能相互转换，不存在 1 表示 true，0 表示 false 这样的用法；
（3）boolean 类型有些 JVM 的实现是占 1 个字节，有些是占 1 个比特位，没有明确规定。

错误示例：

boolean value = true;
System.out.println(value + 1);

3.9 字符串类型变量

注意： 把一些字符放到一起就构成了字符串。String 类型不是基本数据类型，而是引用数据类型，只是使用的频率非常高，所以需要优先了解。

代码示例：

String value = "HelloWorld";
System.out.println(value);
// 字符串拼接，当一个 “ + ” 表达式中存在字符串的时候, 都是执行字符串拼接行为
System.out.println(value + 123);

运行结果：

注意事项：
（1）Java 使用 “双引号 + 若干字符” 的方式表示字符串字面值；
（2）与前面的类型不同，String 不是基本类型，而是引用类型；
（3）字符串中一些特定的不太方便直接表示的字符需要进行转义。

常见的转义字符：

转义字符	含义
\n	换行
\r	回到行首
\t	水平制表符
\’	单引号
\"	双引号
\\	反斜杠

4. 字面量和常量

上面讨论的都是各种规则的变量，每种类型的变量也对应着一种相同类型的常量。常量指的是运行时类型不能发生改变，常量主要有以下两种体现形式：

4.1 字面值

 10      // int 字面值常量(十进制)
 010     // int 字面值常量(八进制) 由数字 0 开头，010 也就是十进制的 8 
 0x10    // int 字面值常量(十六进制) 由数字 0x 开头，0x10 也就是十进制的 16 
 10L     // long 字面值常量. 也可以写作 10l (小写的L) 
 1.0     // double 字面值常量，也可以写作 1.0d 或者 1.0D 
 1.5e2   // double 字面值常量，科学计数法表示，相当于 1.5 * 10^2 
 1.0f    // float 字面值常量，也可以写作 1.0F 
 true    // boolen 字面值常量，同样的还有 false 
 'a'     // char 字面值常量，单引号中只能有一个字符 
 "abc"   // String 字面值常量，双引号中可以有多个字符

4.2 final 关键字修饰的常量

final int a = 10;
a = 20; // 编译出错. 提示 无法为最终变量a分配值

运行结果：

5. 理解类型转换

Java 作为一个强类型的编程语言，当不同类型之间的变量相互赋值时，会有比较严格的校验。

5.1 int 和 long/double 相互赋值

int a = 10; 
long b = 20; 
a = b; // 编译出错, 提示可能会损失精度
b = a; // 编译通过

int a = 10; 
double b = 1.0; 
a = b; // 编译出错, 提示可能会损失精度
b = a; // 编译通过

long/double 表示的范围更大，可以将 int 赋值给 long/double，但是不能将 long/double 赋值给 int。
结论: 不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型，反之则不行。

5.2 int 和 boolean 相互赋值

int a = 10; 
boolean b = true; 
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型

结论: int 和 boolean 是毫不相干的两种类型，不能相互赋值。

5.3 int 字面值常量给 byte 赋值

byte a = 100; // 编译通过
byte b = 256; // 编译报错, 提示 从int转换到byte可能会有损失

注意: byte 表示的数据范围是 -128 -> +127，256 已经超过范围, 而 100 还在范围之内。
结论: 使用字面值常量赋值的时候，Java 会自动进行一些检查校验，判定赋值是否合理。

5.4 使用强制类型转换

int a = 0; 
double b = 10.5; 
a = (int)b; 

int c = 10; 
boolean d = false; 
d = (boolean)c; // 编译出错, 提示不兼容的类型

结论:
使用（类型）的方式可以将 double 类型强制转成 int，但是强制类型转换可能会导致精度丢失，如上面的例子中，赋值之后 10.5 就变成 10 了，小数点后面的部分被忽略；强制类型转换不一定能成功，互不相干的类型之间无法强转。

5.5 int 和 String 之间的相互转换

int 转成 String

int num = 10; 
// 方法1 
String str1 = num + ""; 
System.out.println(str1);

// 方法2 
String str2 = String.valueOf(num);
System.out.println(str2);

String 转成 int

String str = "100"; 
int num = Integer.parseInt(str);

5.6 类型转换小结

（1）不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型；
（2）如果需要把范围大的类型赋值给范围小的类型，需要强制类型转换，但是可能造成精度丢失；
（3）将一个字面值常量进行赋值时，Java 会自动针对数字范围进行检查。

6. 理解数值提升

6.1 int 和 long 混合运算

int a = 10; 
long b = 20; 
int c = a + b;  // 编译出错, 提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过

结论: 当 int 和 long 混合运算的时候，int 会提升成 long，得到的结果仍然是 long 类型，需要使用 long 类型的变量来接收结果，如果非要用 int 来接收结果，就需要使用强制类型转换。

6.2 byte 和 byte 的运算

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c);

结论: byte 和 byte 都是相同类型，但是出现编译报错。虽然 a 和 b 都是 byte类型，但是计算 a + b 会先将 a 和 b 都提升成 int类型，再进行计算，得到的结果也是 int 类型，这时赋给 c，就会出现上述错误。由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据，为了硬件层面上实现方便，诸如 byte 和 short 这种低于 4 个字节的类型，会先提升成 int，再参与计算。

正确的写法：

byte a = 10; 
byte b = 20; 
byte c = (byte)(a + b); 
System.out.println(c);

7. 打印输出

基本语法

System.out.println(msg);         // 输出一个字符串, 带换行
System.out.print(msg);           // 输出一个字符串, 不带换行
System.out.printf(format, msg);  // 格式化输出
System.out.format(format, msg);  // 完全等同于 printf

注意：
（1）println 输出的内容自带 \n，print 不带 \n；
（2）printf 的格式化输出方式和 C 语言的 printf 是基本一致的。