自动类型提升

前景提要

1 12 123 1234 这类纯整数都是默认为int类型，超过int类型范围~2147483647的数字需要强制转换才能赋值给变量。

①当我们遇到超过int范围的情况时则会触发运算溢出（最大值+1＝最小值 ，最小值-1=最大值），例如

public class Test1{
    public static void main(String[] args){
	int max = 2147483647;
	int min = -2147483648;
	System.out.println(max+1);//输出结果为-2147483648最小值
/*  max+1本质是int + int ，结果还是int,用int范围的补码进行运算 */
	System.out.println(max+2);//输出结果为-2147483647次最小值
	System.out.print(min-1);//输出结果为2147483647最大值
    }
}

究其根本是计算机的运算实际上是补码的运算，源码→反码→补码+1or+2之后得到一个补码，这个补码转换为源码就是输出结果，这里int类型位数太多不举例子，下面有byte类型的举例。

②当强制转换为byte类型的时候，有两种情况

        第一种是输出运算结果的对象

        第二种是输出运算结果

第一种：print（）中是变量 而不是表达式

public class Test1{
	public static void main(String args []){
		int a = 127;
		int b = -128;
		byte max = (byte) a;
		byte min = (byte)b;
	int c=1;
	
		byte plus =(byte) c;
//中间是多加的一段。。。。。用于把运算结果封装成对象
	byte max1 =(byte) (max + plus);
	byte max2 =(byte) (max + plus * 2);
	byte min1 = (byte)(min - plus);
//中间是多加的一段。。。。。用于把运算结果封装成对象
	System.out.println(max1);//结果为-128
	System.out.println(max2);//结果为-127
	System.out.println(min1);//结果为127
}
}

由此可见，只有把运算结果封装成byte的一个对象再进行输出才能得到溢出的结果（最大值+1＝最小值，最小值-1=最大值）（第一种）。

第二种 print()中是表达式 而不是变量

public class Test1{
	public static void main(String args []){
		int a = 127;
		int b = -128;
		byte max = (byte) a;
		byte min = (byte)b;
	int c=1;
	
		byte plus =(byte) c;
	System.out.println(max+plus);//结果为128
	System.out.println(max+plus*2);//结果为129
	System.out.println(min-plus);//结果为-129
}
/*补充：如果单独声明一个byte m = max + plus 会报错，
        把max + plus整个表达式作为输出则不会报错*/

()内是byte+byte 结果应该是byte类型，按理说应该会触发溢出机制，然而并没有。

由此可见，并没有正常的触发溢出机制，而是把 表达式byte类型的结果 偷偷转化成了 int 类型进行输出。

但这种“未触发溢出机制”的情况仅出现在“向下强制转换”（int转byte），当我们进行“向上强制转换”（int转long）则会正常触发溢出机制，如下：

public class Test1{
	public static void main(String args []){
		long a = 2147483647;
		long b = -2147483648;
		int max = (int) a;
		int min = (int)b;
	int c=1;
	
		byte plus =(byte) c;
	System.out.println(max+plus);//结果为-2147483648
	System.out.println(max+plus*2);//结果为-2147483647
	System.out.println(min-plus);//结果为2147483647
}
}

print()中int + byte结果是int类型，并且正常触发了溢出机制

  总结：

    自动提升：

当容量小（不是字节大小）的数据和容量大的数据进行运算时（+ - * / % =），自动把结果提升为容量大的数据类型

byte、char、short-->int-->long-->float-->double

其中byte char short 三者之间的运算结果自动转换为int类型，需要用int来装结果变量

理解：byte char short之间的运算很容易算着算着就超了，所以干脆设置为结果都为int类型，并且byte+byte   char+char   short+short三者的结果都是int类型

public class Test1{
	public static void main( String [ ]  args ){
	char c1 = 'a';
	short s1 = 32;
	System.out.print((char)(c1-s1));//输出A
	
}
}

public class Test1{
	public static void main( String [ ]  args ){
	char c1 = 'a';
	short s1 = 32;
	System.out.print(c1-s1);//输出65
	
}
}

补充：

long a = 128;✔

long a = 5616351823;✖  5616351823l✔ 5616351823L✔

float b = 12.3✖ 即使是在范围内也不行，因为浮点数默认为double类型，正确写法是在末尾加F或者f

方法重载的自动类型提升

public class Test1 {
	public static void main(String[] args) {
		
Test1 sb1 = new Test1();
	sb1.tell(1,1);
	}
//方法定义
//public void tell(int i ,int j){
//		System.out.println(1);
//	}
	public void tell(double i,double j){
		System.out.println(2);
	
	}
}

1，1判定为int类型，在方法重载中寻找int类型的，如果有则执行，如果没有则执行自动类型提升为double的重载

执行结果：不注释掉：1

                  注释掉：2