【詳講】java中的關鍵字

---

關鍵字屬於保留字，在 Java 中具有特殊的含義，比如說 public、final、static、new 等等，它們不能用來作爲變量名。爲了便於你作爲參照，我列舉了 48 個常用的關鍵字，你可以瞅一瞅。

---

abstract：

abstract 關鍵字用於聲明抽象類——可以有抽象和非抽象方法。

abstract修飾符用來修飾類和成員方法

1：用abstract修飾的類表示抽象類，抽象類位於繼承樹的抽象層，抽象類不能被實例化。
2：用abstract修飾的方法表示抽象方法,抽象方法沒有方法體。抽象方法用來描述系統具有什麼功能，但不提供具體的實現。 

abstract 規則：

1：抽象類可以沒有抽象方法，但是有抽象方法的類必須定義爲抽象類，如果一個子類繼承一個抽象類，子類沒有實現父類的所有抽象方法，那麼子類也要定義爲抽象類，否則的話編譯會出錯的。
2：抽象類沒有構造方法，也沒有抽象靜態方法。但是可以有非抽象的構造方法
3：抽象類不能被實例化，但是可以創建一個引用變量，類型是一個抽象類，並讓它引用非抽象類的子類的一個實例

public class TestAbstract{
	 public static void main(String[] args){
		  MyClass mc ; mc = new Sub(); // 強制使用多態
		  mc.m1(); mc.m2(); mc.m3();
   } 
 }
   //抽象類 
  	abstract class MyClass{
		int a; // 屬性
 		public void m1(){ 
			System.out.println("m1()..."); 
		 }	
		 public abstract void m2();
		 abstract public void m3();
  }
  // 子類 
  class Sub extends MyClass{
	   public void m2(){ System.out.println("m2()實現內容...");
   		 }
  	  public void m3(){
   	 		System.out.println("m3()...實現內 容.../"); 
     } 
 }
1.如果一個類繼承抽象類，此類爲抽象類的子類
2. 如果子類不想定義爲抽象類，必須覆蓋父類中所有的抽象方法，否則子類必須定義爲抽象類。
3. 抽象類類名 引用名 = new 子類類名（形參）；

boolean:

 boolean 關鍵字用於將變量聲明爲布爾值類型，它只有 true 和 false 兩個值。

Boolean和boolean的區別

boolean是基本數據類型
Boolean是它的封裝類，和其他類一樣，有屬性有方法，可以new，例如：
Boolean flag = new Boolean("true"); // boolean 則不可以！
Boolean 是boolean 的實例化對象類，和Integer對應int一樣
自jdk1.5.0以上版本後，Boolean在"賦值"和判斷上和boolean一樣，
即是你： boolean b1 = true ; 或者 Boolean b2 = true ; 都可以。
唯一隻能使用Boolean上的就是從列表或者哈希表獲取值時。
比如 :

boolean t = false;
Map map = new HashMap();
map.put("t", t);

那麼獲取值時只能用
Boolean t1 = (Boolean) map.get(t); //前面只能用Boolean強制轉換，不能使用boolean.

break：

 break 關鍵字用於中斷循環或 switch 語句。

①只能在循環體內和switch語句體內使用break；
②當break出現在循環體中的switch語句體內時，起作用只是跳出該switch語句體，並不能終止循環體的執行。若想強行終止循環體的執行，可以在循環體中，但並不在switch語句中設置break語句，滿足某種條件則跳出本層循環體。

for(int i=0;i<month;i++)
            {
                switch(i)
                {
                    case 1:
                        sumday+=31;
                        break;
                    case 2:
                        sumday+=29;
                        break;
                    case 3:
                        sumday+=31;
                        break;
                    case 4:
                        sumday+=30;
                        break;
                    case 5:
                        sumday+=31;
                        break;
                    case 6:
                        sumday+=30;
                        break;
                    case 7:
                        sumday+=31;
                        break;
                    case 8:
                        sumday+=31;
                        break;
                    case 9:
                        sumday+=30;
                        break;
                    case 10:
                        sumday+=31;
                        break;
                    case 11:
                        sumday+=30;
                        break;
                    case 12:
                        sumday+=31;
                        break;
                }
    
            }
