【无标题】

 类型转换

                //布尔型不能参与转换
                //低精度到高精度可以自动类型转换
                //高精度到低精度需要强制类型转换
                byte b1 = 13;
                short s1 = b1;
                int i1 = s1;
                long l1 = i1;
                //浮点型 采用科学计数法进行存储
                //所以float的32位 可以存储的数据量大于long的64位
                System.out.println(Long.MAX_VALUE);
                float f1 = 95629845625985262566645288888888888888.3F;
                System.out.println(f1);
                f1 = l1;
                double d1 = f1;
                //byte-->short-->long-->float-->double  是自动类型 转换，反之则需要强制类型转换
                //字节       短整型   长整型   浮点型   双浮点型
                short s2 = 129;
                //高到低，需要强制类型转换
                //强制类型转换有可能损失精度，导致数据不正确
                byte b2 = (byte) s2;
                System.out.println(b2);
                
                System.out.println(Integer.toBinaryString(-265));
                //-265 1111111011110111
                
                //1111111011110111  -265二进制
                //当不考虑符号位时 对应的是 65271
                //正数转换为 char时，是忽略负数的，会把响应负数的二进制转换为对应的正数，然后再进行ASCLL码对照
            char c1 = (char)-265;
            System.out.println(c1);
            System.out.println((char)65271);
            char c2 = 'a';
            int i3 = c2;
            //byte-->short-->long-->float-->double  是自动类型 转换，反之则需要强制类型转换
            //字节       短整型   长整型   浮点型   双浮点型
            //char-->int-->long-->float-->double
            //字符型  整数   长整数    浮点型    双浮点型

混合运算

            //布尔型不能参与运算 
            byte d11 = 2;
            int h1 = 10;
            long j1 = 11L;
            //当进行多类型混合运算时，结果为参与运算的最大类型
            long result = b1 + i1 + l1;
            //当混合运算类型只出现了byte short int char 四种类型时
            //任意一种或多种进行运算，结果一点定时int类型（可以理解为混合运算，结果为参与运算的最大类型，但最低也是int类型）
            byte d2 = 1;
            byte b3 = 1;
            int b4 = b2+b3;
            char c11 = 'a';
            int c21 = c11+b2;

小结

            //1.long需要L结尾，建议大写
            //2. float使用F结尾
            //3.double 结尾D可以省略
            //4.char类型应用,ASCII码对照表a=97,A=65,0=48,unicode编码
            //5.布尔型不参与转换
            //6.强制类型转换有可能损失精度
            //7.byte,short,int,char四种中,任意一种或多种进行混合运算时,结果一定是int类型
            //8.当进行多类型混合运算时,结果为参与运算的最大类型

变量

// 常量:生命周期中,值不能修改,但是可以复用
    final int o = 2;
    // o = 3;
    // 字面量,占用临时空间存储,数字 默认是int
    // 并且不能复用,只能临时使用一次,由于没有找到的路径,所以压根也不能修改
    System.out.println(123);

变量中的分类

    
//    Java中变量分为三类
//    局部变量 : 在方法中写的变量,是局部变量(参数列表也是)
//    静态变量 : 在类体中,使用static修饰的变量是静态变量
//    成员变量 : 在类体中,没有使用static修饰的变量是成员变量

变量调用

    
//    变量必须先声明后使用
    // 局部变量
    int i = 2;
    // 局部变量调用,在方法中,直接写变量名调用,方法外 调用不了
    System.out.println(i);
    // 静态变量调用,使用类名.静态变量名,需要考虑权限修饰符
    System.out.println(m001.a);
    // 如果在类中调用当前类的静态变量,类名也可以省略
    System.out.println(a);
    // 创建对象
     m001 obj = new m001();
     System.out.println(obj.a);

 算术运算符

