下面的代码，你能看出它们的正确答案吗？能够说出为什么得出这样的结果吗？
class Demo
{
        public static void main(String[] args)
        {
                int iValue=233;
                byte bValue=(byte)iValue;
                System.out.println(bValue);//输出结果为-23，是怎样运算出来的，能够具体的说一下吗？
                char c=97;
                System.out.println(c);
                double div=6.0/0.0;
                System.out.println(div);//为什么不报异常呢，而是输出：Infinity
                //System.out.println("5除以0.0的结果为:"+-5/0);//而它却行不通？
                System.out.println("Hello!"+'a'+7);
                System.out.println('a'+7+"Hello");

        }
}
虽然是一些简单的例子，但是还是有很多的疑问，有的知道答案，却说不出它的依据，求解释？？？{:soso_e100:}

求解释，我也不懂……

希望能帮到你，该睡觉了。

1. public class test {
   
2.         public static void main(String arg[]){
   
3.                 int iValue=128;
   
4.         byte bValue=(byte)iValue;
   
5.         System.out.println(bValue);
   
6.         }
   
7. }
   

复制代码

byte 的取值范围是-128到127之间，一共可以存256个数字
int iValue=233;超出了byte的最大值
当iValue=128的时候，它输出-128  也就是说当int值大于127的时候它会返回自己的最小的值。并且每多1本身的最小值加1，当int值为128时，返回为最小值，也就是当int=129时，输出为-127。所以233-128=105，  可以在最小值的基础上加105，则-128+105=-23


整数除0运算时会出错，但在浮点型却不会，Java语言定义了三个特殊的浮点值来表示浮点数除0运算时的各种出错情形：
Infinity：整无穷大（正数除零时的结果）
-Infinity：负无穷大（负数除零时的结果）
NaN：Not a Number（0.0/0或负数开平方根时的结果）
所以6.0/0.0;的结果是:Infinity

byte类型的值的取值范围是-128到127，把int型的233强转为byte型，就超出了这个 范围，就要用到溢出情况的计算，就是把溢出的部分用最小值来进行计算，233转成byte型，溢出了105，所以用-128计算这一部分就是-128+105=-23    double div=6.0/0.0;这个不报异常吧，因为浮点型的值不是一个准确的值，0.0相当一个无限接近于0的一个数，所以一个非0的数除以一个无限接近于0的数就得到一个无穷大的数，就用Infinity表示，（如果是0除以0就是NaN）,int型的值是一个准确的值，你懂的

1.
因为byte类型的数在内存里占8位(int是32位), 表数范围是-128~127  233>127,强制转换成byte时就溢出了
强制转换过程是这样的
iValue 233:
00000000000000000000000011101001
bValue:
11101001
左边第一位是符号位,为1,也就是个负数,负数在计算机里是以补码的形式存在的,需要换算成原码
11101001  补码减1=反码
11101000  按位取反成为原码(符号位不变)
10010111  原码=-23

2.
"/"除法运算时,两个运算数有1个是浮点数(double),或者2个都是,结果也是浮点数,而且允许除数是0或0.0,得到结果是无穷大或负无穷大
5/0 除零异常
5/0.0 Infinity(正无穷)
-5/0.0 -Infinity(负无穷)
5.0/0 Infinity(正无穷)
5.0/0.0 Infinity(正无穷)

class Demo2
{
        public static void main(String[] args)
        {
                int iValue=250;
                byte bValue=(byte)iValue;//iValue变成了字节，打印字节，查询ASCC码表，打印出对应的值
                System.out.println(bValue);//输出结果为-23，是怎样运算出来的，能够具体的说一下吗？
                char c=97;
                System.out.println(c);
                double div=6.0/0.0;
                int x = 5/0;
                System.out.println(div);//为什么不报异常呢，而是输出：Infinity
              //  System.out.println("5除以0.0的结果为:"+-5/0);//而它却行不通？
                System.out.println("Hello!"+'a'+7);//字符串+字符+整数 变成了字符串
               
                System.out.println(("Hello!"+'a'+7).length());
               
                System.out.println('a'+7+"Hello");//'a'+7先变为104，然后和字符串相加，变成字符串
               
                System.out.println(('a'+7+"Hello").length());

        }
}

除法问题：
整形的除法肯定没有疑惑，5/0就会抛出异常。
Double类型0可以作为除数，根据数学知识可以知道除以零，就是得到一个无穷大的数值。
查询API发现Double有个方法isInfinite()
boolean isInfinite()
          如果此 Double 值在数值上为无穷大，则返回 true；否则返回 false。

  boolean b = new Double(div).isInfinite();
                System.out.println(b);
打印结果为true.

谢谢，希望共同进步！！！！问题已解决

java中所有的整型都是有符号的。整型数据存储时是以补码的形式存在的。原码的第一位是符号位，1表示正数，0表示负数。正数的原码，反码，补码相同，负数的原码和补码相同，但是补码是反码加1。int 4占个字节，byte 占一个字节。
int 233                                                                            byte(233)//取233后8位
原码00000000 00000000 00000000 11101001                     补码11101001                        
反码00000000 00000000 00000000 11101001                     反码11101000
补码00000000 00000000 00000000 11101001                     原码00010111