之前的文章我们介绍了一下用 IDEA 编辑器创建一个 Java 项目并输出 HelloWorld，本章我们来看一下 Java 中的变量和基本数据类型。
在这之前我们先来看一下 Java 中的关键字，这些关键字不能被用作变量名称。
Java注释
类似于 C/C++、Java 也支持单行以及多行注释。注释中的字符将被 Java 编译器忽略。
1 package com.demo; 2 /** 这是第一个Java程序 3 * 这是一个多行注释的示例 4 */ 5 public class HelloWorld { 6 public static void main(String[] args) { 7 // 这是单行注释的示例 8 /* 这个也是单行注释的示例 */ 9 System.out.println("Hello World"); 10 } 11 }
Java 基本数据类型
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
int
int 数据类型是32位、有符号的以二进制补码表示的整数，占4个字节；
- 最小值 -2,147,483,648（-2^31），
- 最大值 2,147,483,647（2^31 - 1），
- 整数直接量默认为 int 型，不能超范围，否则会编译错误，
- 两个整数相除，结果还是整数，小数位无条件舍弃，
- 运算时超出范围会发生溢出
1 package com.demo; 2 3 public class HelloWorld { 4 public static void main(String[] args) { 5 // int a = "123"; 编译错误 6 // int a = 123.123; 编译错误 7 // int a = 2147483648; 编译错误，超出最大值 2147483647 8 // int a = -2147483649; //编译错误，超出最大值 -2147483648 9 int a = 1; // 声明变量 a 为整数 1 10 int b = 2147483647; 11 int c; 12 c = 1 + b; 13 System.out.println(c); // -2147483648，运算超出范围发生溢出 14 c = 2 + b; 15 System.out.println(c); // -2147483647，运算超出范围发生溢出 16 } 17 }
long
long 数据类型是 64 位、有符号的以二进制补码表示的整数，8个字节；
- 最小值是 -9,223,372,036,854,775,808（-2^63）
- 最大值是 9,223,372,036,854,775,807（2^63 -1）
- 长整型直接biang为在数字后面加 l 或 L
- 算数运算时有可能超范围，建议在第一个数字后加 l 或 L
- System.currentTimeMillis( ) 用于获取自 1970.1.1 零时至此时此刻所经历的毫秒数，用 long 存储。
1 public class HelloWorld { 2 public static void main(String[] args) { 3 // long a = "123"; 编译错误 4 // long a = 123.123; 编译错误 5 // long a = 9223372036854775808L; //编译错误，超出最大值 9223372036854775807 6 // long a = -9223372036854775809L; //编译错误，超出最大值 -9223372036854775808 7 long a = 100L; // 声明变量 a 为长整数 100 8 long b = 9223372036854775807L; 9 long c; 10 c = 1 + b; 11 System.out.println(c); // -9223372036854775808，运算超出范围发生溢出 12 c = 2 + b; 13 System.out.println(c); // -9223372036854775807，运算超出范围发生溢出 14 long d = System.currentTimeMillis(); 15 System.out.println(d); // 当前时间毫秒数 1558516383355 16 } 17 }
byte
byte 数据类型是8位、有符号的，以二进制补码表示的整数；占1个字节
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默认值是 0；
- byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
- byte类型运算的时候自动转换为int类型
1 public class HelloWorld { 2 public static void main(String[] args) { 3 // byte a = "123"; 编译错误 4 // byte a = 123.123; 编译错误 5 // byte a = 128; 编译错误，超出最大值 127 6 // byte a = -129; //编译错误，超出最大值 -128 7 byte a = 1; // 声明变量 a 为byte 1 8 byte b = 127; 9 // b = 1 + b; 10 // System.out.println(b); // 编译错误，byte 参与运算自动转为 int 11 12 // 可以转换为 byte 型数据 13 b = (byte) (1 + b); 14 System.out.println(b); // -128，超出运算范围发生溢出 15 } 16 }
short
short 数据类型是 16 位、有符号的以二进制补码表示的整数，占2个字节
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- 默认值是 0
- short 数据类型也可以像 byte 那样节省空间。一个 short 变量是int型变量所占空间的二分之一；
- short 类型运算的时候自动转换为int类型
1 public class HelloWorld { 2 public static void main(String[] args) { 3 // short a = "123"; 编译错误 4 // short a = 123.123; 编译错误 5 // short a = 32768; 编译错误，超出最大值 32767 6 // short a = -32769; //编译错误，超出最大值 -32768 7 short a = 1; // 声明变量 a 为short 1 8 short b = 32767; 9 // b = 1 + b; 10 // System.out.println(b); // 编译错误，short 参与运算自动转为 int 11 12 // 可以转换为 short 型数据 13 b = (short) (1 + b); 14 System.out.println(b); // -32768，超出运算范围发生溢出 15 } 16 }
double，float
double 浮点型数据，数据类型是双精度、64 位
float 浮点型数据，数据类型是单精度、32位
- 浮点数的默认类型为 double 类型；
- 表示 float 型数据的直接量需要加 f 或 F 后缀。
- double 类型的精度值是 float 类型的两倍
- 大多数场合使用 double 表示浮点型
- float 在储存大型浮点数组的时候可节省内存空间
- 浮点数运算时，可能会发生摄入误差
- 浮点数不能用来表示精确的值，如货币
1 public class HelloWorld { 2 public static void main(String[] args) { 3 // float a = "123"; 编译错误 4 // double a = "123"; 编译错误 5 float a = 5.0F; 6 a = a - 4.3F; 7 System.out.println(a); // 0.6999998 8 9 double b = 5.0; 10 b = b - 4.3; 11 System.out.println(b); // 0.7000000000000002 12 }
boolean
布尔型，只能取值为 true 或 false，占一个字节，默认为 false
1 public class HelloWorld { 2 public static void main(String[] args) { 3 // boolean a = "111"; // 编译错误 4 boolean a = true; 5 System.out.println(a); // true 6 boolean b = false; 7 System.out.println(b); // false 8 } 9 }
char
char类型是一个单一的 16 位 Unicode 字符；
- 最小值是 \u0000（即为0）；
- 最大值是 \uffff（即为65,535）；
- char 数据类型可以储存任何字符；
- 任意单字符需加单引号 ' '
1 public class HelloWorld { 2 public static void main(String[] args) { 3 // char a = "123"; 编译错误 4 // char a = 123.123; 编译错误 5 // char a = 65536; 编译错误，超出最大值 65535 6 // char a = -1; //编译错误，超出最小值 0 7 // char a = '197'; //编译错误 因为有单引号，表示是字符，只允许放单个字符。 8 // char a = 'a' + b; //编译错误 因为b是一个赋值的变量。 9 // char a = '中' + '国' + '国' + '国'; //报错 int转char有损失。因为结果已经超出char类型的范围。 10 // char a = '中' + "国"; //报编译错误 String无法转换为char。 11 char a='1'; //任意单个字符，加单引号。 12 char a='中'; //任意单个中文字，加单引号。 13 char a = 'a' + 'b'; //Ã char类型相加，提升为int类型，输出对应的字符。 14 int a = 'a' + 'b'; //195 195没有超出int范围，直接输出195。 15 char a = 197; //Ã 输出字符编码表中对应的字符。 16 char a = 'a' + 1; //b 提升为int，计算结果98对应的字符是b。 17 char a = '中' + '国';//42282。 18 int a = '中' + '国' + '国' + '国'; //86820 19 char a = '中' + 1; //丮 //1是int，结果提升为int，输出对应的字符。 20 21 System.out.println('中' + "国"); //中国 没有变量附值的过程。String与任何字符用“+”相连，转换为String。 22 } 23 }
不同的基本类型可以直接相互转换
- 自动转换（隐式转换）：从小类型到到类型可以自动完成，类型的大小关系：byte -> short -> int -> long -> float -> double，其中 char -> int 单独。
- 强行转换：从大类型到小类型需要强制转换符：（需要转换的类型）变量。但这样转换可能会造成精度损失或者溢出。
在上面的示例代码中已经演示过强转了，这里就不在举例了。
隐含强制类型转换
1. 整数的默认类型是 int。
2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。