1024=1*10^3+2*10^1+4*10^0=1000+20+4=1024

10000000000 =1*2^10=1024

01100101=2^6+2^5+2^2+2^0=64+32+4+1=101

0127=1*8^2+2*8^1+7=64+16+7=87

0x12f=1*16^2+2*16^1+f*16^0=256+32+15=303

1011=1000+11=2^3+2^1+2^0=8+2+1=11

11 001 100 =0314

1100 1110 =0xce

0127=001 010 111

0x12f=0001 0010 1111

package net.ittimeline.java.core.jdk.foundational.syntax;

/**
 * 四种进制的整数常量
 *
 * @author tony 18601767221@163.com
 * @version 2020/12/12 7:47
 * @since JDK11
 */
public class IntConstants {

  public static void main(String[] args) {
    // 二进制常量使用0b开头，JDK7以后支持二进制常量
    System.out.println("二进制数据100转换为十进制的数据结果为" + 0b100);
    // 八进制整数 常量以0开头
    System.out.println("八进制数据100转换为十进制的数据结果为" + 0100);
    // 整数常量默认是十进制
    System.out.println("十进制数据100" + 100);
    // 十六进制整数常量以0x开头，包含0-9之间的十个数字以及a-f之间的6个字母组成
    System.out.println("十六进制数据0x100转换为十进制的数据结果为" + 0x100);
  }
}

package net.ittimeline.java.core.jdk.foundational.syntax;

/**
 * 整数溢出的内存原理
 *
 * @author tony 18601767221@163.com
 * @version 2020/12/12 8:36
 * @since JDK11
 */
public class IntOverFlow {
  public static void main(String[] args) {
      //赋值时(修改变量的值) 赋的值是十进制，给的是原码，如果赋值给的是八进制或者十六进制，给的是补码
      //打印输出到终端(获取变量的值)十进制打印的是原码，十六进制或者八进制打印输出的是补码

      /*

	    数据溢出的内存原理
		129默认是int类型，但是在赋值之前使用了强制类型转换转换为byte类型了
		1Byte=8bit
		129使用1个字节的补码表示的方式是 1000 0001

		在打印输出时需要转换成原码
		1000 0001 首先转换成反码
		补码转反码就是补码的末位减1 也就是1000 0001 -1 =1000 0000
		反码转换成原码 最高位不变 其他位取反
		反码1000 0000 转换成原码的结果是1111 1111
		打印输出时默认是有符号的十进制输出，因此打印输出结果是-127

	*/

      byte number=(byte)129;
    System.out.println("number = "+number);
  }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 按位与运算案例:255&15
 *
 * @author tony 18601767221@163.com
 * @version 2020/12/12 11:01
 * @since JDK11
 */
public class BitAndInt {

  public static void main(String[] args) {
    /*
        255和15都是正整数 正整数原码、反码、补码都一样

        255默认是十进制，占据4个字节长度
        转换为二进制的结果是 0000 0000 0000 0000 0000 0000 1111 1111

        15默认是十进制，占据4个字节长度
        转换为二进制的结果是 0000 0000 0000 0000 0000 0000 0000 1111

        1111 1111
   按位与(&)
        0000 1111
   =
        0000 1111
   转换为十进制的结果是 15
     */

    System.out.println("255 & 15 = "+(255&15));
  }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 按位或运算案例 128&64
 *
 * @author tony 18601767221@163.com
 * @version 2020/12/12 11:13
 * @since JDK11
 */
public class BitOrInt {

  public static void main(String[] args) {
     /*
        128和64都是正整数 正整数原码、反码、补码都一样

        128默认是十进制，占据4个字节长度
        转换为二进制的结果是 0000 0000 0000 0000 0000 0000 1000 0000

        64默认是十进制，占据4个字节长度
        转换为二进制的结果是 0000 0000 0000 0000 0000 0000 0100 0000

        1000 0000
   按位或(|)
        0100 0000
   =
        1100 0000
   转换为十进制的结果是 192
     */

      System.out.println("128 | 64 = "+(128|64));
  }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 按位异或运算案例 256&256
 *
 * @author tony 18601767221@163.com
 * @version 2020/12/12 11:20
 * @since JDK11
 */
public class BitXorInt {

