Java数据类型简介
程序是一套数字处理的游戏框架，就是说在整个程序开发的过程中，
所达到的最终目的就是对一些数据的处理过程，
那么既然要进行数据的处理，就一定需要提供有各种类型的数据定义。
Java数据分类：
在Java语言之中对于数据类型分为两类：
基本数据类型：描述的是一些具体的数字单元，例如：1、1.1；
数值型：
整型：byte、short、int、long； --> 默认值：0
浮点型：float、double； --> 默认值：0.0
布尔型：boolean； --> 默认值：false
字符型：char； --> 默认值：'\u0000'
引用数据类型：牵扯到内存关系的使用；
数组、类、接口。 --> 默认值：null
本次讨论的主要是基本数据类型，这里面不牵扯到复杂的内存关系的匹配操作。
每一种基本数据类型都有每一种类型保存的数据范围。
如下图1：
不同的类型保存有不同范围的数据，但是这里面实际上就牵扯到了数据类型的选择上，
那么对于以上的数据类型划分，给出个人的使用参考原则：
要是描述数字首选的一定是int（整数）、double（小数）；例如：年龄--int
要进行数据传输或者是进行文字编码转换使用byte类型（二进制处理操作）；
处理中文的时候最方便的操作使用的是字符char来完成（可选概念）；
描述内存或文件大小、描述表的主键列（自动增长）可以使用long；
会使得你的代码精进不少
1
整型数据
整型数据有四种，按照保存的范围由小到大：byte、short、int、long，
那么在Java里面任何的一个整型常量其默认的类型都是int型（只要是整数就是int类型的数据）。
范例：定义int型变量
d:\fgqjava目录下的文件JavaDemo.java
代码如下：
public class JavaDemo {
public static void main(String args[]) {
// int 变量名称 = 常量（10是一个常量，整数类型为int）；
int x = 10 ; // 定义了一个整数变量x
// int型变量 * int型变量 = int型数据
System.out.println(x * x) ;
}
}
执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
100
-------------------------------------------------------------
在上述代码中，10永远不会改变，但是x是一个变量，x的内容是可以改变的。
范例：修改x的内容
代码如下：
public class JavaDemo {
public static void main(String args[]) {
// int 变量名称 = 常量（10是一个常量，整数类型为int）；
int x = 10 ; // 定义了一个整数变量x
x = 20 ; // 改变了x的已有内容（新增）
// int型变量 * int型变量 = int型数据
System.out.println(x * x) ;
}
}
执行命令：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
400
-------------------------------------------------------------
任何的数据类型都是有其可以保存的数据范围的（正常使用下你很少会出现超过此范围的数据），
那么如果真的超过了，会如何呢？下面通过一个具体代码进行观察。
范例：观察超过了int处理范围
代码如下：
public class JavaDemo {
public static void main(String args[]) {
int max = Integer.MAX_VALUE ; // 获取int的最大值
int min = Integer.MIN_VALUE ; // 获取int的最小值
System.out.println(max) ; // 2147483647
System.out.println(min) ; // -2147483648
}
}
命令执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
2147483647
-2147483648
修改代码如下：
public class JavaDemo {
public static void main(String args[]) {
int max = Integer.MAX_VALUE ; // 获取int的最大值
int min = Integer.MIN_VALUE ; // 获取int的最小值
System.out.println(max) ; // 2147483647
System.out.println(min) ; // -2147483648
System.out.println("---------- 无以言表的分割线 ----------") ;
// int型变量 + int型常量 = int型计算结果
System.out.println(max + 1) ; // -2147483648，最大值 + 1 = 最小值
System.out.println(max + 2) ; // -2147483647，最大值 + 2 = 次最小值
// int型变量 - int型常量 = int型计算结果
System.out.println(min - 1) ; // 2147483647，最小值 - 1 = 最大值
}
}
命令执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
2147483647
-2147483648
---------- 无以言表的分割线 ----------
-2147483648
-2147483647
2147483647
-------------------------------------------------------------
通过此时的执行结果可以发现这些数字在进行处理的时候，
如果超过了其最大的保存范围，那么将出现有循环的问题，
而这样的问题在Java中被称为数据溢出，如果要想解决这种溢出，
那么可以继续扩大使用范围，比int范围更大的是long。
范例：解决数据溢出
方法1：在操作的时候预估数据范围，如果发现范围不够就使用更大范围：
修改代码如下：
public class JavaDemo {
public static void main(String args[]) {
// long long变量 = int的数值
long max = Integer.MAX_VALUE ; // 获取int的最大值
long min = Integer.MIN_VALUE ; // 获取int的最小值
System.out.println(max) ; // 2147483647
System.out.println(min) ; // -2147483648
System.out.println("---------- 无以言表的分割线 ----------") ;
// long型变量 + int型常量 = long型计算结果
System.out.println(max + 1) ; // 2147483648
System.out.println(max + 2) ; // 2147483649
// long型变量 - int型常量 = long型计算结果
System.out.println(min - 1) ; // -2147483649
}
}
命令执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
2147483647
-2147483648
---------- 无以言表的分割线 ----------
2147483648
2147483649
-2147483649
-------------------------------------------------------------
范例：解决数据溢出
方法2：除了可以定义long型的变量之外，也可以直接在常量上进行处理，
默认的整数常量都是int型，那么可以为它追加字母"L"或直接使用"(long)"转换。
修改代码如下：
public class JavaDemo {
public static void main(String args[]) {
int max = Integer.MAX_VALUE ; // 获取int的最大值
int min = Integer.MIN_VALUE ; // 获取int的最小值
System.out.println(max) ; // 2147483647
System.out.println(min) ; // -2147483648
System.out.println("---------- 无以言表的分割线 ----------") ;
// long型变量 + long型常量 = long型计算结果
System.out.println(max + 1L) ; // 2147483648
System.out.println(max + 2L) ; // 2147483649
// long型变量 - int型常量 = long型计算结果
System.out.println((long)min - 1) ; // -2147483649
}
}
注意最下面的 (long)min 是把int型强制转换成long型
注意(max + 1L)，其中的"L"可以换成小写"l"，
但是不要这样做，很容易把小写的"l"看成是数字1；
命令执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
2147483647
-2147483648
---------- 无以言表的分割线 ----------
2147483648
2147483649
-2147483649
-------------------------------------------------------------
现在发现数据类型之间是可以转换的，
即：范围小的数据类型可以自动转换为范围大的数据类型，
但是如果反过来，范围大的数据类型要转为范围小的数据类型，
那么就必须采用强制性的处理模式，同时还需要考虑可能带来的数据溢出，
范例：强制类型转换
错误做法：
public class JavaDemo {
public static void main(String args[]) {
long num = 2147483649L ; // 此数据已经超过了int范围
int temp = num ; // long范围比int范围大，不能够直接转换
}
}
long num 的值是以下3个都不能编译，原因是long型数据范围比int型数据范围大
long num = 2147483649 ;
long num = 2147483649L ;
long num = 2147 ;
D:\fgqjava>javac JavaDemo.java
JavaDemo.java:4: 错误: 不兼容的类型: 从long转换到int可能会有损失
int temp = num ; // long范围比int范围大，不能够直接转换
要想强制转换，代码如下：
public class JavaDemo {
public static void main(String args[]) {
long num = 2147483649L ; // 此数据已经超过了int范围
int temp = (int) num ; // long范围比int范围大，不能够直接转换
System.out.println(temp) ;
}
}
执行结果，虽然可以编译，结果仍然是一个错误结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
-2147483647
结论：
程序支持有数据转换处理，但是如果不是必须的情况下不建议这种转换。
-------------------------------------------------------------
在进行整型处理的时候，还有一个byte类型特别需要注意，
首先这个类型的范围是：-128~127之间，也就是说它保存的数据量很小。
范例：定义byte变量
代码如下：
public class JavaDemo {
public static void main(String args[]) {
byte num = 20 ;
System.out.println(num * num) ; // byte * byte = byte
}
}
执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
400
代码如下：
public class JavaDemo {
public static void main(String args[]) {
byte num = 20 ;
byte result = num * num ; // byte * byte = byte
System.out.println(result) ;
}
}
执行结果报错原因，result是400，大于byte范围：
D:\fgqjava>javac JavaDemo.java
JavaDemo.java:4: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte result = num * num ; // byte * byte = byte
代码如下：
public class JavaDemo {
public static void main(String args[]) {
byte num = 20 ;
System.out.println(num) ;
}
}
执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
20
正常来讲在Java程序里面20这个数字应该是int型，
但是在为byte赋值的时候并没有因为是int型而发生强制类型转换，
这是因为Java对byte做了特殊处理，
即：如果没超过byte范围的常量可以自动由int变为byte。
如果超过了，就必须进行强制转换。
代码如下：
public class JavaDemo {
public static void main(String args[]) {
byte num = 200 ;
System.out.println(num) ;
}
}
执行结果：
D:\fgqjava>javac JavaDemo.java
JavaDemo.java:3: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte num = 200 ;
范例：int强制转换为byte
代码：
public class JavaDemo {
public static void main(String args[]) {
byte num = (byte) 200 ;
System.out.println(num) ;
}
}
执行结果：
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
-56
由于现在200已经超过了byte的范围，所以产生了数据溢出的问题。
需要提醒的是，对于常量可以自动适配转换，
但是对于变量则还是必须使用强制转换处理。
public class JavaDemo {
public static void main(String args[]) {
int x = 200 ;
byte num = x ;
System.out.println(num) ;
}
}
D:\fgqjava>javac JavaDemo.java
JavaDemo.java:4: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte num = x ;
强制转换就是把 "byte num = x ;" 变为 "byte num = (int) x ;"
public class JavaDemo {
public static void main(String args[]) {
int x = 200 ;
byte num = (int) x ;
System.out.println(num) ;
}
}