Java中的数据类型

Java数据类型介绍

Java中的数据类型包括两种，分别是：
● 基本数据类型
● 引用数据类型

Java中的基本数据类型又包括四类8种：
● 整数型（不带小数的数字）：byte,short,int,long
● 浮点型（带小数的数字）：float,double
● 字符型（文字，单个字符）：char
● 布尔型（真和假）：boolean
什么是编码？什么是解码？我们拿’a’来解释：
● ‘a’ ----（以ASCII字符集进行编码）----> 01100001
● 01100001----（以ASCII字符集进行解码）----> ‘a’
大家一定要注意：编码和解码要采用同一种字符编码方式（要采用同一个对照表），不然会出现乱码。
java为了国际化，为了支持所有国家的语言，所以java采用的编码方式为Unicode编码。

Java字符型和整数类型

字符型
字符型char在java语言中占用2个字节，char类型的字面量必须使用半角的单引号括起来，取值范围为[0-65535]，char和short都占用2个字节，但是char可以取到更大的正整数，因为char类型没有负数。java语言中的char类型变量可以容纳一个汉字。
\n表示换行符，\’表示普通的单引号字符，\表示一个普通的\字符，\”表示一个普通的双引号字符，\u后面的十六进制是文字的Unicode编码。
整数类型
整数型数据在java中有三种表示方式，分别是十进制、八进制、十六进制。默认为十进制，以0开始表示八进制，以0x开始表示十六进制。
● 十进制：0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17…
● 八进制：0,1,2,3,4,5,6,7,10,11,12,13,14,15,16,17,20,21…
● 十六进制：0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,10,11…
在java语言当中，整数型字面量被当做int类型处理，如果想表示long类型则需要在字面量后面添加L/l，建议大写L，因为小写l和1不好区分。

public class Test01 {
	public static void main(String[] args) {
		
		//声明一个int类型的变量a
		//100被默认当做int类型处理
		//以下代码不存在类型转换
		int a = 100;
		
		//100被默认当做int类型处理，占用4个字节
		//b变量是long类型，默认可容纳8个字节
		//小容量转换成大容量，叫做自动类型转换
		long b = 100;
		
		//b变量long类型，占用8个字节
		//c变量int类型，占用4个字节
		//大容量不能直接赋值给小容量，编译报错了
		//int c = b;
		
		//强制类型转换需要添加强制类型转换符
		//强制类型转换时可能引起精度损失，谨慎使用
		int c = (int)b;
		
		//a是int类型
		//b是long类型
		//c是int类型
		//多种数据类型混合运算时先转换成容量最大的再做运算
		//最终的结果是long类型，大容量无法直接赋值给小容量
		//所以编译报错了
		//int d = a + b + c;
		
		//解决以上编译错误
		int d = (int)(a + b + c);
		System.out.println("d = " + d);
		//或者
		long d2 = a + b + c;
		System.out.println("d2 = " + d2);
		
//100L被当做long类型处理
		//x变量是long类型
		//不存在类型转换
		long x = 100L;
		System.out.println("x = " + x);
	}
}

小容量转换成大容量叫做自动类型转换，大容量转换成小容量叫做强制类型转换，强制类型转换要想编译通过必须添加强制类型转换符，虽然编译通过了，但运行阶段可能出现精度损失，谨慎使用。
接下来我们一起来看看精度损失的情况：运行结果如下图所示：

4个字节的int类型300强转为1个字节的byte类型，最终的结果是44，为什么呢？首先300对应的二进制码是：00000000 00000000 00000001 00101100，强制类型转换的时候会变成1个字节，这个时候底层是将前3个字节砍掉了，也就是最后的二进制码是：00101100，这个二进制码对应的是44。
接下来我们再来看一下如果精度损失之后成为负数的情况：

public class Test02 {
	public static void main(String[] args) {
		int a = 300;
		byte b = (byte)a;
		System.out.println("b = " + b);
	}
}

运行结果如下图所示：
为什么以上的运行结果是-106呢？那是因为计算机在任何情况下都是采用二进制补码的形式存储数据的。
计算机二进制编码方式包括原码、反码、补码。对于正数来说原码、反码、补码是同一个。对于负数来说呢？负数的反码是在其原码的基础上, 符号位不变，其余各个位取反。
当一个整数型的字面量没有超出byte,short,char的取值范围，可以将该字面量直接赋值给byte,short,char类型的变量。

Java布尔类型

在Java语言中布尔类型的值只包括true和false，没有其他值，不包括1和0，布尔类型的数据在开发中主要使用在逻辑判断方面。

public class BooleanTest {
	public static void main(String[] args) {
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入第1个整数 ： ");
		int a = s.nextInt();
		System.out.print("请输入第2个整数 ： ");
		int b = s.nextInt();
		if(a > b){
			System.out.println(a + " - " + b + " = " + (a - b));
		}else{
			System.out.println(b + " - " + a + " = " + (b - a));
		}
	}
}

