java語言關鍵字

⑶ 求java中的關鍵字

訪問控制:
private 私有的
protected 受保護的
public 公共的

類、方法和變數修飾符
abstract 聲明抽象
class 類
extends 擴允,繼承
final 終極,不可改變的
implements實現
interface 介面
native 本地
new 新,創建
static 靜態
strictfp 嚴格,精準
synchronized 線程,同步
transient 短暫
volatile 易失

程序控制語句
break 跳出循環
continue 繼續
return 返回
do 運行
while 循環
if 如果
else 反之
for 循環
instanceof 實例
switch 開關
case 返回開關里的結果
default 默認

錯誤處理
catch 處理異常
finally 有沒有異常都執行
throw 拋出一個異常對象
throws 聲明一個異常可能被拋出
try 捕獲異常

包相關
import 引入
package 包

基本類型
boolean 布爾型
byte 位元組型
char 字元型
double 雙精度,
float 浮點
int 整型
long 長整型
short 短整型
null 空
true 真
false 假

變數引用
super 父類,超類
this 本類
void 無返回值

---------------------------------------------------------------------

Java語言有51個保留關鍵字，其中const和goto雖然被保留但未被使用。你不能使用保留關鍵字來命名類、方法或變數。

一、保留關鍵字

數據類型：

Boolean int long short byte float double char class interface

流程式控制制：

if else do while for switch case default break continue return try catch finally

修飾符：

public protected private final void static strictfp abstract transient

synchronized volatile native

動作：

package import throw throws extends implements this Super instanceof new

保留字：

true false null goto const

二、訪問修飾符：

訪問修飾符： public , protected , private

* 只能應用於類的成員變數。（局部變數只能在函數的范圍內可見，不能使用訪問修飾符）

* 能夠用來修飾類本身。（protected , private 不能用於頂級類，只能用於內部類）

* 能夠應用於成員方法和構造函數。

下面是一個例子：

package Examples;

public class HelloWorld02{

//以下定義了三個了類成員變數

public String str1="Hello"; //可被你程序中的任何其他代碼訪問

protected String str2="World!"; //程序中同一包的成員和不同包中的該類子類可以訪問

private String str3=" "; //僅該類中的成員可以訪問

String str=str1+str3+str2; //不使用修飾符的話，變數的訪問控制在所在包內為public，

// 不能被所在包外的代碼存取

//以下定義了三個使用不同修飾符和不同參數的構造方法。

public HelloWorld(){

System.out.println(str);

}

protected HelloWorld(long l){

System.out.print("Use \"protected\" constructor! And l is ["+l+"] ");

System.out.println(str);

}

private HelloWorld(float f){

System.out.print("Use \"private\" constructor! And f is ["+f+"] ");

System.out.println(str);

}

//聲明構造方法為void類型是合法的.不過因為沒有返回值,所以不能用來創建新對象.

public void HelloWorld(){

System.out.println(str +" Use the void constructor!");

}

public static void main(String[] args){

HelloWorld hw1=new HelloWorld(); //使用無參數的構造方法

HelloWorld hw2=new HelloWorld(5); // 雖然5是int類型，但會自動提升成long類型

HelloWorld hw3=new HelloWorld(5L);

HelloWorld hw5=new HelloWorld(3.14f); // 但float類型則必須指明，否則會出錯

hw5.HelloWorld(); // 無返回值的構造方法只能這樣調用

(new HelloWorld()).HelloWorld(); //這里創建了一個匿名類對象並調用無返回值的構造方法

}

}

總結：

請認真思考一下：

（1）public、protected、private 可用來修飾哪些成員？

使用這些修飾符的成員的訪問控制是怎樣的？

沒有指定訪問修飾符的成員的訪問控制是怎樣的？

* public、protected和private可以用來修飾類成員變數、方法、構造方法和內部類；

public可以用來修飾頂級類，但protected和private則不行。

注意事項：

* 每一個java文件中可以包含多個類，但只能存在一個public頂級類，如果聲明了兩個頂級類的話，則會出現編譯錯誤。

二、部分其他修飾符

this：

Java中定義了this關鍵字來訪問當前對象實例內的成員。當局部變數和類實例內的類變數同名時，在這個局部變數所作用區域內類變數就被隱藏了，必須使用this來指明。

static：

有時你希望定義一個類成員，使它的使用完全獨立於該類的任何對象。通常情況下，類成員必須通過它的類的對象訪問，但是可以創建這樣一個成員，它能夠被它所在類使用，而不必引用所在類的實例。將類中的成員聲明為static就能實現這樣的效果。聲明為static的變數實質就是全局變數。當聲明一個對象（某個類的實例）時，並不產生static變數的拷貝，而是該類所有的實例變數共用同一個static變數。

