Byte类型详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40701750/article/details/127261788

**5. byte的注意**
```java
/*
	* Author:CF.FC
	* Time:2022.10.13
	* Signature:Perfection doesn't happen overnight
*/
public class Byte{
	public static void main(String[] args){
		
		// 给byte的数据大小不能超过它所表示范围，否则自动转换为int整数型进行操作，并且发生精度损失
		byte num1 = (byte)128;
		byte num2 = (byte)-129;
		int num3 = 128;
		int num4 = -129;
		System.out.println("128超过了byte字节型整数表示的最大值所以会自动变成默认的int,而预先给的变量数据类型为byte因此报错,若要解决可加上强制类型转换即(byte),转换后的结果为" + num1);  // -128
		System.out.println("-129超过了byte字节型整数表示的最小值所以会自动变成默认的int,而预先给的变量数据类型为byte因此报错,若要解决可加上强制类型转换即(byte),转换后的结果为" + num2);  // 127
		System.out.println("这个" + num3 + "超过了byte字节型整数表示的最大值所以输入的数字为默认的int,而预先给的变量数据类型为byte因此报错，所以要将之前的byte改为int才会正常执行代码,正常执行后的结果为128"); // -128
		System.out.println("这个" + num4 + "超过了byte字节型整数表示的最小值所以输入的数字为默认的int,而预先给的变量数据类型为byte因此报错，所以要将之前的byte改为int才会正常执行代码,正常执行后的结果为-129"); // -129
		
		// byte两个数字相除时，小数点后小于1的小数都会自动转换为0即向下取整,例如：2/3(0.6666666666666667)->0,4/3(1.333333333333333)->1
		byte num5 = 2/3;
		byte num6 = 4/3;
		System.out.println("三分之二计算出来后是0.6的死循环，因为小数点后的小数小于1，所以向下取整为" + num5); // 0
		System.out.println("三分之四计算出来后是1.3的死循环，因为小数点后的小数小于1，所以向下取整为" + num6); // 1
	}
}

6. byte的存储

负数的原码及补码变化（从小到大的顺序）
-128									
原码：无								
反码：无							
补码：0B1000,0000	
-127	
原码：0B1111,1111
反码：0B1000,0000
补码：0B1000,0001
-126
原码：0B1111,1110
反码：0B1000,0001
补码：0B1000,0010
-125
原码：0B1111,1101
反码：0B1000,0010
补码：0B1000,0011
-1
原码：0B1000,0001
反码：0B1111,1110
补码：0B1111,1111

正数的原码及补码变化（从小到大的顺序）
0
原码：0B0000,0000
反码：0B0000,0000
补码：0B0000,0000
1
原码：0B0000,0001
反码：0B0000,0001
补码：0B0000,0001
2
原码：0B0000,0010
反码：0B0000,0010
补码：0B0000,0010
3
原码：0B0000,0011
反码：0B0000,0011
补码：0B0000,0011
127
原码：0B0111,1111
反码：0B0111,1111
补码：0B0111,1111

byte数据大小越界后的最大值精度损失（128->-128）

原数128（大于byte最大值即127）
原码：0,1000,0000
反码：0,0111,1111
补码：0,1000,0000

转换后的数-128（精度损失--损失最左边的一个位即损失符号位）
原码：无
反码：无
补码：0,1000,0000->1000,0000

byte数据大小越界后的最小值精度损失（-129->127）

原数-129（小于byte最小值即-128）
原码：1,0111,1111
反码：1,1000,0000
补码：1,1000,0001

转换后的数127（精度损失--损失最左边的一个位即损失符号位）
原码：1,1111,1111->0111,1111
反码：0111,1111
补码：0111,1111

备注：
1. 正数原码、反码、补码相同（三码合一）
2. 负数补码 = 反码最低位 + 1，负数的反码 = 原码除符号位不变外其余每一位的数字都置反
3. 原码、反码、补码的最左边的位是最高位也是符号位（0代表正1代表负），最右边的位是最低位
4. 若要推到数字如何在计算机中进行存储从原码出发，若要拿出计算机的数字进行使用从补码出发
5. 计算机中都是以补码进行数字的存储，因为有了补码的存在才使得负数也能像正数一样存储在计算机中

总结：
6. 负数的原码变化
0B1111,1111->0B1000,0001（即从大到小）
7. 负数的补码变化
0B1000,0000->0B1111,1111（即从小到大）
8. 正数的原码变化
0B0000,0000->0B0111,1111（即从小到大）
9. 正数的原码变化
0B0000,0000->0B0111,1111（即从小到大）
10. 取值超过byte取值范围后的变化
取值超过byte取值范围后，会发生精度损失即损失掉符号位

7. byte的代码

/*
	* Author:CF.FC
	* Time:2022.10.13
	* Signature:Perfection doesn't happen overnight
*/
public class Byte{
	public static void main(String[] args){
		
		// 整数取值范围（-128~127）
	    byte num1 = 0;
		byte num2 = 127;
		byte num3 = -128;
		
		// 字符（符合ASCII码表即0~127） 
		byte num4 = 65;
		byte num5 = 90;
		byte num6 = 97;
		byte num7 = 122;

		// 整数算术表达式（加减乘除）
		byte num8 = 1+2;
		byte num9 = 1-2;
		byte num10 = 1*2;
		byte num11 = 1/2;

		// 字符算术表达式（加减乘除）
		byte num12 = '1' + '1';
		byte num13 = '1' - '1';
		byte num14 = '1' * ('1' - '1');
		byte num15 = '1' / '1';

	    // 字符和数字混合算术表达式（加减乘除）
		byte num16 = 'a' + 26;
		byte num17 = 'Z' - 26;
		byte num18 = 'z'*1;
		byte num19 = 'A'/1;
		
 		// 整数取值范围（-128~127）二进制（0b|0000,0000或0B|0000,0000）
		byte num20 = 0b01111111;
		byte num21 = 0b00000000;
		byte num22 = -0B10000000;
		
		// 整数取值范围（-128~127）八进制(00|000)
		byte num23 = 00177;
		byte num24 = 00000;
		byte num25 = -00200;
		
		// 整数取值范围（-128~127）十六进制(0x|0000或0X|0000)
		byte num26 = 0x7F;
		byte num27 = 0x0000;
		byte num28 = -0X0080;

	    // 整数取值范围（-128~127）二进制（0b|0000,0000或0B|0000,0000）算术表达式（加减乘除）
		byte num29 = 0b01111111 + 0b00000000 + -0B10000000;
		byte num30 = 0b01111111 - 0b00000000;
		byte num31 = 0b01111111 * 0b00000000 * -0B10000000;
		byte num32 = 0b01111111 / -0B10000000;
		
		// 整数取值范围（-128~127）八进制(00|000)算术表达式（加减乘除）
		byte num33 = 00177 + 00000 + -00200;
		byte num34 = 00177 - 00000;
		byte num35 = 00177 * 00000 * -00200;
		byte num36 = 00177 / -00200;
		
		// 整数取值范围（-128~127）十六进制(0x|0000或0X|0000)算术表达式（加减乘除）
		byte num37 = 0x7F + 0x0000 + -0X0080;
		byte num38 = 0x7F - 0x0000;
		byte num39 = 0x7F * 0x0000 * -0X0080;
		byte num40 = 0x7F / -0X0080;

		// 整数取值范围（-128~127）输出
		System.out.println("");
		System.out.println("=整数取值范围（-128~127）输出=");
		System.out.println("num1:" + num1); // 0
		System.out.println("num2:" + num2); // 127
		System.out.println("num3:" + num3); // -128
		
		// 字符（符合ASCII码表即0~127）输出
		System.out.println("");
		System.out.println("==字符（符合ASCII码表即0~127）输出==");
		System.out.println("num4:" + num4); // 65
		System.out.println("num5:" + num5); // 90
		System.out.println("num6:" + num6); // 97
		System.out.println("num7:" + num7); // 122

	   	 // 整数算术表达式（加减乘除）输出
	    System.out.println("");
		System.out.println("===整数算术表达式（加减乘除）输出===");
		System.out.println("num8:" + num8);   // 3
		System.out.println("num9:" + num9);   // -1
		System.out.println("num10:" + num10); // 2
		System.out.println("num11:" + num11); // 0

		// 字符算术表达式（加减乘除）输出
 		System.out.println("");
		System.out.println("====字符算术表达式（加减乘除）输出====");
		System.out.println("num12:" + num12); // 98
		System.out.println("num13:" + num13); // 0
		System.out.println("num14:" + num14); // 0
		System.out.println("num15:" + num15); // 1

	    // 字符和数字混合算术表达式（加减乘除）输出
	   	System.out.println("");
		System.out.println("=====字符和数字混合算术表达式（加减乘除）输出=====");
		System.out.println("num16:" + num16); // 123
		System.out.println("num17:" + num17); // 64
		System.out.println("num18:" + num18); // 122
		System.out.println("num19:" + num19); // 65
		
	    // 整数取值范围（-128~127）二进制(0b|0000,0000或0B|0000,0000)输出
	    System.out.println("");
		System.out.println("======整数取值范围（-128~127）二进制(0b|0000,0000或0B|0000,0000)输出======");
		System.out.println("num20:" + num20); // 127
		System.out.println("num21:" + num21); // 0
		System.out.println("num22:" + num22); // -128

   	    // 整数取值范围（-128~127）八进制(00|000)输出
   	    System.out.println("");
		System.out.println("=======整数取值范围（-128~127）八进制(00|000)输出=======");
		System.out.println("num23:" + num23); // 127
		System.out.println("num24:" + num24); // 0
		System.out.println("num25:" + num25); // -128

		// 整数取值范围（-128~127）十六进制(0x|0000或0X|0000)输出
		System.out.println("");
		System.out.println("========整数取值范围（-128~127）十六进制(0x|0000或0X|0000)输出========");
		System.out.println("num26:" + num26); // 127
		System.out.println("num27:" + num27); // 0
		System.out.println("num28:" + num28); // -128
		
 		// 整数取值范围（-128~127）二进制（0b|0000,0000）算术表达式（加减乘除）输出
 		System.out.println("");
		System.out.println("=========整数取值范围（-128~127）二进制（0b|0000,0000）算术表达式（加减乘除）输出=========");
		System.out.println("num29:" + num29); // -1
		System.out.println("num30:" + num30); // 127
		System.out.println("num31:" + num31); // 0
		System.out.println("num32:" + num32); // 0
		
		// 整数取值范围（-128~127）八进制(00|000)算术表达式（加减乘除）输出
		System.out.println("");
		System.out.println("==========整数取值范围（-128~127）八进制(00|000)算术表达式（加减乘除）输出==========");
		System.out.println("num33:" + num33); // -1
		System.out.println("num34:" + num34); // 127
		System.out.println("num35:" + num35); // 0
		System.out.println("num36:" + num36); // 0
		
	    // 整数取值范围（-128~127）十六进制(0x|0000或0X|0000)算术表达式（加减乘除）输出
	    System.out.println("");
		System.out.println("===========整数取值范围（-128~127）十六进制(0x|0000或0X|0000)算术表达式（加减乘除）输出===========");
	    System.out.println("num37:" + num37); // -1
		System.out.println("num38:" + num38); // 127
		System.out.println("num39:" + num39); // 0
		System.out.println("num40:" + num40); // 0
	}
}