Java学习日记之编程入门（7）------------②

整型数据类型

整型数据类型一共有四种，按照保存的范围由小到大：byte、short、int、long。那么在Java里面任意一个整型常量，默认的常量类型都是int型（只要是整数就是int类型的数据）。
范例：定义一个int型变量

public class JavaDemo{
	public static void main(String args[]){
		// int 变量名称 = 常量;（10是一个常量，整数类型为int）
		int x = 10;		//定义了一个整型变量x，值为10
		//int型变量 * int型变量 = int型变量
		System.out.println(x * x);
	}
}

在上述例子中，10是永远不会改变的，但是x是一个变量，x的内容是可以改变的。
范例：修改x的内容

public class JavaDemo{
	public static void main(String args[]){
		// int 变量名称 = 常量;（10是一个常量，整数类型为int）
		int x = 10;		//定义了一个整型变量x，值为10
		x = 20；		//改变了x的已有内容
		//int型变量 * int型变量 = int型变量
		System.out.println(x * x);
	}
}

任何的数据类型都是有其可以保存的数据范围的（正常使用下你很少会出现超过此范围的数据），但是如果真的超过了，会出现怎样的情况呢？下面通过实例来进行观察。

范例：观察超过了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
		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 = 最大值
	}
}

通过此时的执行结果可以发现这些数字在进行处理的时候，如果超过了其最大的保存范围，那么将出现循环的问题，而这样的问题被称作为数据溢出，如果想要解决这种溢出，那么可以扩大适用范围，使用比int取值范围大的数据类型。

范例：解决数据溢出问题

• 在操作的时候预估数据范围，如果发现范围不够就使用更大范围

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
	}
}

• 除了可以定义long型的变量之外，也可以直接在常量上进行处理，默认的整数的常量都是int型，那么可以为它追加大写字母L或者小写字母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("----------------分割线----------------");
		// int型变量 + long型常量 = long型计算结果
		System.out.println(max + 1L);	//2147483648
		System.out.println(max + 2l);		//2147483649
		//long型的变量 - int型常量 = int型计算结果
		System.out.println((long)min - 1);//-2147483649
	}
}

现在发现数据类型之间是可以进行转换的，即：范围小的数据类型可以自动转为范围大的数据类型，但是反过来，数据范围大的数据类型要转为数据范围小的数据类型，那么就必须采用强制性的处理模式，同时还需要考虑可能带来的数据溢出。

范例：强制类型转换(下面有三段代码，注意区别这三个代码之间的区别)

public class JavaDemo{
	public static void main(String args[]){
		long num = 2147483649; 		
		int temp = num;	
		System.out.println(temp)			
	}
}

现在会出现，以下的错误：

进过改进后：

public class JavaDemo{
	public static void main(String args[]){
		long num = 2147483649L; 		// 默认的数据是int型的，所以此数据已经超过了int的范围,所以要在数据的后面添加 L / l 来转换
		int temp = num;	
		System.out.println(temp)			
	}
}

现在会出现以下的问题：

再进行改进一下：

public class JavaDemo{
	public static void main(String args[]){
		long num = 2147483649L; 		// 此数据已经超过了int的范围
		int temp = (int) num;//long范围比int的范围要大，不能够直接转换
		System.out.println(temp);//-2147483647
	}
}

程序支持有数据转换处理，但是如果不是必须的情况下不建议这种转换。

在进行整型数据处理的时候，还有一个byte类型特别需要注意，首先这个类型的范围是：-128~127，数据量很小。

范例：定义byte变量

public class JavaDemo{
	public static void main(String args[]){
		byte num = 20;
		byte result = num * num;//byte * byte = byte	
	}
}

会出现以下问题：

public class JavaDemo{
	public static void main(String args[]){
		byte num = 20;
		System.out.println(num)
	}
}

正常来讲在Java程序里面20这个数字应该是int型，但是在为byte赋值的时候并没有因为是int型的而发生强制类型转换，是因为Java对byte做了特殊处理，即：如果没超过byte范围的常量可以自动由int变为byte，如果超过了就必须进行强制转换，但是会出现数据损失。

public class JavaDemo{
	public static void main(String args[]){
		byte num = (byte)200;
		System.out.println(num);
	}
}

上述代码运行过后会输出：

由于现在200已经超过了byte的范围，所以产生了数据溢出的问题。需要提醒的是，对于常量可以自动适配转换，但是如果对于变量则还是必须进行强制类型转换。