5.二进制码补充学习
    2 二进制 为10
     其实全部显示为00000000000000000000000000000010，高位为0，表示为正

    -2 二进制为11111111111111111111111111111110
     其计算方法为：
          1.首先是找到正数2的二进制形式00000000000000000000000000000010
          2.按位取反->111111111111111111111111111111101
          3.加1->11111111111111111111111111111110
  
    将11111111111111111111111111111110变为整数
         1.首先判断其为负数，按位取反->0000000000000000000000000000001
         2.加1->00000000000000000000000000000010
         3.2步骤后，得结果为2，然后因为是负数，所以加一个符号，得-2

    所以补码的设计目的是：

        ⑴ 使符号位能与有效值部分一起参加运算，从而简化运算规则。补码机器数中的符号位，并不是强加上去的，是数据本身的自然组成部分，可以正常地参与运算。
        ⑵ 使减法运算转换为加法运算，进一步简化计算机中运算器的线路设计。
        (3)为了统一正0和负0

    有符号数：
        最高位是符号位，0表示正，1表示负

        反码表示法规定：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
        补码表示法规定：正数的补码与其原码相同；负数的补码是在其反码的末位加1。

        原码表示虽然很简单，用原码来进行加减运算会出问题,
            问题出在带符号位的负数上
        反码表示，将加减数都表示成反码后，减法可以直接表示成加法
            问题出在(+0)和(-0)上,在人们的计算概念中零是没有正负之分的，于是就出现了补码，正数的补码不变，负数的补码是将其反码加1

        原码和反码中，+0与-0的表示并不相同，所以计算机中一般使用补码。还有利用高位溢出，将减法运算变成加法运算

        模的概念：把一个计量单位称之为模或模数。例如，时钟是以12进制进行计数循环的，即以12为模。在时钟上，时针加上（正拨）12的整数位或减去（反拨）12的整数位，时针的位置不变。14点钟在舍去模12后，成为（下午）2点钟（14=14-12=2）。从0点出发逆时针拨10格即减去10小时，也可看成从0点出发顺时针拨2格（加上2小时），即2点（0-10=-10=-10+12=2）。因此，在模12的前提下，-10可映射为+2。由此可见，对于一个模数为12的循环系统来说，加2和减10的效果是一样的；因此，在以12为模的系统中，凡是减10的运算都可以用加2来代替，这就把减法问题转化成加法问题了（注：计算机的硬件结构中只有加法器，所以大部分的运算都必须最终转换为加法）。10和2对模12而言互为补数。
　　
        同理，计算机的运算部件与寄存器都有一定字长的限制（假设字长为8），因此它的运算也是一种模运算。当计数器计满8位也就是256个数后会产生溢出，又从头开始计数。产生溢出的量就是计数器的模，显然，8位二进制数，它的模数为8=256。在计算中，两个互补的数称为“补码”。

    a. 采用补码后，可以方便地将减法运算转化成加法运算，运算过程得到简化。正数的补码即是它所表示的数的真值，而负数的补码的数值部份却不是它所表示的数的真值。采用补码进行运算，所得结果仍为补码。 　　
    b. 与原码、反码不同，数值0的补码只有一个，即 [0]补=00000000B。 　　
    c. 若字长为8位，则补码所表示的范围为-128～+127；进行补码运算时，应注意所得结果不应超过补码所能表示数的范围。

6.部分源码

package com.book.chap2.operator;
/** *//**
 *
 *直接常量
 *<p>byte,short,int,long均有符号和无符号之分，如byte[-128-127]</p>
 *<p>Integer.toBinaryString</p>
 *
 *@author landon
 *@since JDK1.6
 *@version 1.0 2012-3-21
 *
 */
public class Literals
{
    public static void main(Stringargs)
    {
        //0x-16进制
        int i1 = 0x2f;//f 小写
        //转为2进制
        System.out.println("i1:" + Integer.toBinaryString(i1));
        //转为16进制
        System.out.println("i1:" + Integer.toHexString(i1));
        //转为8进制
        System.out.println("i1:" + Integer.toOctalString(i1));
        System.out.println(i1);
        
        //0x-16进制
        int i2 = 0x2F;//F 大写
        System.out.println("i2:" + Integer.toBinaryString(i1));
        System.out.println(i2);
        
        //0-8进制
        int i3 = 0177;
        System.out.println("i3:" + Integer.toBinaryString(i3));
        
        //char能表示的16进制的最大值,char，2个字节，因为是字符->0-2的16次方-1
        char c = 0xffff;
        System.out.println("c:" + Integer.toBinaryString(c));
        
        //byte的16进制表示的最大值，因为byte1个字节，-128-127
        byte b = 0x7f;
        System.out.println("b:" + Integer.toBinaryString(b));
        
        //short的16进制表示的最大值
        short s = 0x7fff;
        System.out.println("s:" + Integer.toBinaryString(s));
        
        //long的后缀--小写l容易和1混淆
        long n1 = 200L;
        long n2 = 200l;
        
        //float的后缀
        float f1 = 1;
        float f2 = 1f;
        float f3 = 1F;
        
        //double的后缀
        double d1 = 1;
        double d2 = 1d;
        double d3 = 1D;
        
        //TODO 此会编译错误，因为0.2默认为double,应该改为0.2f
//        float f4 = 0.2;
        float f5 = 0.2f;
        
        //TODO 试图向一个变量赋值超过自身范围的数值，编译器会报错
        //byte b2 = 128;Type mismatch: cannot convert from int to byte
        byte b2 = 127;
        
        //TODO 输出各数据类型的最大值/最小值
        System.out.println("byte:" + Byte.MIN_VALUE + "-" + Byte.MAX_VALUE + 
                " " + Integer.toHexString(Byte.MIN_VALUE) + "-" + Integer.toHexString(Byte.MAX_VALUE));
        System.out.println("char:" + Character.MIN_VALUE + "-" + Character.MAX_VALUE + 
                " " + Integer.toHexString(Character.MIN_VALUE) + "-" + Integer.toHexString(Character.MAX_VALUE));
        System.out.println("short:" + Short.MIN_VALUE + "-" + Short.MAX_VALUE + 
                " " + Integer.toHexString(Short.MIN_VALUE) + "-" + Integer.toHexString(Short.MAX_VALUE));
        System.out.println("int:" + Integer.MIN_VALUE + "-" + Integer.MAX_VALUE + 
                " " + Integer.toHexString(Integer.MAX_VALUE) + "-" + Integer.toHexString(Integer.MIN_VALUE));
        System.out.println("long:" + Long.MIN_VALUE + "-" + Long.MAX_VALUE + 
                " " + Long.toHexString(Long.MAX_VALUE) + "-" + Long.toHexString(Long.MIN_VALUE));
        
        //TODO 将float或者double转为整型的时候，总会截尾
        System.out.println((int)0.1);
        System.out.println((int)0.9f);
        
        //TODO 如果需要舍入，则需Math.round
        System.out.println(Math.round(0.9));
        System.out.println(Math.round(0.4));
    }
}