聲明為static的方法有以下三條限制：

* 它們只能訪問static數據

* 它們僅能調用其他的static方法

* 它們不能以任何方式引用this或super

實例分析：

package Examples;

public class StaticDemo{

public static void main(String[] args){

System.out.println(MyStaticClass.str); //不用創建MyStaticClass的實例就能訪問它的str變數

// System.out.println(MyStaticClass.str2); 這句是錯誤的。

MyStaticClass msc=new MyStaticClass(); //這里創建MyStaticClass的一個實例

System.out.println("After create instance:");

msc.printString();

}

}

class MyStaticClass{

static String str="Hello World!";

String str2;

void setString(String s){

str2=s;

}

static void setNewString(String s){

str=s;

}

static void printString(){

//setString(str); 在static方法中調用非static方法是錯誤的

//System.out.println(str2); 也不能訪問非static變數

//Java中是先檢測static變數再檢測static方法的

System.out.println(str); // 可以正常訪問static變數

setNewString("Static method is OK!"); //正常調用static方法

System.out.println(str);

}

}

final：

一個變數可以被聲明為final，這樣做的目的是阻止它的內容被修改。這意味著在聲明final變數的時候，你必須初始化它。一個final變數實質上是一個常數，為final變數的所有字母選擇大寫是一個普遍的編碼約定。聲明為final的變數在實例中不佔用內存。

聲明成final的方法不能被重載。通常，Java在運行時動態的調用方法，這叫做後期綁定（late binding）；由於被聲明為final的方法不能被重載，那麼對final方法的調用可以在編譯時解決，這叫做早期綁定（early bingding）。

聲明為final的類不能被其他類繼承。聲明一個final類含蓄的宣告了它的所有方法也都是final的。所以，聲明一個既是abstract的，又是final的類是不合法的，因為抽象類本身是不完整的，它依靠它的子類提供完整的實現。

strictfp：

Java2向Java語言增加了一個新的關鍵字strictfp。與Java2同時產生的浮點運算計算模型很輕松的使某些處理器可以以較快速度進行浮點運算（例如奔騰處理器）。這個浮點運算計算模型在計算過程中，不需要切斷某些中介值。如果用strictfp來修飾類或方法，可以確保浮點運算（以及所有切斷）正如它們在早期Java版本中那樣准確（即使用原始的浮點運算模型）。切斷隻影響某些操作的指數。當一個類被strictfp修飾，所有該類的方法都自動被strictfp修飾。坦白說，很多程序員從未用過strictfp，因為它只對非常少的問題有影響。

native：

有時你希望調用不是用Java語言寫的子程序，或者你希望調用一個專用的第三方的庫，例如統計學包。雖然這種情況比較少，但Java提供了native關鍵字，該關鍵字用來聲明本機代碼方法。

為聲明一個本機方法，在該方法之前用native修飾符，但是不要定義任何方法體。例如：

public native int meth();

聲明本機方法後，必須編寫本機方法並要執行一系列復雜的步驟使它與Java代碼鏈接。很多本機方法是用C寫的。把C代碼結合到Java程序中的機制是調用Java Native Interface（JNI）。

transient：

如果用transient聲明一個實例變數，當對象儲存時，它的值不需要維持。例如：

class T{

transient int a; // will not persist

int b; // will persist

}

這里，如果T類的一個對象被寫入一個持久的存儲區域，a的內容不被保存，但b將被保存。

volatile：

volatile修飾符告訴編譯器被volatile修飾的變數可以被程序的其他部分改變。一種 這樣的情形是多線程程序。在多線程程序里，有時兩個或更多的線程共享一個相同的實例變數。考慮效率的問題，每個線程可以自己保存該共享變數的私有拷貝。實際的（或主要的）變數副本在不同的時候更新，例如當進入synchronized方法時。當這種方法運行良好時，它在時間上會是低效的。在某些情況下，真正要緊的是變數主副本的值會體現當前的狀態。為保證這點，僅需把變數定義成volatile型，它告訴編譯器它必須總是使用volatile變數的主副本（或者至少總是保持一些私有的最新的主副本的拷貝，反之亦然），同時，對主變數的獲取必須以簡潔次序執行，就像執行私有拷貝一樣。

⑷ java 的關鍵字有哪些

轉的

Abstract 抽象的
一個Java語言中的關鍵字，用在類的聲明中來指明一個類是不能被實例化的，但是可以被其它類繼承。一個抽象類可以使用抽象方法，抽象方法不需要實現，但是需要在子類中被實現