在以上程序当中出现的System.out.print()可以输出信息但不换行，之前我们用的System.out.println()可以输出信息并换行。以上代码当中还有一段程序是专门用来接收用户键盘输入的。
1、 java.util.Scanner s = new java.util.Scanner(System.in);这行代码表示创建键盘扫描器对象，从键盘上扫描数据。
2、int a = s.nextInt();执行到这行代码的时候，程序会停下来等待用户的输入。这个方法只能接收整数类型的数据。
3、另外扩展一下：String str = s.next();这行代码是专门用来接收用户输入字符串类型数据的。

Java浮点类型

浮点型数据实际上在内存中存储的时候大部分情况下都是存储了数据的近似值，为什么呢？这是因为在现实世界中存在无穷的数据，例如：3.333333333333333333…，数据是无穷的，但是内存是有限的，所以只能存储近似值，float单精度占4个字节，double双精度占8个字节，相对来说double精度要高一些。由于浮点型数据存储的是近似值，所以一般判断两个浮点型数据是否相等的操作很少。
在java语言中有这样的一条规定：只要是浮点型的字面量，例如1.0、3.14等默认会被当做double类型来处理，如果想让程序将其当做float类型来处理，需要在字面量后面添加f/F。

Java基本数据类型转换

Java基本数据类型之间是存在固定的转换规则的，现总结出以下6条规则，无论是哪个程序，将这6个规则套用进去，问题迎刃而解：
（1）八种基本数据类型中，除boolean类型不能转换，剩下七种类型之间都可以进行转换；
（2）如果整数型字面量没有超出byte,short,char的取值范围，可以直接将其赋值给byte,short,char类型的变量；
（3）小容量向大容量转换称为自动类型转换，容量从小到大的排序为：byte < short(char) < int < long < float < double
注：short和char都占用两个字节，但是char可以表示更大的正整数；
（4） 大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用；
（5）byte,short,char类型混合运算时，先各自转换成int类型再做运算；
（6）多种数据类型混合运算，各自先转换成容量最大的那一种再做运算。
我们来看一下以下代码，指出哪些代码编译报错，以及怎么解决：

public class Test03{
	public static void main(String[] args) {
		byte b1 = 1000;
		byte b2 = 20;
		short s = 1000;
		int c = 1000;
		long d = c;
		int e = d;
		int f = 10 / 3;
		long g = 10;
		int h = g / 3;
		long m = g / 3;
		byte x = (byte)g / 3;
		short y = (short)(g / 3);
		short i = 10;
		byte j = 5;
		short k = i + j;
		int n = i + j;
		char cc = 'a';
		System.out.println("cc = " + cc);
		System.out.println((byte)cc);
		int o = cc + 100;
		System.out.println(o);
	}
}

编译报错，错误信息如下所示：

如何修改，请看以下代码：

public class Test03 {
	public static void main(String[] args) {
		//1000超出byte取值范围，不能直接赋值
		//byte b1 = 1000;
		//如果想让上面程序编译通过，可以手动强制类型转换，但程序运行时会损失精度
		byte b1 = (byte)1000;
		//20没有超出byte取值范围，可以直接赋值
		byte b2 = 20;
		//1000没有超出short取值范围，可以直接赋值
		short s = 1000;
		//1000本身就是int类型，以下程序不存在类型转换
		int c = 1000;
		//小容量赋值给大容量属于自动类型转换
		long d = c;
		//大容量无法直接赋值给小容量
		//int e = d;
		//加强制类型转换符
		int e = (int)d;
		//int类型和int类型相除最后还是int类型，所以结果是3
		int f = 10 / 3;
		long g = 10;
		//g是long类型，long类型和int类型最终结果是long类型，无法赋值给int类型
		//int h = g / 3;
		//添加强制类型转换符
		int h = (int)(g / 3);
		//long类型赋值给long类型
		long m = g / 3;
		//g先转换成byte，byte和int运算，最后是int类型，无法直接赋值给byte
		//byte x = (byte)g / 3;
		//将以上程序的优先级修改一下
		byte x = (byte)(g / 3);
		short y = (short)(g / 3);
		short i = 10;
		byte j = 5;
		//short和byte运算时先各自转换成int再做运算，结果是int类型，无法赋值给short
		//short k = i + j;
		int n = i + j;
		char cc = 'a';
		System.out.println("cc = " + cc);
		//将字符型char转换成数字，'a'对应的ASCII是97
		System.out.println((byte)cc);
		//char类型和int类型混合运算，char类型先转换成int再做运算，最终197
		int o = cc + 100;
		System.out.println(o);
	}
}