  public static void main(String[] args) {
     /*
        256是正整数 正整数原码、反码、补码都一样

        256默认是十进制，占据4个字节长度
        转换为二进制的结果是 0000 0000 0000 0000 0000 0001 0000 0000



        1 0000 0000
   按位与(|)
        1 0000 0000
   =
        0 0000 0000
   转换为十进制的结果是 0
     */

      System.out.println("256 ^ 256 = "+(256 ^ 256));
  }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 使用数据交换
 *
 * @author tony 18601767221@163.com
 * @version 2020/12/12 11:30
 * @since JDK11
 */
public class BitXorDataExchange {

  public static void main(String[] args) {

    int left = 10;
    int right = 20;
    System.out.printf("【异或运算】变量交换之前 left = %d  right = %d \n", left, right);

    left = left ^ right;
    right = left ^ right;
    left = left ^ right;
    System.out.printf("【异或运算】变量交换之后 left = %d  right = %d \n", left, right);
  }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 数据交换的其他两种方式
 *
 * @author tony 18601767221@163.com
 * @version 2020/12/12 11:33
 * @since JDK11
 */
public class DataExchange {

  public static void main(String[] args) {

      int left= 10;
      int right=20;

      dataExchangeArithmetic(left,right);

      dataExchangeTempSpace(left,right);
      
  }

    /**
     * 使用算术运算交换两个变量
     * @param left
     * @param right
     */
  public static void dataExchangeArithmetic(int left,int right){
      System.out.printf("【算术运算】变量交换之前 left = %d  right = %d \n", left, right);
      left=left+right;
      right=left-right;
      left=left-right;
      System.out.printf("【算术运算】变量交换之后 left = %d  right = %d \n", left, right);

  }

    /**
     * 使用临时变量交换两个变量
     * @param left
     * @param right
     */
    public static void dataExchangeTempSpace(int left,int right){
        System.out.printf("【临时空间】变量交换之前 left = %d  right = %d \n", left, right);
        int temp=left;
        left=right;
        right=temp;
        System.out.printf("【临时空间】变量交换之后 left = %d  right = %d \n", left, right);

    }



}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 按位取反运算案例:~245
 * 按位取反(~) :单目运算符，即只能操作一个变量或则表达式，将操作数的每个位(包括符号位)全部取反
 * @author tony 18601767221@163.com
 * @version 2020/12/12 12:24
 * @since JDK11
 */
public class BitNotSignedInt {
    public static void main(String[] args) {

        /*
         ~245的计算过程
          245的二进制补码是0000 0000 0000 0000 0000 0000 1111 0101

          按位取反(包括符号位)
                         1111 1111 1111 1111 1111 1111 0000 1010
          取反的补码结果是一个负数需要将其转换成原码输出
          其反码表示方式是  1111 1111 1111 1111 1111 1111 0000 1001
          其原码表示方式是  1000 0000 0000 0000 0000 0000 1111 0110
          转换为十进制的结果是-246
         */

        System.out.println("十进制有符号正整数245按位取反的结果是"+(~245));

        /*
        ~-245的计算过程
          -245的二进制原码是1000 0000 0000 0000 0000 0000 1111 0101
          其反码表示方式    1111 1111 1111 1111 1111 1111 0000 1010
          其补码表示方式    1111 1111 1111 1111 1111 1111 0000 1011
          按位取反(包括符号位)
                         0000 0000 0000 0000 0000 0000 1111 0100
          取反的补码结果是一个正整数，转换为十进制的结果是244
         */

        System.out.println("十进制有符号负整数-245按位取反的结果是"+(~-245));



    }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 有符号左移案例: 10<<2和-10<<2
 * 正数、负数的按位左移
 * 二进制位向左移动，左边符号位丢弃，右边补齐0。有符号左移的规律:向左移动几位，就是乘以2的几次方
 * @author tony 18601767221@163.com
 * @version 2020/12/12 11:38
 * @since JDK11
 */
public class BitLeftMoveSignedInt {
  public static void main(String[] args) {

      /*
       10 << 2的计算过程
       10默认是有符号的十进制正整数
       转换为二进制 0000 0000 0000 0000 0000 0000 0000 1010
       向左边移动两位后 右边补两个0 左边的两个0丢弃
       00 0000 0000 0000 0000 0000 0000 101000
       101000 转换为十进制的结果是40
       因此 10 << 2 =40
       */
      System.out.println("有符号十进制正整数10左移2位的结果是" + (10 << 2));

      /*
      -10 << 2 的计算过程
      -10默认是有符号的十进制负整数
      -10原码是         1000 0000 0000 0000 0000 0000 0000 1010
      在进行移位运算之前需要转换为补码
      原码取反转换为反码  1111 1111 1111 1111 1111 1111 1111 0101
      反码加1转换为补码   1111 1111 1111 1111 1111 1111 1111 0110

      1111 1111 1111 1111 1111 1111 1111 0110 向左移动两位
      右边补上2个0，左边符号位丢弃
      11 1111 1111 1111 1111 1111 1111 011000
      输出时需要将其转换为原码
      补码 11 1111 1111 1111 1111 1111 1111 011000
      先计算11 1111 1111 1111 1111 1111 1111 011000的反码:即补码减1
      1111 1111 1111 1111 1111 1111 1101 1000 -1=1111 1111 1111 1111 1111 1111 1101 0100
      再求1111 1111 1111 1111 1111 1111 1101 0100原码:最高位不变，其他位取反
      1111 1111 1111 1111 1111 1111 1101 0100转换原码结果是1000 0000 0000 0000 0000 0000 0010 1000
      1000 0000 0000 0000 0000 0000 0010 1000 转换为十进制输出就是-40

       */
      System.out.println("有符号十进制负整数-10左移2位的结果是" + (-10 << 2));
  }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 有符号整数的右移案例 32 >> 2,-32 >> 2
 * 正整数和负整数的右移运算
 *  有符号右移(>>):二进制位向右移动，使用符号位进行补位，符号位是1那就补上1，符号位是0就补0。有符号右移规律:向右移动几位，就是除以2的几次方
 * @author tony 18601767221@163.com
 * @version 2020/12/12 12:02
 * @since JDK11
 */
public class BitRightMoveSignedInt {