break後跳出switch 但是還在for裏

byte：

byte 關鍵字用於聲明一個可以容納 8 個比特的變量。

1. byte是java的基本數據類型，存儲整型數據，佔據1個字節(8 bits)，能夠存儲的數據範圍是-128～+127。

2. Byte是java.lang中的一個類，目的是爲基本數據類型byte進行封裝

Byte可以將對象的引用傳遞，使得多個function共同操作一個byte類型的數據，而byte基本數據類型是賦值之後要在stack(棧區域)進行存儲的；

在java中包裝類，比較多的用途是用在於各種數據類型的轉化中。
比如，現在byte要轉爲String

byte a=0;
String result=Integer.toString(a);

使用泛型時

 List<Integer> nums;
這裏<>需要類。如果你用int。它會報錯的

case：

 case 關鍵字用於在 switch 語句中標記條件的值。

JDK1.7版本之前，case語句只支持可轉換爲int型的類型（byte ,short,char,int(其他的都不可以））和枚舉類型的數據變量；（char可以轉換成int）

 String input = "Monday";
String output = null;
switch(input){
case "Monday":
    output = "星期一";
    break;
case "Tuesday":
    output = "星期二";
    break;
case "Wednesday":
    output = "星期三";
    break;
case "Thursday":
    output = "星期四";
    break;
case "Friday":
    output = "星期五";
    break;
case "Saturday":
    output = "星期六";
    break;
case "Sunday":
    output = "星期日";
    break;
default:
    throw new IllegalArgumentException("無效的輸入參數：" + input);
}
System.out.println(output); //輸出：星期一

catch：

catch 關鍵字用於捕獲 try 語句中的異常。

char：

char 關鍵字用於聲明一個可以容納無符號 16 位比特的 Unicode 字符的變量。

class：

class 關鍵字用於聲明一個類。

continue：

continue 關鍵字用於繼續下一個循環。它可以在指定條件下跳過其餘代碼。

default：

 default 關鍵字用於指定 switch 語句中除去 case 條件之外的默認代碼塊。

do：

 do 關鍵字通常和 while 關鍵字配合使用，do 後緊跟循環體。

double：

double 關鍵字用於聲明一個可以容納 64 位浮點數的變量。

else：

else 關鍵字用於指示 if 語句中的備用分支。

enum：

 enum（枚舉）關鍵字用於定義一組固定的常量。

extends：

extends 關鍵字用於指示一個類是從另一個類或接口繼承的。

final：

final 關鍵字用於指示該變量是不可更改的。

finally：

 finally 關鍵字和 try-catch 配合使用，表示無論是否處理異常，總是執行 finally 塊中的代碼。

float：

float 關鍵字用於聲明一個可以容納 32 位浮點數的變量。

for：

for 關鍵字用於啓動一個 for 循環，如果循環次數是固定的，建議使用 for 循環。

if：

if 關鍵字用於指定條件，如果條件爲真，則執行對應代碼。

implements：

 implements 關鍵字用於實現接口。

import：

import 關鍵字用於導入對應的類或者接口。

instanceof：

instanceof 關鍵字用於判斷對象是否屬於某個類型（class）。

int：

int 關鍵字用於聲明一個可以容納 32 位帶符號的整數變量。

interface：

interface 關鍵字用於聲明接口——只能具有抽象方法。

long：

long 關鍵字用於聲明一個可以容納 64 位整數的變量。

native：

 native 關鍵字用於指定一個方法是通過調用本機接口（非 Java）實現的。

可以將native方法比作Java程序同Ｃ程序的接口，其實現步驟：
　 １、在Java中聲明native()方法，然後編譯；
　２、用javah產生一個.h文件；
　３、寫一個.cpp文件實現native導出方法，其中需要包含第二步產生的.h文件（注意其中又包含了JDK帶的jni.h文件）；
　４、將第三步的.cpp文件編譯成動態鏈接庫文件；
　５、在Java中用System.loadLibrary()方法加載第四步產生的動態鏈接庫文件，這個native()方法就可以在Java中被訪問了。

new：

new 關鍵字用於創建一個新的對象。

null：

如果一個變量是空的（什麼引用也沒有指向），就可以將它賦值爲 null。

package：

package 關鍵字用於聲明類所在的包。

private：

private 關鍵字是一個訪問修飾符，表示方法或變量只對當前類可見。

protected：

protected 關鍵字也是一個訪問修飾符，表示方法或變量對同一包內的類和所有子類可見。

public：

 public 關鍵字是另外一個訪問修飾符，除了可以聲明方法和變量（所有類可見），還可以聲明類。main() 方法必須聲明爲 public。

return：

 return 關鍵字用於在代碼執行完成後返回（一個值）。

short：

 short 關鍵字用於聲明一個可以容納 16 位整數的變量。

static：

static 關鍵字表示該變量或方法是靜態變量或靜態方法。

/**
 * 說明：靜態變量內存分析舉例
 * 
 * @author huayu
 * @date 2018/8/3 
 */
public class Cat {
    //靜態成員變量，就算不new對象它也會在data seg裏面保存一份，它屬於整個類
    //不屬於某個對象。int靜態變量可以用來計數。
    //對靜態值訪問：1.任何一個對象通過對象的引用都可以訪問這個靜態對象，訪問的時候都是同一塊內存
    //2.即便是沒有對象，也可以通過 類名. 來訪問 如：System.out  out是個靜態變量
1.    private static  int sid=0;
    //非靜態成員變量 new對象的時候在堆內存對象中保存，每new一個對象產生一塊
2.    private  String name;
    //非靜態成員變量 new對象的時候在堆內存對象中保存，每new一個對象產生一塊
3.    private int id;
 
    public Cat(String name) {
4.        this.name = name;
5.        id=sid++;
    }
 
    public void info(){
6.        System.out.println("My name is "+name+" No."+id);
    }
 
    public static void main(String[] args) {
        //靜態變量sid屬於整個Cat類，不屬於某個對象，可以用類名.來訪問，所以這兒沒有new任何對 
        //象，直接用類名.（Cat.sid）來訪問的。
7.        Cat.sid=100;
        //字符串常量分配在data seg
8.        Cat mimi=new Cat("mimi");
9.        Cat pipi=new Cat("pipi");
10.       mimi.info();
11.       pipi.info();
 
    }
}
 
打印結果：
My name is mimi No.id=100 sid= 102
My name is pipi No.id=101 sid= 102

strictfp：

strictfp 關鍵字並不常見，通常用於修飾一個方法，確保方法體內的浮點數運算在每個平臺上執行的結果相同。

super：

super 關鍵字可用於調用父類的方法或者變量。

switch：

switch 關鍵字通常用於三個（以上）的條件判斷。

synchronized：

synchronized 關鍵字用於指定多線程代碼中的同步方法、變量或者代碼塊。

this：

this 關鍵字可用於在方法或構造函數中引用當前對象。

throw：

throw 關鍵字主動拋出異常。

throws：

throws 關鍵字用於聲明異常。

transient：

transient 關鍵字在序列化的使用用到，它修飾的字段不會被序列化。

try：

try 關鍵字用於包裹要捕獲異常的代碼塊。

void：

void 關鍵字用於指定方法沒有返回值。

volatile：

 volatile 關鍵字保證了不同線程對它修飾的變量進行操作時的可見性，
 即一個線程修改了某個變量的值，這新值對其他線程來說是立即可見的。

while：

如果循環次數不固定，建議使用 while 循環。