java表达式常见错误—基础

女爷i 2022-07-10 04:25 203阅读 0赞

package dicengshengyanFirst;  
  
//运算符：Java中预定义的进行某种特殊运算的符号  
//+ - && <<   ?:  
//表达式  
//1.表达式是一种运算符和操作数合成在一起组成的式子  
//运算符需要的操作数数量不相同 a+b a\*b a++ ?:  
//运算符需要的操作数类别不相同 a+b a+1 1+1 a++ 1++  
//2.表达式都有一个结果值

class Demo{
        public static void main(String[] args){
            //赋值运算：=
            /*
            int a = 1;
            a = 2;
            System.out.println(a); //2
            */
            /*
            int a = 1;
            System.out.println(a=2);//2
            */
            /*
            int a = 10;
            int b = a+(a=5)+a+(a=10);
            
                        10+(a=5)+a+(a=10)    a = 5
                        10+5+a+(a=10)        a = 5
                        10+5+5+(a=10)        a = 10 
                        10+5+5+10
                    
            System.out.println(b); //30
            System.out.println(a); //10
            */
            /*
            int i = 1;
            i = (i=i+(i+(i=2)+i)+i)+3;
            运算过程
            第一种：i = (i=i+(i+(i=2)+i)+i)+3      
                 i=(1+(1+(i=2)+i)+i)+3
                 i=(1+1+2+2+2)+3
                 i=8+3     i=8
              =8+3
              =11
              第二种：  i = (i=i+(i+(i=2)+i)+i)+3;
                     i=i+(i+(i=2)+i)+i
                       i+(i+(i=2)+i)+i
                       i+(i+(i=2)+i)+i    i = 1
                           i+(i=2)+i
                           1+(i=2)+i                        i = 2
                           1+  2  +2
                       1+     5        +2
                     i=        8                i=8                        i = 8
                i=         8             +3
                i = 11
          
            System.out.println(i);  //11
            */
            
            //算数运算：+ - * / %
            //算数运算的运行原理
            /*
            int a = 1,b = 2,c = 3;
            //a+b+c
            //a+b+c*d
            //a+b*c
            System.out.println(a+b*c);//7
            */
            /*
            a+b+c
            1.去内存中找a对应的数据
            2.读取下一个运算符 +
            3.读取+后面的运算数b，同时读取b后面的运算式，看运算符，看是否先运行
                + b +
            4.a+b -> temp
            5.temp+c
            */
            /*
            int a = 1;
            int b = 2;
            System.out.println((a=3) + (b=4) + a*b);
            */
            
            //System.out.println(-11%-7);//-4
            /*
            前面的操作数提供最终运算结果的符号
            前面的操作数的绝对值与后面操作数的绝对值提供最终结果值
        
            */
            
            
            //自增自减运算 ++ --
            //自增自减运算符的运行原理
            //++运算符
            //i++ 表达式 ++i
            
            
            //int i = 1;
            //System.out.println(i+++i+++i+++i++);
            /*
            i++ + i++ + i++ + i++            i = 1
            1    + i++ + i++ + i++            i = 2
            1    + 2   + i++ + i++            i = 3
            1   + 2   + i++ + i++            i = 3
                3     + 3   + i++            i = 4
                     6      + i++            i = 4
                     6      + 4                i = 5
            */
            //System.out.println(i++ + ++i + i++ + ++i);//10
                    
            /*
            int i = 1;
            int j = i++ + (i=1) + i++ + (i=1)+ i++;
                          //1+1+1+1+1
            System.out.println(j);//5
            */
            
            
            
            //关系运算==
            /*
            int a = 10;
            int b = 10;
            double c = 10.0;
            //先将左右两边的数据类型统一成一种类型，然后比较
            System.out.println(a==b);
            //先将a的值由int->double，然后比较a与c的值
            System.out.println(a==c);
            */
                    
            //搞怪的二进制，有关计算机数据的存储格式
            //财务运算时，小数点后不能轻易省略
            //System.out.println(3.0*10==30.0);//true
            //System.out.println(3.14*10==31.4);//false
            //System.out.println(3.1415*10==31.415);false
            /*
            0.5     1/2  //能精确表示
            0.25     1/4
            0.125    1/8
            0.0625    1/16
            0.4  0.25+0.125+   //不能精确表示
            */
            /*
            System.out.println(3.141*10);
            3.14000000002
            3.14100000000009        3.141
            3.14150000001
            */
            
            
            
            //自动装箱封装类对象判定
            /*
            Integer a = 1;    //a = 127        //a = 128
            Integer b = 1;    //b = 127        //b = 128
            System.out.println(a == b);
            */
            //java自动装箱功能
            //1.首先判断当前值的范围是不是在byte的表示范围内 -128 ~ +127
            //2.如果在此范围内，JVM(java虚拟机)会在内存中创建一个数组，该数组中有256个数据
            //  数据如果在-128 +127内，自动装箱的对象 保存在一个静态数组中
            /*
            Integer[] nums = new Integer[256];
            Integer a = 1;
            Integer b = 1;
            Integer c = 1;
            */
            //3.如果不在此范围内，每次均new Integer();
            //注意：byte：计算机中的基本单位
            
            
            //综合
            /*
            byte b = 1;
            byte c = 1;
            b = b + 1;        //int赋值到byte报错
            c++;
            System.out.println(b == c);
            */
            
            /*
            //byte b = 1;
            // 检测常量
            //1是int类型的
            //1.JVM(java虚拟机)在进行定义的变量初始化时，首先检测右侧的数据自身的数据类型
            //与左侧的常量的数据类型之间是否存在有可转化的可能性
            //2.检测具有可转换性，检测左边的数据类型的范围-128 +127
            //3.检测右侧数据的值是否在范围内
            //4.如果在范围内，自动将右侧的数据转型成左侧的类型
            //5.如果不在范围内，报错
            */
            
            /*
            byte b = 127;
            byte bs = b;
            //检测变量
            //1.检测右边的数据类型是否与左边相同
            //如果相同，编译通过
            //如果不相同，编译失败
            */
            
    
            //逻辑运算符&/&&  |/||
            //System.out.println(true | false & false);//true
            //java语言中，与&运算比或|运算级别高
    
    
            //移位运算 <<  >>  >>>
            //对前面的操作数进行后面的数值位数的移动运算
            //3<<4 //增大了2的四次方
            //0000-0000 0000-0000 0000-0000 0000-0011
    
            //int a = 10;
            //System.out.println(a<<1);
            //System.out.println(a<<2);
            //System.out.println(a<<32);//恢复成原数
            //System.out.println(a<<33);//等于a<<1
            //System.out.println(a<<32L);//不转long，只提供数字32
            /*
            long a = 10L;
            System.out.println(a<<1);
            System.out.println(a<<2);
            System.out.println(a<<32);
            System.out.println(a<<64);//恢复成原数，long是以64为存储的
            System.out.println(a<<64L);
            //在移位运算时右边的数字只提供数值，不考虑其数据类型
            //右边的数据类型必须是整型数据,左边的数据类型必须是整型数据
            */
            /*
            byte b = 1;
            System.out.println(b<<1);
            System.out.println(b<<2);
            System.out.println(b<<8);//不恢复原数
            */
            //移位运算，左边的必定是int或long，不足int(byte,short)会自动变成int,右边的任意整型
            /*
            int a = 10;
            a = a<<1;  // 10*2
            a = a<<1;  // 20*2
            int b = 10;
            b = b<<1<<1;  //
            int c = 10;
            c = c<<2;  // 10*2^2
            System.out.println(a);  //40
            System.out.println(b);  //40
            System.out.println(c);  //40
            */
            /*
            int a = 10;
            a = a << 10;        //a如果原始是11001100110，移动后得到新值
            a = a << 22;        //a在新值的基础上进行移动
            int b = 10;
            b = b << 32;        //直接变成原数
            System.out.println(a);
            System.out.println(b);
            */
            
            
            
            //三目运算
            //内存运行原理
            // a ? b : c
            /*
            int a = 10;
            int b = 5;
            System.out.println(a>b?a:b);  //10
            */
            //三目运算时，如果条件表达式确认了取哪一个值，那么另一个值
            //将不再进行运算
            /*
            int a = 2;
            int b = 1;
            int c = a > b ? (a = 4) : (b = 3);
            System.out.println(a); //4
            System.out.println(b); //1
            System.out.println(c); //4
            */
            /*
            int a = 10;
            double d = 9.5;
            //double x =  a > d ? a : d;
            System.out.println( a > d ? a : d );  //10.0
            //三目运算是一个表达式，作为一个表达式，应该有一个结果
            //这个结果应该有一种唯一确定的数据类型
            */
            
            /*
            //自动装箱
            Object x = 3 > 2 ? 1 : true;
                  //new Integer(1):new Boolean(true);
            System.out.println( 3 > 2 ? 1 : true ); //1
            */
            
            //System.out.println( true ? false : true ? false : true ); //false
            //true ? false : 式子
            //1.读取到true
            //2.读取到?,遇到了一个三目运算
            //3.三目运算，后面要提供两个数据
            //4.第一个数据在哪里？一定是在：和？中间
            //5.读取到了：就代表第一个数据读取到了，后面管你是什么
            //都是第二个数据
            //true ? false : (true ? false : true )
            
            
            //复合赋值表达式    += -= *= /= &= ...
            //1.作为一个表达式一定有值
            //2.复合赋值表达式在进行赋值之前要进行一次运算
            
            //运行结果
            /*
            int a = 1;
            a+=1;            //a = a + 1; 错误
            System.out.println(a); //2
            */
            /*
            int a = 1;
            System.out.println(a+=4); //5
            */
            
            /*
            int a = 1;
            a+=a++;  
            System.out.println(a); //2
            a初值为1
            a = a + a++;    a=1
                    1 + a++;  a=2
                    1 + 1
                      2
            a =   2
            */
            
            /*
            int a = 1;
            a+=a++ + a++;
            System.out.println(a); //4
            a+=(a++ + a++);
            a = a + (a++ + a++)
              = 1 + (1+2)
              = 4
            */
            
            
            /*
            int a = 1;
            a+= a+= a++;
            System.out.println(a);  //3
            
            a+=( a+= a++);
            a=a+( a+= a++);
            a=1+(a+= a++);
            a=1+(a= a + a++);
            a=1+(a= 1 +a++);
            a=1+(a= 1 +1);   a=2
            a=1+(a= 2);
            a=1+2;
            a = 3
            
            
            */
            
            /*
            int a = 1;
            a+=(a=2)+ (a+=(a=3)+a++);
            System.out.println(a);  //11
            
            a+=((a=2)+ (a+=(a=3)+a++));
            a=a+((a=2)+ (a+=(a=3)+a++));
            a=1+((a=2)+ (a+=(a=3)+a++));
            a=1+(2+ (a+=(a=3)+a++));
            a=1+(2+ (a+=((a=3)+a++)));
            a=1+(2+ (a=a+((a=3)+a++)));
            a=1+(2+ (a=2+((a=3)+a++)));
            a=1+(2+ (a=2+(3+a++)));
            a=1+(2+ (a=2+(3+3)));
            a=1+(2+ (a=8));
            a=1+(2+ 8);
            a = 11
        */
            
            
            //特殊的数据类型转换格式
            /*
            long s = 1;    //自动类型转换int->long
            double d = 1;//自动类型转换int->double
            int m = (int)1.5;//强制类型转换double->int
            //低类型转换高类型——自动
            //高类型转换第类型——强制
            */
            
            /*
            int a = 1;
            a+=3L;  
            a = a + 3L;
            System.out.println(a); //4
            */
            
            /*
            int a = 1;
            a+=3.5;
            System.out.println(a); //4
            */
            //在这里+=符号右边的操作数被转化成左边的类型
            //不管右边是否高于左边，全部自动转换
            //高类型->低类型 自动转化格式 , 只出现在复合赋值运算中
            
                    
            
            int a = 1;
            a+= 4294967295L;
            System.out.println(a);  //0
            
            //a = a + (int)4294967295L
            
    /*        
      0000-0000 0000-0000 0000-0000 0000-0001    1
    + 1111-1111 1111-1111 1111-1111 1111-1111    4294967295
     10000-0000 0000-0000 0000-0000 0000-0000    0
    */        
            
    
        }

\}  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
        //赋值运算：=  
        /\*  
        int a = 10;  
        int b = a+(a=5)+a+(a=10);  
        System.out.println(b);  
        \*/  
        /\*  
        int i = 1;  
        i = (i=i+(i+(i=2)+i)+i)+3;  
        System.out.println(i);  
        \*/  
          
          
          
        //算数运算：+ - \* / %  
        /\*  
        //算数运算的运行原理  
        int a = 1,b = 2,c = 3;  
        //a+b+c  
        //a+b+c\*d  
        //a+b\*c  
        System.out.println();  
        \*/  
          
          
          
        //自增自减运算 ++ --  
        //自增自减运算符的运行原理  
        /\*  
        int i = 1;  
        System.out.println(i+++i+++i+++i++);  
        \*/  
        /\*  
        int i = 1;  
        int j = i++ + (i=1) + i++ + (i=1)+ i++;  
        System.out.println(j);  
        \*/  
          
          
          
        //关系运算==  
        /\*  
        int a = 10;  
        int b = 10;  
        double c = 10;  
        System.out.println(a==b);  
        System.out.println(a==c);  
        \*/  
        /\*  
        //自动装箱封装类对象判定  
        Integer a = 1;    //a = 127        //a = 128  
        Integer b = 1;    //b = 127        //b = 128  
        a == b  
        \*/  
        /\*  
        //综合  
        byte b = 1;  
        byte c = 1;  
        b = b + 1;  
        c++;  
        System.out.println(b == c)  
        \*/  
          
          
  
        //逻辑运算符&/&& |/||  
        //System.out.println(true | false & false);  
  
  
  
        //移位运算 <<  >>  >>>  
        /\*  
        int a = 10;  
        System.out.println(a<<1);  
        System.out.println(a<<2);  
        System.out.println(a<<32);  
        //System.out.println(a<<32L);  
        \*/  
        /\*  
        long a = 10L;  
        System.out.println(a<<1);  
        System.out.println(a<<2);  
        System.out.println(a<<32);  
        //System.out.println(a<<64);  
        //System.out.println(a<<64L);  
        \*/  
        /\*  
        int a = 10;  
        a = a<<1;  
        a = a<<1;  
        int b = 10;  
        b = b<<1<<1;  
        int c = 10;  
        c = c<<2;  
        System.out.println(a);  
        System.out.println(b);  
        System.out.println(c);  
        \*/  
        /\*  
        int a = 10;  
        a = a << 10;  
        a = a << 22;  
        int b = 10;  
        b = b << 32;  
        System.out.println(a);  
        System.out.println(b);  
        \*/  
          
          
          
        //三目运算  
        //内存运行原理  
        // a ? b : c  
        /\*  
        int a = 2;  
        int b = 1;  
        int c = a > b ? a : b ;  
        //int c = a > b ? (a = 4) : (b = 3);  
        System.out.println(a);  
        System.out.println(b);  
        System.out.println(c);  
        \*/  
        /\*  
        int a = 10;  
        double d = 9.5;  
        System.out.println( a > d ? a : d );  
        \*/  
        //System.out.println( true ? false : true ? false : true );  
        //System.out.println( 3 > 2 ? 1 : true );  
          
          
          
        //复合赋值表达式    += -= \*= /= &= ...  
        //运行结果  
        /\*  
        int a = 1;  
        a+=1;  
        System.out.println(a);  
        \*/  
        /\*  
        int a = 1;  
        a+=a++;  
        System.out.println(a);  
        \*/  
        /\*  
        int a = 1;  
        a+=a+++a++;  
        System.out.println(a);  
        \*/  
        /\*  
        int a = 1;  
        a+=a+=a++;  
        System.out.println(a);  
        \*/  
        /\*  
        int a = 1;  
        a+=(a=2)+ (a+=(a=3)+a++);  
        System.out.println(a);  
        \*/  
        //特殊的数据类型转换格式  
        /\*  
        int a = 1;  
        a+=3L;  
        System.out.println(a);  
        \*/  
        /\*  
        int a = 1;  
        a+=3.5;  
        System.out.println(a);  
        \*/  
        /\*  
        int a = 1;  
        a+= 4294967295L;  
        System.out.println(a);  
        \*/