Java语言基础

谁借莪１个温暖的怀抱￠ 2021-09-11 07:22 339阅读 0赞

> > # Java语言基础（一）---关键字、标识符、注释、常量、变量、运算符 #
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 一. 关键字
> 
> > 【注】关键字的所有的字母都是小写
> 
> >  1. 用于定义数据类型的关键字
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> 基本数据类型 </td> 
> > <td> 数值型 </td> 
> > <td> 整数：byte（字节） short（短整型） int （整型） long（长整型） </td> 
> > </tr> 
> > <tr> 
> > <td> 浮点数： float（单精度浮点数） double（双精度浮点数） </td> 
> > </tr> 
> > <tr> 
> > <td> 字符型 </td> 
> > <td> char（字符型） </td> 
> > </tr> 
> > <tr> 
> > <td> 布尔型 </td> 
> > <td> boolean（布尔型） </td> 
> > </tr> 
> > <tr> 
> > <td> 引用数据类型 </td> 
> > <td colspan="2"> chass（类） interface（接口） </td> 
> > </tr> 
> > <tr> 
> > <td colspan="3">  void（表示函数的返回值是无返回值类型） </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> > 
> > 
> 
> >  2. 用于定义数据类型值的关键字  
> >  true
> 
> >  true
> 
> >  true（真） false（假） null（空）
> 
> >  3.  用于定义流程控制的关键字
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> 循环结构 </td> 
> > <td> if（如果） else（否则） </td> 
> > </tr> 
> > <tr> 
> > <td> 选择结构 </td> 
> > <td> switch case default（默认） </td> 
> > </tr> 
> > <tr> 
> > <td> 循环结构 </td> 
> > <td> while do for </td> 
> > </tr> 
> > <tr> 
> > <td> 其他流程控制语句 </td> 
> > <td> break（跳出） continue（继续） return（返回） </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> > 
> > 
> 
> >  4. 用于定义访问权限修饰符的关键字  
> >  private
> 
> >  private
> 
> >  private（私有）  protected（保护） public（公有）
> 
> >  5. 用于定义类，函数，变量修饰符的关键字  
> >  abstract
> 
> >  abstract
> 
> >  abstract（抽象） final（最终） static（静态） synchronized（同步） Enum（枚举）
> 
> >  6. 用于定义类与类之间的关键字  
> >  extends
> 
> >  extends
> 
> >  extends（继承类） implements（实现接口）
> 
> >  7. 用于定义建立实例及引用实例，判断实例的关键字  
> >  new
> 
> >  new
> 
> >  new（实例化类） this（本类对象） super（父类对象） instanceof（判断对象类型）
> 
> >  8. 用于异常处理的关键字  
> >  try
> 
> >  try
> 
> >  try（检查异常） catch（抓住异常） finally（发生异常后最终执行）   
> >  throw
> 
> >  throw
> 
> >  throw（程序中实例化异常抛出） throws（标识方法抛出异常）
> 
> >  9. 用于包的关键字  
> >  package
> 
> >  package
> 
> >  package（创建包名） import（引入包名）
> 
> >  10. 其他修饰符关键字
> 
> > ·        [native][]（本地）
> 
> > native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。
> 
> > ·        [strictfp][]（strict float point (精确浮点)）
> 
> > 使用strictfp关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。
> 
> > ·        [transient][]（变量修饰符，用它声明一个实例变量，在对象序列化时不会被序列化）
> 
> > 当对象被序列化时（写入字节序列到目标文件）时，transient阻止实例中那些用此关键字声明的变量持久化；当对象被反序列化时（从源文件读取字节序列进行重构），这样的实例变量值不会被持久化和恢复。例如，当反序列化对象——数据流（例如，文件）可能不存在时，原因是你的对象中存在类型为java.io.InputStream的变量，序列化时这些变量引用的输入流无法被打开。
> 
> > ·        [volatile][]（类型修饰符，用来修饰被不同线程访问和修改的变量）
> 
> > Java 语言提供了一种稍弱的同步机制,即 volatile 变量.用来确保将变量的更新操作通知到其他线程,保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新. 当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的.
> 
> > ·        [assert][] （断言，可以看作是异常处理的一种高级形式，用于捕捉我们在代码中做出的假设）
> 
> > 在Java中，assert关键字是从JAVA SE 1.4 引入的，为了避免和老版本的Java代码中使用了assert关键字导致错误，Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都将忽略！），如果要开启断言检查，则需要用开关\-enableassertions或\-ea来开启。
> 
> > 二. 标识符
> 
> > 标识符是在程序中自定义的一些名称，由大小写字母\[a-zA-Z\]，数字\[0-9\]，下划线\[ \_ \]，特殊字符\[$\]组成。
> 
> > 1. 标识符的命名规则：
> 
> > （1）数字不可以开头  
> > 
> 
> > （2）不可以使用关键字  
> > 
> 
> > （3） Java中严格区分大小写
> 
> > （4）不能包含空格
> 
> >  
> 
> > 【注】“main”不是关键字，但被JVM（Java虚拟机）识别
> 
> > 2. 标识符的名称规范：
> 
> > （1）包名：多个单词组成时，所有字母小写  
> >   e.g. xxxyyyzzz  
> > 
> 
> >   e.g. xxxyyyzzz 
> 
> >   e.g. xxxyyyzzz 
> 
> > （2）类名和接口名：多个单词组成时，所有单词首字母大写  
> >   e.g. XxxYyyZzz  
> > 
> 
> >   e.g. XxxYyyZzz 
> 
> >   e.g. XxxYyyZzz 
> 
> > （3）变量名和函数名：多个单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写  
> >   e.g. xxxYyyZzz  
> > 
> 
> >   e.g. xxxYyyZzz 
> 
> >   e.g. xxxYyyZzz 
> 
> > （4）常量名：多个单词组成，所有字母大写，每个单词用下划线连接  
> >   e.g. XXX\_YYY\_ZZZ
> 
> >   e.g. XXX\_YYY\_ZZZ
> 
> >   e.g. XXX\_YYY\_ZZZ
> 
> > 三. 注释
> 
> > Java的注释有三种：单行注释，多行注释，文档注释（是程序的说明书，Java特有的，使用javadoc执行程序可以提取出来形成网页，给开发人员看的）。
> 
> >  
> 
> >  
> 
> > //（单行注释）
> 
> >  
> 
> > /\*
> 
> > （多行注释）
> 
> > \*/
> 
> >  
> 
> > /\*\*
> 
> > （文档注释）
> 
> > @author 作者
> 
> > @version 版本号
> 
> > \*/
> 
> > 1. 注释的作用：
> 
> > （1）注解说明程序，但是注意不要每一行都加注释，不然会导致中英文结合地非常密，阅读性差  
> > 
> 
> > （2）调试程序（很重要的应用）
> 
> > 2. 注释的问题：
> 
> > （1）单行注释中能够使用单行注释  
> > 
> 
> > （2）多行注释中能够使用单行注释  
> > 
> 
> > （3）多行注释中不能使用多行注释，文档注释  
> > 
> 
> > （4）文档注释中不能使用文档注释，多行注释
> 
> > 3. 注释的分别用法：
> 
> > （1）类上面加的是文档注释  
> > 
> 
> > （2）函数上面加的是文档注释  
> > 
> 
> > （3）如果修饰符有改变的话，加多行注释  
> > 
> 
> > （4）代码中的某几句话，加单行注释
> 
> > 四. 常量
> 
> > 常量不能被改变数值
> 
> > 1. 常量包括：
> 
> > （1）整数常量  
> > 
> 
> > （2）小数常量  
> > 
> 
> > （3）布尔型常量：true，false  
> > 
> 
> > （4）字符常量：’4’，单个字母  
> > 
> 
> > （5）字符串常量：”abc”  
> > 
> 
> > （6）null常量，值为null
> 
> > 2. 整数常量：
> 
> > （1）十进制\[0-9\]，满10进1  
> > 
> 
> > （2）八进制\[0-7\]，用0开头  
> > 
> 
> > （3）十六进制\[0-9A-F\]，用0x开头  
> > 
> 
> > （4）二进制\[0-1\]，8位1,0表示一个字节，字节是一个数据单位。  
> > 
> 
> > 【注】ASCII码使用指定的7位或8位二进制数组合来表示128或256种可能的字符。  
> >   e.g. 01000001
> 
> >   e.g. 01000001
> 
> >   e.g. 01000001表示A  
> >   e.g. 01000010
> 
> >   e.g. 01000010
> 
> >   e.g. 01000010表示B
> 
> > 2.1 十进制\->二进制：
> 
> > 原理：对十进制数进行除2运算
> 
> > 【实例】：6的二进制
> 
> > System.out.println(Integer.toBinaryString(6));//打印结果为110
> 
> > ·        1
> 
> > 2.2 二进制\->十进制：
> 
> > 原理：对二进制数乘以2n运算（n是从0开始）
> 
> > 【实例 1】：110 => 0∗20+1∗21+1∗22=6
> 
> > 【实例 2】：00110101的十进制（便捷式）
> 
> > （【注】8个1 = 255； 7个1 = 127）
> 
> > 【实例 3】：5 + 4 = 9 内存中的算法：101 + 100 = 1001 =>9
> 
> > 2.3 二进制\->十六进制：
> 
> > 原理：四个二进制位就是一个十六进制位（1111 => 15 = 24−1）
> 
> > 【实例】：十进制90的十六进制
> 
> > 2.4 二进制\->八进制：
> 
> > 原理：三个二进制位就是一个八进制位（111 => 7 =23−1）
> 
> > 【实例】：十进制90的八进制
> 
> > 【注】其他进制转换：先把十进制转换为二进制，再对应地进行转换
> 
> > 2.5 负数的二进制变现形式：
> 
> > 6 =>110 
> 
> > \-6：其实就是6的二进制取反\+1（取反：将二进制的1变成0，0变成1）  
> > 
> 
> > 【注】整数在内存中为4个字节，1个字节为8位
> 
> > 【实例 1】：十进制6的转换为\-6的过程
> 
> > 结论：负数的最高位都是1，取反得来。
> 
> > 【实例 2】：（拓展）求111…111001=？【解题思路】：先减1，再取反，再加负号
> 
> > 五. 变量
> 
> > 变量就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。（Java是强类型语言） 先声明，后使用
> 
> > 【注】：Java在方法中定义的变量不会自动初始化，必须要我们给它初始化后才能使用它。在类中定义的变量会自动初始化。
> 
> > 成员变量（类的内部，方法外部）and局部变量
> 
> > 基本数据类型and 引用数据类型
> 
> >  
> 
> > 1. 变量的初始化：
> 
> > （1）Java在方法中定义的变量不会自动初始化，必须要我们给它初始化后才能使用它。  
> > 
> 
> > （2）在类中定义的变量会自动初始化。
> 
> > 2. 变量的作用域：
> 
> > Java中变量的作用域——大括号划分
> 
> >  
> 
> >  
> 
> > \{ 
> 
> >    int x = 9;
> 
> > \}
> 
> > System.out.println(x); //不可以在大括号外调用X
> 
> > （1）Java同一函数中变量不允许嵌套定义（和C语言中不同）
> 
> > public static void main(String\[\] args)
> 
> > \{ 
> 
> >    int x = 3;
> 
> >     \{ 
> 
> >        int x = 9; //不允许嵌套定义
> 
> >        System.out.println(x);
> 
> >     \}
> 
> >    System.out.println(x);
> 
> > \}
> 
> > ·         
> 
> > （2）Java同一类中允许方法中的变量与成员变量同名
> 
> > class Demo
> 
> > \{ 
> 
> >    private int x;
> 
> >    public int getX()
> 
> >     \{ 
> 
> >        int x = ++this.x;
> 
> >        return x; //此处调用的是方法中定义的x,而非类的成员变量
> 
> >     \}
> 
> > \}
> 
> > 六. 运算符
> 
> > 处理数据的原理就是运算。运算符包括：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三元运算符。
> 
> >  
> 
> >  
> 
> >  
> 
> > 1. 算术运算符：
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> +（正号） </td> 
> > <td colspan="3"> -（负号） </td> 
> > </tr> 
> > <tr> 
> > <td> +（加） </td> 
> > <td> -（减） </td> 
> > <td> *（乘） </td> 
> > <td> /（除）【e.g.】5 / 5 = 1 </td> 
> > </tr> 
> > <tr> 
> > <td colspan="4"> %（取模） 规律：左边小于右边 = 左边 【e.g.】 2 %5 = 2;&nbsp;          左边等于右边 = 0 【e.g. 】5 %5 = 0;&nbsp;          右边等于1 = 0 【e.g. 】5 %1 = 0;&nbsp; </td> 
> > </tr> 
> > <tr> 
> > <td colspan="4"> +（字符串相加） 字符串数据和任何数据使用【+】都是相连接，最终都会变成字符串&nbsp;          【e.g.】(“He” + “llo”) =&gt;(“Hello”)&nbsp; </td> 
> > </tr> 
> > <tr> 
> > <td> ++（自增） </td> 
> > <td colspan="3"> 自增前（先自增，后赋值）： a = 2; b = ++a;  =&gt; a = 3 ; b = 3; </td> 
> > </tr> 
> > <tr> 
> > <td colspan="3"> 自增后（先赋值，后自增）： a = 2; b = a++;  =&gt; a = 3 ; b = 2; </td> 
> > </tr> 
> > <tr> 
> > <td colspan="3"> 【总结】：a++; =&gt; a = a + 1;&nbsp;      a++和++a运算过后，a的值都增加1&nbsp; </td> 
> > </tr> 
> > <tr> 
> > <td> - -（自减） </td> 
> > <td colspan="3"> 自减前（先自减，后赋值）： a = 2; b = - -a;  =&gt; a = 1 ; b = 1; </td> 
> > </tr> 
> > <tr> 
> > <td colspan="3"> 自减后（先赋值，后自减）： a = 2; b = a- -;  =&gt; a = 1 ; b = 2; </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> > 
> > 
> 
> > 【实例】：”+” 字符串连接符的用法
> 
> > System.out.println("5+5=" + 5 +5); //5+5=55
> 
> > System.out.println("5+5=" +(5+5)); //5+5=10
> 
> > System.out.println("a=" + a +", b=" + b); //a=4, b=5
> 
> > 2. 赋值运算符
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> =（赋值） </td> 
> > <td> +=（和赋值） </td> 
> > <td> -=（差赋值） </td> 
> > <td> *=（积赋值） </td> 
> > <td> /=（商赋值） </td> 
> > <td> %=（余数赋值） </td> 
> > </tr> 
> > <tr> 
> > <td colspan="6"> 【注】：以上的符号如”-=” 都是仅为一个运算符符号 </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> > 
> > 
> 
> > 【实例1】x += 4; => x = x + 4;  
> >     
> 
> >     
> 
> >     左右两边的和赋值给左边
> 
> > 【实例2】两个赋值方法对比
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> short s = 4;&nbsp; s = s + 4; </td> 
> > <td> short s = 4;&nbsp; s += 4; </td> 
> > </tr> 
> > <tr> 
> > <td> 先做加法，再做赋值，有自动类型提升的过程 </td> 
> > <td> 这个只做了一次运算，只是运用了赋值运算符，把左右两边的和赋值给左边 </td> 
> > </tr> 
> > <tr> 
> > <td> 【编译失败】，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型 </td> 
> > <td> 【编译成功】，因为”+=”赋值运算符在给s赋值时，自动完成了强转操作 </td> 
> > </tr> 
> > <tr> 
> > <td> 总结：s = (short) (s + 4)这样才能将和赋值给s </td> 
> > <td> 总结：(1)s = 4; (2)s += 4; 这两个表达式都只用了赋值运算符，将int类型赋值给short型，会进行自动类型转换 </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> > 3. 比较运算符：
> 
> > 比较运算符结果都是boolean型，true 或者 false。
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> ==（相等） </td> 
> > <td> ！=（不相等） </td> 
> > <td> &lt;（小于） </td> 
> > <td> &gt;（大于） </td> 
> > <td> &lt;=（小于等于） </td> 
> > <td> &gt;=（大于等于） </td> 
> > </tr> 
> > <tr> 
> > <td colspan="6"> instanceof（检查是否是类的对象） </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> > 
> > 
> 
> > 【实例】：
> 
> > System.out.println("Hello"instanceof String); //true
> 
> > System.out.println(3 > 4); //false
> 
> > 逻辑运算符代表关系，用于连接boolean类型的表达式。
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> &amp; </td> 
> > <td> And （与） </td> 
> > <td> true&nbsp;&nbsp;&amp;&nbsp;&nbsp;true&nbsp;&nbsp;= true true&nbsp;&nbsp;&amp;&nbsp;&nbsp;false = false false &amp;&nbsp;&nbsp;true&nbsp;&nbsp;= false false &amp;&nbsp;&nbsp;false = false </td> 
> > <td> 【结论】：  两边只要有一个为false，结果就是false，  两边只要都为true，结果为true。 </td> 
> > <td> 【实例】： int x = 4;&nbsp; x &gt; 3 &amp; x&nbsp;&lt;&nbsp;4 = false; true &amp; true = true; </td> 
> > </tr> 
> > <tr> 
> > <td> | </td> 
> > <td> or （或） </td> 
> > <td> true&nbsp;&nbsp;|&nbsp;&nbsp;true&nbsp;&nbsp;= true true&nbsp;&nbsp;|&nbsp; false = true false |&nbsp;&nbsp;true&nbsp;&nbsp;= true false |&nbsp;&nbsp;false = false </td> 
> > <td colspan="2"> 【结论】：  两边只要有一个true，结果为true，  两边只要都为false，结果为false。 </td> 
> > </tr> 
> > <tr> 
> > <td> &nbsp; </td> 
> > <td> &nbsp; </td> 
> > <td> &nbsp; </td> 
> > <td colspan="2"> &nbsp; </td> 
> > </tr> 
> > <tr> 
> > <td> ^ </td> 
> > <td> xor （异或） </td> 
> > <td> true&nbsp;&nbsp;^&nbsp;&nbsp;true&nbsp;&nbsp;= false true&nbsp;&nbsp;^&nbsp;&nbsp;false = true false ^&nbsp;&nbsp;true&nbsp;&nbsp;= true false ^&nbsp;&nbsp;false = false </td> 
> > <td colspan="2"> 【结论】：  两边相同，结果为false，  两边不同，结果为true。 </td> 
> > </tr> 
> > <tr> 
> > <td> ！ </td> 
> > <td> Not （非） </td> 
> > <td colspan="3"> ！true = false&nbsp; </td> 
> > </tr> 
> > <tr> 
> > <td> &amp;&amp; </td> 
> > <td> And （短路） </td> 
> > <td colspan="3"> 【 &amp; 与 &amp;&amp; 的区别】：  &amp;：无论左边是true，还是false，右边都运算。  &amp;&amp;：当左边为false时，右边不运算，因为结果肯定为false，      左边为true，右边参与运算。 </td> 
> > </tr> 
> > <tr> 
> > <td> || </td> 
> > <td> or （短路） </td> 
> > <td colspan="3"> 【 | 与 || 的区别】：  |：无论左边是true，还是false，右边都运算。  ||：当左边为true时，右边不运算，因为结果肯定为true，    左边为false，右边参与运算。 </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> >  
> 
> > 5. 位运算符：
> 
> > 位运算符是二进制运算的运算符，“位”是二进制的位，是最快的运算，但局限是基为2。
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td> &lt;&lt;&nbsp; </td> 
> > <td> 左移 </td> 
> > <td colspan="2"> 3&nbsp;&lt;&lt;&nbsp;2   =&gt; 3∗22=12 </td> 
> > </tr> 
> > <tr> 
> > <td> &gt;&gt;&nbsp; </td> 
> > <td> 带符号右移 </td> 
> > <td> 3&nbsp;&gt;&gt;&nbsp;1   =&gt; 3&nbsp;/&nbsp;21=1 </td> 
> > <td> 高位空出来要补什么？ 按原有数据的高位置是0补0，是1补1。 </td> 
> > </tr> 
> > <tr> 
> > <td> &gt;&gt;&gt;&nbsp; </td> 
> > <td> 无符号右移 </td> 
> > <td> 3&nbsp;&gt;&gt;&gt;&nbsp;1 =&gt; 3&nbsp;/&nbsp;21=1 </td> 
> > <td> 右移空出来都拿0补 </td> 
> > </tr> 
> > <tr> 
> > <td> &amp; </td> 
> > <td> 与运算 </td> 
> > <td colspan="2"> 6 &amp; 3 = 2 </td> 
> > </tr> 
> > <tr> 
> > <td> | </td> 
> > <td> 或运算 </td> 
> > <td colspan="2"> 6 | 3 = 7 </td> 
> > </tr> 
> > <tr> 
> > <td> ^ </td> 
> > <td> 异或运算 </td> 
> > <td colspan="2"> 6 ^ 3 = 5 </td> 
> > </tr> 
> > <tr> 
> > <td> ~ </td> 
> > <td> 反码 </td> 
> > <td colspan="2"> ~6 = -7 </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> > 
> > 
> 
> > 【实例】：左移，右移，无符号右移之间的区别
> 
> > <table> 
> > <tbody> 
> > <tr> 
> > <td colspan="2"> 【 1.&nbsp;&lt;&lt;&nbsp;与&nbsp;&gt;&gt;&nbsp;的区别】： </td> 
> > </tr> 
> > <tr> 
> > <td> &lt;&lt;（左移） </td> 
> > <td> 其实就是乘以2的移动位数为次幂 </td> 
> > </tr> 
> > <tr> 
> > <td> &gt;&gt;（右移） </td> 
> > <td> 其实就是除以2的移动位数为次幂 </td> 
> > </tr> 
> > <tr> 
> > <td colspan="2"> 【 2.&nbsp;&gt;&gt;&nbsp;时，正数和负数 的区别】： </td> 
> > </tr> 
> > <tr> 
> > <td> &gt;&gt;（正数右移时） </td> 
> > <td> 高位补0 </td> 
> > </tr> 
> > <tr> 
> > <td> &gt;&gt;（负数右移时） </td> 
> > <td> 高位补1 </td> 
> > </tr> 
> > <tr> 
> > <td colspan="2"> 【 3.&nbsp;&gt;&gt;&nbsp;与&nbsp;&gt;&gt;&gt;&nbsp;的区别】： </td> 
> > </tr> 
> > <tr> 
> > <td> &gt;&gt;（带符号右移） </td> 
> > <td> 高位补0或1：具体看原有值高位，是0补0，是1补1 </td> 
> > </tr> 
> > <tr> 
> > <td> &gt;&gt;&gt;（无符号右移） </td> 
> > <td> 高位都补0 </td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> >  
> 
> > 5.1 <<（左移）：
> 
> > 【实例】： 3 << 2   => 3∗22=12
> 
> > 【总结】：m << n   => m∗2n  （向左边移动，右边用0补。）
> 
> > 5.2 >>（右移）：
> 
> > 【实例 1】：正数右移：3 >> 1   => 3 / 21=1
> 
> > 【总结】：m >> n   => m / 2n  
> 
> > 【实例 2】：负数右移： −3 >> 1   => −3 / 21=−2
> 
> > （1）将3转换为二进制的\-3（取反加1）  
> > 
> 
> > （2）将二进制的\-3右移1位，高位用1补（负数高位为1）  
> > 
> 
> > （3）将二进制的\-3转换为十进制（减1取反）
> 
> > 【总结】：负数右移还是负数。
> 
> > 5.3 >>>（无符号右移）：
> 
> > 【实例 1】：正数无符号右移：3 >>> 1   => 3 / 21=1
> 
> > 【实例 2】：负数无符号右移：\-3 >>> 1   => −3 / 21=2147483646
> 
> > 【总结】：如果是负数右移的话，高位也补0，此时的数就转变为了正数
> 
> > 5.4 &（与运算）：
> 
> > 【实例】： 6 & 3 = 2
> 
> > 5.5 | （或运算）：
> 
> > 【实例】： 6 | 5 = 7
> 
> > 5.6 ^（异或运算）：
> 
> > 【实例 1】： 6 ^ 5 = 3
> 
> > 【实例 2】：异或运算还可以用于加密解密： 7 ^ 4 ^ 4 = 7;（“4”相当于密钥）
> 
> > 【总结】：一个数异或同一个数两次，结果是本身。
> 
> > 5.7 ~（反码）：
> 
> > 【实例】： ~6 = -7  步骤：（1）取反，（2）减1，（3）取反，（4）加负号
> 
> > 5.8 位运算练习：
> 
> > 【实例 1】：最有效的方式算出2乘以8等于几？
> 
> > 解： 2 \* 8 = 2∗23 => 2的二进制位向左移了3位；  
> >     2
> 
> >     2
> 
> >     2的二进制为000..0000-0010  
> >    
> 
> >    
> 
> >    左移了3位：000..0001-0000 => 16
> 
> > 【实例 2】：对两个整数变量的值进行交换（不需要第三方变量）
> 
> > // （1）使用第三方变量
> 
> >    int n = 3, m = 8;
> 
> >    int temp;
> 
> >    temp = n;
> 
> >     n= m;
> 
> >     m= temp;
> 
> >  
> 
> > // （2）不需要使用第三方变量，利用两数的和
> 
> >     n= n + m;
> 
> >     m= n - m;
> 
> >     n= n - m;
> 
> >  
> 
> > // （3）不需要使用第三方变量，利用异或同一个数两次还是本身
> 
> >     n= n ^ m;
> 
> >     m= n ^ m; //m = (n ^ m) ^ m;
> 
> >     n= n ^ m; //n = (n ^ m) ^ n;
> 
> > 
> > 
> 
> > 【实例 3】： 60（十进制）转换为十六进制，用代码
> 
> > public static void main(String\[\] args) 
> 
> >     \{ 
> 
> >        int num = 60;
> 
> >  
> 
> >        //取出最低4位，方法：通过&15
> 
> >        int n1 = num & 15;
> 
> >  
> 
> >        //输出最低4位的十六进制值
> 
> >        System.out.println(n1 > 9 ? (char)(n1 - 10 + 'A') : n1); 
> 
> >        //char是两个字节，int是四个字节，(n1 - 10 + 'A')会自动类型提升为int型，所以输出结果为67
> 
> >  
> 
> >        //获取下一组4位，右移4位
> 
> >        int temp = num >>> 4;
> 
> >        int n2 = temp & 15;
> 
> >        System.out.println(n2 > 9 ? (char)(n2 - 10 + 'A') : n2);
> 
> >     \}

> 【实例 4】：（扩展） \-60（十进制）转换为十六进制
> 
> 6. 三元运算符：
> 
> （条件表达式）？表达式 1 ：表达式 2； =>一定有结果
> 
> （1）如果条件为true，运算后的结果为表达式 1；   
> 
> 
> （2）如果条件为false，运算后的结果为表达式 2；
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>

[native]: http://blog.163.com/yueyemaitian@126/blog/static/21475796200701491621267/
[strictfp]: http://blog.csdn.net/basenet855x/article/details/6691040
[transient]: http://www.importnew.com/12611.html
[volatile]: http://www.cnblogs.com/yakun/p/3589437.html%29
[assert]: http://lavasoft.blog.51cto.com/62575/43735/