package com.book.chap2.operator;

//TODO 静态导入，这样就不必每次都敲System.out了
import static java.lang.System.out;
/** *//**
 *
 *循环标签-标签是后面跟有冒号的标识符
 *<p>
 *    1.java中，标签起作用的唯一地方是刚好在迭代语句之前:即在标签和迭代语句之间置入任何语句都不好
 * 2.在迭代之前设置标签的唯一理由是：我们希望在其中嵌套另一个迭代或者一个开关switch;break和continue只能中断当前循环，与标签一起使用，则会中断循环，直到标签所在地方
 * 3.注意：在java中使用标签的理由就是因为有嵌套迭代的存在，而且想从多层嵌套中break或者continue
 *</p>
 *
 *@author landon
 *@since JDK1.6
 *@version 1.0 2012-3-21
 *
 */
public class LoopLabel
{
    public static void main(Stringargs)
    {
        int i = 0;
        //label
        OUTER:
            while(true)
            {
                System.out.println("outter while loop");
                while(true)
                {
                    i++;
                    System.out.println("i = " + i);
                    
                    if(i == 1)
                    {
                        out.println("continue");
                        continue;
                    }
                    
                    //TODO 带标签的continue回达到标签的位置，然后并重新进入紧接在那个标签后面的循环
                    if(i == 3)
                    {
                        out.println("continue outer");
                        continue OUTER;
                    }
                    
                    if(i == 5)
                    {
                        out.println("break");
                        break;
                    }
                    
                    //TODO 带标签的break会中断并跳出标签所指的循环
                    if(i == 7)
                    {
                        out.println("break outer");
                        break OUTER;
                    }
                }
            }
    }
}

package com.book.chap2.operator;


/** *//**
 *
 *移位
 *<pre>
 *    1.左移<<，按照操作符右侧指定的位数将操作符左侧的操作数向左移动，低位补0
 *    2.“有符号”右移>>,按照操作符右侧指定的位数将操作符左侧的操作数向右移动；“有符号”操作符>>使用符号扩展：若符号为正，则在高位插入0；若符号为负，则在高位插入1
 * 3."无符号"右移，Java新增，它使用零扩展，无论正负，都在高位插入0
 *</pre>
 *
 *@author landon
 *@since JDK1.6
 *@version 1.0 2012-3-21
 *
 */
public class ShiftBit
{
    public static void main(Stringargs)
    {
        int j = 2;
        
        //正-左移
        System.out.println("before shift:"+ j + " " + Integer.toBinaryString(j));
        int shitfJ1 = j << 5;
        System.out.println("after shift:"+ shitfJ1 + " " + Integer.toBinaryString(shitfJ1));
        
        int k = -2;
        
        //负-左移
        System.out.println("before shift:"+ k + " " + Integer.toBinaryString(k));
        int shitfk1 = k << 5;
        System.out.println("after shift:"+ shitfk1 + " " + Integer.toBinaryString(shitfk1));
        
        int i = 128;
        
        //正-右移
        System.out.println("before shift:"+ i + " " + Integer.toBinaryString(i));
        int shitfI1 = i >> 5;
        System.out.println("after shift:"+ shitfI1 + " " + Integer.toBinaryString(shitfI1));
        
        //负-右移,符号为负，右移的时候，高位插入1
        int m = -128;
        System.out.println("before shift:"+ m + " " + Integer.toBinaryString(m));
        int shitfm1 = m >> 5;
        System.out.println("after shift:"+ shitfm1 + " " + Integer.toBinaryString(shitfm1));
        
        int n = 128;
        
        //正-无符号右移，无论正负，高位均插入0
        System.out.println("before shift:"+ n + " " + Integer.toBinaryString(n));
        int shitn1 = n >>> 5;
        System.out.println("after shift:"+ shitn1 + " " + Integer.toBinaryString(shitn1));
        
        //负-无符号右移，无论正负，高位均插入0-->这样一个负数就变成了正数
        int o = -128;
        System.out.println("before shift:"+ o + " " + Integer.toBinaryString(o));
        int shitfo1 = o >>> 5;
        System.out.println("after shift:"+ shitfo1 + " " + Integer.toBinaryString(shitfo1));
    }
}