  public static void main(String[] args) {

    /*
        32 >> 2 的计算过程
        整数常量默认是4个字节
        32是四个字节的有符号十进制整数
        其二进制补码表示方式为0000 0000 0000 0000 0000 0000 0010 0000

        0000 0000 0000 0000 0000 0000 0010 0000 向右移动2位，右边去掉2个0，符号位是1，左边补上2个0
        0000 0000 0000 0000 0000 0000 0000 1000
        1000 转换为十进制的结果是8

     */
    System.out.println("有符号十进制正整数32右移2位的结果是"+(32 >> 2));

    /*
        -32 >> 2 的计算过程
        整数常量默认是4个字节
        -32是四个字节的有符号十进制整数
        其二进制原码表示方式为1000 0000 0000 0000 0000 0000 0010 0000
        其二进制反码表示方式为1111 1111 1111 1111 1111 1111 1101 1111
        其二进制补码表示方式为1111 1111 1111 1111 1111 1111 1110 0000

        1111 1111 1111 1111 1111 1111 1110 0000 向右移动2位，右边去掉两个0，左边补上两个1
        右移两位的结果是1111 1111 1111 1111 1111 1111 1111 1000
        其二进制反码表示方式为 1111 1111 1111 1111 1111 1111 1111 0111
        其二进制原码表示方式为 1000 0000 0000 0000 0000 0000 0000 1000
        转换为十进制的结果是-8
     */
    System.out.println("有符号十进制正整数32右移2位的结果是"+(32 >> 2));


  }
}

package net.ittimeline.java.core.jdk.foundational.operator.bit;

/**
 * 有符号整数的无符号右移案例 188 <<< 2　和　-188 <<< 2
 * 无符号右移(>>>):二进制位向右移动，无论符号位是0还是1，左边都补0。无符号右移，对于负数来说，右移后会变成正数。
 * @author tony 18601767221@163.com
 * @version 2020/12/12 12:57
 * @since JDK11
 */
public class UnsignedBitRightMoveSignedInt {

  public static void main(String[] args) {

      /*
            188 <<< 2的计算过程
            188的二进制原码表示方式为 0000 0000 0000 0000 0000 0000 1011 1100
          向右边无符号移动2位的结果0000 0000 0000 0000 0000 0000 0010 1111
          10 1111转换为十进制47
       */

    System.out.println("有符号十进制正整数188的无符号右移2位的结果是"+ (188 >>> 2) );

    /*
        -188 <<< 2的计算过程
            -188的二进制原码表示方式为 1000 0000 0000 0000 0000 0000 1011 1100
            -188的二进制反码表示方式为 1111 1111 1111 1111 1111 1111 0100 0011
            -188的二进制补码表示方式为 1111 1111 1111 1111 1111 1111 0100 0100

          向右边无符号移动2位，去掉右边的两个0，左边补上两个0
         001111 1111 1111 1111 1111 1111 0100 01 转换为十进制的结果是1073741777

     */
    System.out.println("有符号十进制负整数-188无符号右移2位的结果是"+ (-188 >>> 2) );
  }
}