1. class OperateDemo2
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 byte b = 1;
   
6.                 byte b0 = 127;
   
7.                 b += b0;//可以运行,值为-128;
   
8.                 b = b+b0;//可能损失精度;
   
9. 
   
10.                 int i = 1;
    
11.                 int i0 = Integer.MAX_VALUE;
    
12.                 i = i+i0;
    
13.                 i += i0;
    
14.                 System.out.println(i);
    
15. 
    
16.                 short s = 1;
    
17.                 short s1 = 32767;
    
18.                 s += s1;//值为-32768
    
19.                 s = s+s1;//可能损失精度
    
20.                 System.out.println(s);
    
21.         }
    
22. 对于byte,short，一个损失精度，一个溢出，而对于int,long,float,double则不会出现精度丢失的状况，为什么？
    
23. }
    

复制代码

请不要这样一连串的发帖，严重会被当做刷帖处理。

1. 
   
2. class OperateDemo2
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 byte b = 1;
   
7.                 byte b0 = 127;
   
8.                 b += b0;//可以运行,值为-128;
   
9.                 b = b+b0;//可能损失精度;
   
10. 
    
11.                 int i = 1;
    
12.                 int i0 = Integer.MAX_VALUE;
    
13.                 i = i+i0;
    
14.                 i += i0;
    
15.                 System.out.println(i);
    
16. 
    
17.                 short s = 1;
    
18.                 short s1 = 32767;
    
19.                 s += s1;//值为-32768
    
20.                 s = s+s1;//可能损失精度
    
21.                 System.out.println(s);
    
22.         }
    
23. 
    
24. }

复制代码

对于byte,short，一个损失精度，一个溢出，而对于int,long,float,double则不会出现精度丢失的状况，为什么？

byte b = 1，这个1是默认int类型的，而byte和short类型的精度都小于int，那么b = b + b0、s = s+s1自然不会编译通过，需要强制转换(byte)。

Java 语言规范中讲到，复合赋值 E1 op= E2 等价于简单赋值E1 =(T)((E1)op(E2))，其中T 是E1 的类型。所以你例子中的 b += b0;  等价于 b = (byte)(b + b2);能编译通过，只是隐性转换类型。


int,long,float,double精度大于等于默认赋值时的int类型，自然不会强制要求类型转换

byte 占1个字节
short 占2个字节
int 占4个字节
long 占8个字节 其后加L或l标识
double 占8个字节
1个字节对应一个8位的范围：         负2^7 ~正 2^7-1          以此类推、
2个字节对应两个8位的范围： 负2^15 ~正 2^15-1
超出了这个范围就会出错、也就是损失精度