Java 从入门到进阶之路（二）

之前的文章我们介绍了一下用 IDEA 编辑器创建一个 Java 项目并输出 HelloWorld，本章我们来看一下 Java 中的变量和基本数据类型。

在这之前我们先来看一下 Java 中的关键字，这些关键字不能被用作变量名称。

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	新,创建
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用
	null	空

Java注释

类似于 C/C++、Java 也支持单行以及多行注释。注释中的字符将被 Java 编译器忽略。

package com.demo;
/** 这是第一个Java程序
 * 这是一个多行注释的示例
 */
public class HelloWorld {
    public static void main(String[] args) {
        // 这是单行注释的示例
        /* 这个也是单行注释的示例 */
        System.out.println("Hello World");
    }
}

Java 基本数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

int 

int 数据类型是32位、有符号的以二进制补码表示的整数，占4个字节；

• 最小值 -2,147,483,648（-2^31），
• 最大值 2,147,483,647（2^31 - 1），
• 整数直接量默认为 int 型，不能超范围，否则会编译错误，
• 两个整数相除，结果还是整数，小数位无条件舍弃，
• 运算时超出范围会发生溢出

package com.demo;

public class HelloWorld {
    public static void main(String[] args) {
        // int a = "123"; 编译错误
        // int a = 123.123; 编译错误
        // int a = 2147483648; 编译错误，超出最大值 2147483647
        // int a = -2147483649; //编译错误，超出最大值 -2147483648
        int a = 1;  // 声明变量 a 为整数 1
        int b = 2147483647;
        int c;
        c = 1 + b;
        System.out.println(c); // -2147483648，运算超出范围发生溢出
        c = 2 + b;
        System.out.println(c); // -2147483647，运算超出范围发生溢出
    }
}

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 存储。

public class HelloWorld {
    public static void main(String[] args) {
        // long a = "123"; 编译错误
        // long a = 123.123; 编译错误
        // long a = 9223372036854775808L; //编译错误，超出最大值 9223372036854775807
        // long a = -9223372036854775809L; //编译错误，超出最大值 -9223372036854775808
        long a = 100L;  // 声明变量 a 为长整数 100
        long b = 9223372036854775807L;
        long c;
        c = 1 + b;
        System.out.println(c); // -9223372036854775808，运算超出范围发生溢出
        c = 2 + b;
        System.out.println(c); // -9223372036854775807，运算超出范围发生溢出
        long d = System.currentTimeMillis();
        System.out.println(d); // 当前时间毫秒数 1558516383355
    }
}

byte

byte 数据类型是8位、有符号的，以二进制补码表示的整数；占1个字节

• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
• byte类型运算的时候自动转换为int类型

public class HelloWorld {
    public static void main(String[] args) {
        // byte a = "123"; 编译错误
        // byte a = 123.123; 编译错误
        // byte a = 128; 编译错误，超出最大值 127
        // byte a = -129; //编译错误，超出最大值 -128
        byte a = 1;  // 声明变量 a 为byte 1
        byte b = 127;
        // b = 1 + b;
        // System.out.println(b); // 编译错误，byte 参与运算自动转为 int

        // 可以转换为 byte 型数据
        b = (byte) (1 + b);
        System.out.println(b); // -128，超出运算范围发生溢出
    }
}

short

short 数据类型是 16 位、有符号的以二进制补码表示的整数，占2个字节

• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• 默认值是 0
• short 数据类型也可以像 byte 那样节省空间。一个 short 变量是int型变量所占空间的二分之一；
• short 类型运算的时候自动转换为int类型

public class HelloWorld {
    public static void main(String[] args) {
        // short a = "123"; 编译错误
        // short a = 123.123; 编译错误
        // short a = 32768; 编译错误，超出最大值 32767
        // short a = -32769; //编译错误，超出最大值 -32768
        short a = 1;  // 声明变量 a 为short 1
        short b = 32767;
        // b = 1 + b;
        // System.out.println(b); // 编译错误，short 参与运算自动转为 int

        // 可以转换为 short 型数据
        b = (short) (1 + b);
        System.out.println(b); // -32768，超出运算范围发生溢出
    }
}

double，float

double 浮点型数据，数据类型是双精度、64 位

float 浮点型数据，数据类型是单精度、32位

• 浮点数的默认类型为 double 类型；
• 表示 float 型数据的直接量需要加 f 或 F 后缀。
• double 类型的精度值是 float 类型的两倍
• 大多数场合使用 double 表示浮点型
• float 在储存大型浮点数组的时候可节省内存空间
• 浮点数运算时，可能会发生摄入误差
• 浮点数不能用来表示精确的值，如货币

public class HelloWorld {
    public static void main(String[] args) {
        // float a = "123"; 编译错误
        // double a = "123"; 编译错误
        float a = 5.0F;
        a = a - 4.3F;
        System.out.println(a); // 0.6999998

        double b = 5.0;
        b = b - 4.3;
        System.out.println(b); // 0.7000000000000002
    }

boolean 

布尔型，只能取值为 true 或 false，占一个字节，默认为 false

public class HelloWorld {
    public static void main(String[] args) {
        // boolean a = "111"; // 编译错误
        boolean a = true;
        System.out.println(a); // true
        boolean b = false;
        System.out.println(b); // false
    }
}

char

char类型是一个单一的 16 位 Unicode 字符；

• 最小值是 u0000（即为0）；
• 最大值是 uffff（即为65,535）；
• char 数据类型可以储存任何字符；
• 任意单字符需加单引号 ' ' 

public class HelloWorld {
    public static void main(String[] args) {
        // char a = "123"; 编译错误
        // char a = 123.123; 编译错误
        // char a = 65536; 编译错误，超出最大值 65535
        // char a = -1; //编译错误，超出最小值 0
        // char a = '197'; //编译错误 因为有单引号，表示是字符，只允许放单个字符。
        // char a = 'a' + b; //编译错误 因为b是一个赋值的变量。
        // char a = '中' + '国' + '国' + '国'; //报错 int转char有损失。因为结果已经超出char类型的范围。
        // char a = '中' + "国"; //报编译错误 String无法转换为char。
        char a='1';  //任意单个字符，加单引号。
        char a='中'; //任意单个中文字，加单引号。
        char a = 'a' + 'b'; //Ã  char类型相加，提升为int类型，输出对应的字符。
        int a = 'a' + 'b'; //195 195没有超出int范围，直接输出195。
        char a = 197; //Ã 输出字符编码表中对应的字符。
        char a = 'a' + 1; //b 提升为int，计算结果98对应的字符是b。
        char a = '中' + '国';//42282。
        int a = '中' + '国' + '国' + '国'; //86820
        char a = '中' + 1; //丮 //1是int，结果提升为int，输出对应的字符。

        System.out.println('中' + "国"); //中国 没有变量附值的过程。String与任何字符用“+”相连，转换为String。
    }
}

不同的基本类型可以直接相互转换

• 自动转换（隐式转换）：从小类型到到类型可以自动完成，类型的大小关系：byte -> short -> int -> long -> float -> double，其中 char -> int 单独。
  
• 强行转换：从大类型到小类型需要强制转换符：（需要转换的类型）变量。但这样转换可能会造成精度损失或者溢出。

在上面的示例代码中已经演示过强转了，这里就不在举例了。

隐含强制类型转换

• 1. 整数的默认类型是 int。

• 2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。