System.out.println(10 + 3);
    System.out.println(10 - 3);
    System.out.println(10 * 3);
    // 由于都是整数,所以结果也是整数 3
    System.out.println(10 / 3);
    // 由于3.0是double 所以结果是 double 3.3333335
    System.out.println(10 / 3.0);
    // 由于10和3都是整数,所以得 3 , 由于 1.0是double,所以 得 4.0
    System.out.println(10 / 3 + 1.0);
    // 余数
    System.out.println(10 % 3);
    
    //------------------------
    // ++ : 自身+1, 把值取出来+1在放回去 , i++ 就等于 i=i+1
    int i = 10;
    i++;
    ++i;
    // 如果 i++ 和 ++i 单独出现,则没有区别, 直接自身+1 完事
    System.out.println(i);
    // 如果 在混合运算中 i++ 和 ++i 就有区别了
    // i++ 先赋值 后 + 1(i的值,是+1之前的值)
    // ++i 先+1 后赋值 (i的值,是+1之后的值)
    i = 10;
    i = i++;
    // i = i++; i = 10
    // i = 10++; i = 10
    // i = 10; i = 11
    // i = 10;
    // ++ -- 属于一元运算, 一元优先级大于二元
    i = i++ + i;
    // i = i++ + i; i = 10
    // i = 10++ + i; i = 10
    // i = 10 + i; i = 11
    // i = 10 + 11; i = 11
    // i = 21; i = 11
    // i = 21;

    i = 10;
    i = ++i + i;
    System.out.println(i);

关系运算符

    //关系运算符 结果 一定是布尔型 true/false

    //> >= < <= == !=

     //== 比较基本类型时  比较的是值,比较引用类型时则比较内存地址
       int a = 10, b = 11;
       System.out.println(a > b);
       System.out.println(a >= b);
       System.out.println(a < b);
       System.out.println(a <= b);
       System.out.println(a == b);
       System.out.println(a != b);

       
       逻辑运算符

       
       //& , | , !  与或非

// & : 与 , 两边都是真,结果才是真 并且的意思
// & 也支持与运算,两边是数字,即可进行与运算
//先把两个数转换为二进制进行每位比较,都是1则取1,反之则取0 , 结果一定不大于两个数中的最小数

//| : 或 , 两边一个条件成立,结果就是真

// ! : 非 , 取反意思,真变假,假变真

// &&   ||   短路

//& : 不短路,两边都是真,结果才是真,比如第一个条件已经为假了,结果一定是假,但是第二个条件依然会执行
//&& : 短路,第一个为假,则第二个不执行

// ^ : 异或 , 两边不一样结果才是真 
// 如果两边是数字,则进行异或运算,二进制每位进行比较,不同取1,相同取0

// >> : 右移运算 : 右移一次,就相当于该数 除2  (符号位不变)
//    转换二进制,进行移位,右移一次,则删除最右边一个,并在最左边(非符号位)添加一位 (如果是整数则补0,负数则补1)

// >>> : 右移运算 : 不考虑符号位,并且不考虑正负数,只在最左边补0 , 所以负数 有可能变正数

// << : 左移运算,向左移动一位,相当于该数乘2,删除左边(非符号位),右边补0

          int f = 10 , g = 11;
          System.out.println(a > b & ++a>=b);
          System.out.println(a > b | ++a>=b);
          System.out.println(!true);
          // 0000 0110
          // 0000 1000
          // 0000 0000
          System.out.println(6&8);
          
          a = 10;
          b = 11;
          System.out.println(a > b && ++a>=b);
          System.out.println(a);
          System.out.println(true ^ true);
          // 0000 1010
          // 0000 0111
          // 0000 1101
          System.out.println(10 ^ 7);
          // 相同数 异或两次 , 得0
          System.out.println(8^8);
          // 0 和任何数进行异或,还是该数
          // 0000 0000
          // 0000 0111
          System.out.println(0^8);
          // a ^b ^b  得a 
          System.out.println(465465^8989^8989);
          
          System.out.println(-2 >> 1);
          // 1000 0010   1111 1101  1111 1110
          // 01111 111
          System.out.println(-2 >>> 1);