摘要：和也許看起來像是關(guān)鍵字，但是他們專門用于表示布爾類型的字面量。值得注意的是，在中整形值和布爾值之間不能相互轉(zhuǎn)換至少在語言層面。相關(guān)的操作等于不等于取反位與異或或條件與條件或三目運(yùn)算符在控制流程中使用一個(gè)布爾值可且僅可被轉(zhuǎn)型為，類型。

Java 語言中有 50 個(gè)關(guān)鍵字，這些關(guān)鍵字不能用作標(biāo)識(shí)符，如下圖所示（來自 jls8)

其中關(guān)鍵字 const 和 goto 是預(yù)留的，現(xiàn)在無法使用，并且在程序中出現(xiàn)會(huì)是編譯器產(chǎn)生錯(cuò)誤信息。

true 和 false 也許看起來像是關(guān)鍵字，但是他們專門用于表示布爾類型的字面量。類似的， null 專門用于表示 Null 類型的字面量。

其中 strictfp 始于 1.2，assert 始于 1.4， enum 始于 1.5， 這里說的都是 JDK 的版本。

下面我們先開始將關(guān)鍵詞分類，無法的分類的關(guān)鍵詞將分開講解。

char

boolean

double float

byte int long short

共計(jì) 8 中類型的基本類型，占據(jù)了 Java 的 8 的關(guān)鍵字。
下面簡(jiǎn)單介紹一下，從最簡(jiǎn)單的開始。

很簡(jiǎn)單，非真即假，有兩個(gè)字面量，true 和 false。 值得注意的是，在 Java 中整形值和布爾值之間不能相互轉(zhuǎn)換,至少在語言層面。網(wǎng)上有關(guān) boolean 在內(nèi)存中占用多大空間，這涉及到一個(gè)設(shè)計(jì)與實(shí)現(xiàn)的問題，Java 語言的規(guī)范和 Java 虛擬機(jī)的規(guī)范和最終實(shí)現(xiàn)的 Java 虛擬機(jī)的實(shí)現(xiàn)總會(huì)有實(shí)現(xiàn)上的語意偏離，而 Java 虛擬機(jī)的規(guī)范的原則也是在保證正確性的情況下盡量讓虛擬機(jī)的實(shí)現(xiàn)提升效率。

相關(guān)的操作：

== != 等于 不等于

! 取反

& ^ | 位與 異或 或

&& || 條件與 條件或

? : 三目運(yùn)算符

在控制流程中使用（if, while, do, for）

一個(gè)布爾值可且僅可被轉(zhuǎn)型為 boolean， Boolean, Object 類型。

char 類型用于表示單個(gè)字符。
而關(guān)于 char 的長(zhǎng)度是個(gè)非常有趣的問題，我們首先需要了解編碼的相關(guān)知識(shí)。
可以看一下吳秦的博客，總結(jié)的很好。

在 Java 語言中字符編碼是基于 Unicode 編碼規(guī)范中的 UTF-16 實(shí)現(xiàn)的，UTF-16 具體定義了 Unicode 字符在計(jì)算機(jī)中的存取方法，UTF-16 使用定長(zhǎng)的兩個(gè)字節(jié)來表示 Unicode 的轉(zhuǎn)換格式，也是16位長(zhǎng)度，理論上可以表示
65536 個(gè)字符，然后在當(dāng)時(shí)足夠長(zhǎng)的 char 類型在加入大量東亞體系的表意文字后， 16 位的 char 類型已經(jīng)不能描述所有的 Unicode 字符了。

對(duì)此 Java 的對(duì)應(yīng)策略可以參照 魏照哲的專欄 進(jìn)行理解，學(xué)習(xí)完上面兩篇博客和 Java 既有的字符表現(xiàn)形式，對(duì)于 char 長(zhǎng)度這個(gè)問題大家應(yīng)該要慎重對(duì)待。

Java 的整型的范圍是與機(jī)器無關(guān)的（這與 C，C++ 正好相反），因?yàn)?Java 程序時(shí)運(yùn)行在 Java 虛擬機(jī)之上的，各個(gè)平臺(tái)的上的 Java 虛擬機(jī)遵循同樣的 Java 虛擬機(jī)規(guī)范。

這里再講一些關(guān)于整型字面量表示的內(nèi)容：

// 注意 "0" 是零 不是 字母 o 或 O
int a = 077;   // 前面加 "0" 表示八進(jìn)制數(shù)， 十進(jìn)制 63
int b = 0xee;  // 前面加 "0x" 或 "0X"，后面的 ee 也可以表示成 EE、Ee、eE 表示十六進(jìn)制，十進(jìn)制238
int c = 0b00000001; // 前面加 "0b" 或 "0B"，表示十六進(jìn)制，十進(jìn)制 1 ，JDK 1.7 增加的

另外順便說下在整形字面量和浮點(diǎn)數(shù)中使用下劃線的特性（也是JDK 1.7 增加的）