break
一個Java的關鍵字，用來改變程序執行流程，立刻從當前語句的下一句開始執行從。如果後面跟有一個標簽，則從標簽對應的地方開始執行
case
Java語言的關鍵字，用來定義一組分支選擇，如果某個值和switch中給出的值一樣，就會從該分支開始執行。
catch
Java的一個關鍵字，用來聲明當try語句塊中發生運行時錯誤或非運行時異常時運行的一個塊。
char
Java語言的一個關鍵字，用來定義一個字元類型
continue
一個Java的關鍵字，用來打斷當前循環過程，從當前循環的最後重新開始執行，如果後面跟有一個標簽，則從標簽對應的地方開始執行。
do
一個Java語言的關鍵字，用來聲明一個循環，這個循環的結束條件可以通過while關鍵字設置
double
一個Java語言的關鍵字，用來定義一個double類型的變數
else
一個Java語言的關鍵字，如果if語句的條件不滿足就會執行該語句。
final
一個Java語言的關鍵字。你只能定義一個實體一次，以後不能改變它或繼承它。更嚴格的講：一個final修飾的類不能被子類化，一個final修飾的方法不能被重寫，一個final修飾的變數不能改變其初始值。
finally
一個Java語言的關鍵字，用來執行一段代碼不管在前面定義的try語句中是否有異常或運行時錯誤發生。
float
一個Java語言的關鍵字，用來定義一個浮點數變數
for
一個Java語言的關鍵字，用來聲明一個循環。程序員可以指定要循環的語句，推出條件和初始化變數。
if
Java編程語言的一個關鍵字，用來生成一個條件測試，如果條件為真，就執行if下的語句。
implements
Java(TM)編程語言的一個關鍵字，在類的聲明中是可選的，用來指明當前類實現的介面。
import
Java(TM)編程語言的一個關鍵字，在源文件的開始部分指明後面將要引用的一個類或整個包，這樣就不必在使用的時候加上包的名字。
instanceof
一個二操作數的Java(TM)語言關鍵字，用來測試第一個參數的運行時類型是否和第二個參數兼容。
int
Java(TM)的一個關鍵字，用來定義一個整形變數
Java(TM)的一個關鍵字，用來定義一系列的方法和常量。它可以被類實現，通過implements關鍵字。
long
Java語言的一個關鍵字，用來定義一個long類型的變數。
private
Java語言的一個關鍵字，用在方法或變數的聲中。它表示這個方法或變數只能被這個類的其它元素所訪問。
protected
Java語言的一個關鍵字，在方法和變數的聲明中使用，它表示這個方法或變數只能被同一個類中的，子類中的或者同一個包中的類中的元素所訪問。
public
Java語言的一個關鍵字，在方法和變數的聲明中使用，它表示這個方法或變數能夠被其它類中的元素訪問。
return
Java語言的一個關鍵字，用來結束一個方法的執行。它後面可以跟一個方法聲明中要求的值。
short
Java語言的關鍵字，用來定義一個short類型的變數。
static
Java語言的關鍵字，用來定義一個變數為類變數。類只維護一個類變數的拷貝，不管該類當前有多少個實例。"static" 同樣能夠用來定義一個方法為類方法。類方法通過類名調用而不是特定的實例，並且只能操作類變數。
this
Java語言的關鍵字，用來代表它出現的類的一個實例。this可以用來訪問類變數和類方法。
throw
Java語言的關鍵字，允許用戶拋出一個exception對象或者任何實現throwable的對象
throws
Java語言的關鍵字，用在方法的聲明中來說明哪些異常這個方法是不處理的，而是提交到程序的更高一層。
transient
Java語言的關鍵字，用來表示一個域不是該對象串列化的一部分。當一個對象被串列化的時候，transient型變數的值不包括在串列化的表示中，然而非transient型的變數是被包括進去的。
try
Java語言的關鍵字，用來定義一個可能拋出異常語句塊。如果一個異常被拋出，一個可選的catch語句塊會處理try語句塊中拋出的異常。同時，一個finally語句塊會被執行，無論一個異常是否被拋出。
void
Java語言的關鍵字，用在Java語言的方法聲明中說明這個方法沒有任何返回值。"void"也可以用來表示一句沒有任何功能的語句。
volatile
Java語言的關鍵字，用在變數的聲明中表示這個變數是被同時運行的幾個線程非同步修改的。
while
Java語言的一個關鍵字，用來定義一段反復執行的循環語句。循環的退出條件是while語句的一部分。
關於break和continue
continue語句與break語句相關，但較少用到。continue語句用於使其所在的for、while或do-while語句開始下一次循環。在while與do-while語句中，continue語句的執行意味著立即執行測試部分；在for循環語句中，continue語句的執行則意味著使控制傳遞到增量部分。