int a = 1_500_000; // 方便閱讀
float b = 5_6.3_4;
// 需要注意的是不能以 "_" 開頭，只能出現(xiàn)在數(shù)字中間，包括不能出現(xiàn)在進(jìn)制標(biāo)示的后面 "0x_EF" 這樣不合法

怎么說呢，它們無法精確的表示所有數(shù)，對(duì)于很多數(shù)而言，是存在誤差的。
大家先看篇博客，我去喝杯咖啡

if else switch case

while do for

break 用于退出 switch 和 當(dāng)前循環(huán)，另外支持標(biāo)簽跳出多重循環(huán)

continue 用于結(jié)束本輪循環(huán)，從下輪循環(huán)開始執(zhí)行

共計(jì) 9 個(gè)關(guān)鍵字。

關(guān)于流程控制關(guān)鍵字這里只講一下 switch ：
case: 標(biāo)簽可以是：

char, byte, short, int, Character, Byte, Short, Integer

enum 枚舉類型

String 字符串字面量 （JDK 1.7 增加），實(shí)際上是利用 hash 算法轉(zhuǎn)化為 int 類型的語法糖

包括 public protected private

訪問控制符決定了其他類是否可以使用特定的域或調(diào)用特定的方法。訪問控制分為兩個(gè)層次：

頂層，可以修飾類，public, package-private (不需要顯式修飾).

成員層面，public, private, protected 或者 package-private (不需要顯式修飾).

被聲明為 public 的類對(duì)所有類可見，沒有顯式修飾的類只在包內(nèi)可見。
關(guān)于成員的可見性，給出下圖以供理解：

package

import

包是我們用來分類相同功能模塊的類、接口文件的一個(gè)集合，就像我們電腦中文件夾一樣。聲明在類或接口文件的頭部，如下所示：
package packageName
關(guān)于包我們需要牢記的一點(diǎn)是，相同前綴的包除了可以在組織上在一起，但是實(shí)際上他們沒有任何關(guān)系：
例如 com.sun.a 和 com.sun 作為兩個(gè)包沒有任何關(guān)系，屬于獨(dú)立的類集合。

既然包已經(jīng)將我們類組織起來，那么我們?nèi)绾蝸硎褂冒袀€(gè)類的？
我們可以像下面一樣使用類的全限定名：

java.util.Date date = new java.util.Date(); 
// 假如你一直這么干，那么恭喜你，你對(duì) JDK 中常用類分布一定非常熟悉
// 假如你一直這么干，并且使用黑軸的機(jī)械鍵盤，那么很不幸，你手指一定非常酸痛

這時(shí) import 關(guān)鍵字就登場(chǎng)了，我們可以這樣：

import java.util.Date;
...
Date date = new Date();

實(shí)際上在這里我必須要提前講到 static 關(guān)鍵字，JDK 1.5 起支持靜態(tài)導(dǎo)入：

// 讓我們可以不同導(dǎo)入 Math 類再使用 PI 靜態(tài)變量
import static java.lang.Math.PI;   
public  class MathUtils{   
    //計(jì)算圓面積   
    public static double calCircleArea(double r){   
        return PI * r * r;   
    }   
    //計(jì)算球面積   
    public static double calBallArea(double r){   
        return 4 * PI * r * r;   
    }   
}   

int i=3;
switch(i)
{
   case 1:
       System.out.println(1);
       break;
   case 2:
       System.out.println(2);
       break;
   case 3:
       System.out.println(3);
       break;
   default:
       System.out.println("default");
       break;
} 

關(guān)于 default 在注解中的使用
來自 Java Language Specification 8  9.6.2 章節(jié)
An annotation type element may have a default value, specified by following the
element"s (empty) parameter list with the keyword default and an ElementValue
Default values are not compiled into annotations, but rather applied
dynamically at the time annotations are read. Thus, changing a default
value affects annotations even in classes that were compiled before
the change was made (presuming these annotations lack an explicit
value for the defaulted element)

public @interface RequestForEnhancementDefault {
    int id(); // No default - must be specified in each annotation
    String synopsis(); // No default - must be specified in each annotation
    String engineer() default "[unassigned]";
    String date() default "[unimplemented]";
}

It all began with a story,
When java was being developed by James Gosling, Herbert and rest of
his team. They had this crazy thing in mind called platform  independency.
They wanted to make oak(Java) so much better that it
would run exactly same on any machine having different instruction
set, even running different operating systems. But, there was a
problem with decimal point numbers also known as floating point and
double in programming languages. Some machines were built targeting
efficiency while rest were targeting accuracy. So, the later(more
accurate) machines had size of floating point as 80 bits while the
former(more efficient/faster) machines had 64 bit doubles. But, this
was against there core idea of building a platform independent

Also, this might lead to loss of precision/data when a code

built on some machine(having double of 64 bit size) and run on


another kind of machine(having double of 80 bit size).
Up-Sizing can be tolerated but Down-Sizing can"t be. So, they came
across a concept of strictfp i.e. strict floating point. If you use
this keyword with a class/function then its floating point and doubles
have a consistent size over any machine. i.e. 32/64 -bit respectively.