A. 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語句的執行則意味著使控制傳遞到增量部分。
B. JAVA關鍵字具體的作用和用法
分類: 電腦/網路 >> 程序設計 >> 其他編程語言
問題描述:
本人是JAVA自學者，剛開始學習JAVA，對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語句的執行則意味著使控制傳遞到增量部分。
C. 有沒有較完整的Java中的關鍵字及其含義
java關鍵字
概述
關鍵字是電腦語言里事先定義的,有特別意義的標識符,有時又叫保留字，還有特別意義的變數。 Java的關鍵字對java的編譯器有特殊的意義，他們用來表示一種數據類型，或者表示程序的結構等，關鍵字不能用作變數名、方法名、類名、包名。 一個Java語言中的關鍵字，用在類的聲明中來指明一個類是不能被實例化的，但是可以被其它類繼承。一個抽象類可以使用抽象方法，抽象方法不需要實現，但是需要在子類中被實現。
break
一個Java的關鍵字，用來改變程序執行流程，立刻從當前語句的下一句開始執行。如果後面跟有一個標簽，則從標簽對應的地方開始執行。用來中斷程序的執行，一般用在循環語句中，用來跳出本層循環，轉去執行下面的程序。
case
Java語言的關鍵字，用來定義一組分支選擇，如果某個值和switch中給出的值一樣，就會從該分支開始執行。
catch
Java的一個關鍵字，用旦芹來聲明當try語句塊中發生運行時錯誤或非運行時異常時運行的一個塊。
char
Java語言的一個關鍵字，用來定義一個字元類型。
int
Java語言的一個關鍵字，用來定義一個整型類型數據或變數。
for
Java語言的一個關鍵字，是循環結構中經常使用的一個關鍵字，其形式為： for（表達式1；表達式2；表達式3） { } 其中表達式1用於給相應的變數賦值，表達式2是條件判斷語句，表達式3循環控制語句。
if
Java語言的一個關鍵字，是用來判斷條件用的。 abstract boolean break byte case
catch char class continue default
do double else enum extends
final finally float for if
implements import instanceof int interface
long native new package private
protected public return strictfp short
static super switch synchronized this
throw throws transient try void
volatile while
編輯本段詳細介紹
類和介面
abstract標記為抽象或包含在抽象類中的成員必須通過從抽象類派生的類來實現。 class類， 格式為： class類名 extends 父類名稱{ 屬性聲明及初始化；方法聲明及方法體； } implements實現 import導入 interface介面。 格式為： interface 介面名 [extends 父介面列表]{ [public][static][final]屬性類型屬性名=常量值； [public][abstract]返回值類型方法名（參數列表）； } package打包，聲明僅僅指定了文件中所定義的類屬於哪一個包。 static靜態屬性，用來描述一個類下所有對象共享的屬性。 throws扔，一個方法中發生異常但沒有捕獲，在方法頭聲明，由方法調用者處理。//throw後不允許有其他的語句。 void空
數據類型
boolean 值只能是true和false，而不能用0和1代替，並且一定要小寫。 byte位元組型 char字元型 double雙精度浮點型 float單精度浮點型 int整型 long長整型 short短整型
流程式控制制
break中斷switch語句的執行拆瞎，在循環語句中，同樣也是結束循環語句的執行。 continue 只跳出本次循環，還要繼續執行下一次的循環。break完全跳出所在或者是所標記的循環。 do 和while連用， 格式為： do{ 循環體； }while（循環條件旅遲空）；//不要忘記分號； for 格式為： for（表達式1；表達式2；表達式3）{ 循環體;} final如果不希望某個類被其他的類繼承，在這種情況下需要使用修飾符final來說明一個類是終極的，不能夠做父類。 if 格式為： if（條件表達式） {功能代碼塊1} else {功能代碼塊}//條件表達式返回值為真，則執行功能塊，否則執行else功能塊。 return switch 格式為： switch（表達式）{ case 值1： 功能代碼1； [break;] case 值2： 功能代碼2； [break;]； …… case 值n： 功能代碼n； [break;] default：功能代碼others；} while 格式為： while（循環條件） {循環體;}
訪問范圍
private 私有地，Private 語句 在模塊級別中使用，用於聲明私有變數及分配存儲空間。 默認訪問控制(package ),如果在成員變數和方法前不加任何訪問許可權修飾符，則稱為默認訪問控制，也稱為包訪問控制。這意味著同一包內的其他所有類都能訪問該成員，但對包外的所有類就不能訪問。 protected 表明被它修飾的成員變數為保護類型，在同一個包里和 public 類型是一樣的，也是能夠訪問到的。但是如果在不同包里的 protected 類型的成員變數就只能通過子類來訪問，這個修飾符是區別於其他的修飾符的。 public 公共的，他表示某個變數或者函數是全局函數，例如:public int a 表示a這個整型變數是全局變數。
類的實例
new 該子句創建一個新的對象實例。New 子句必須指定一個可以用來創建實例的已定義類。可以在聲明語句或賦值語句中使用 New。執行該語句時，它將調用指定類的構造函數，傳遞提供的所有參數。 this引用屬性，當方法中的參數和某個屬性有相同的名字時，這是局部變數優先，屬性被隱藏。然而，有時為了能夠在方法中以用隱藏的屬性，就可以用this區分，由this引用的就是屬性，沒有this引用的則是局部變數或者是參數。 super被繼承的類稱為超類，繼承的類稱為子類。
其它
1、catch捕獲錯誤的語句。 2、finally為了完成執行的代碼而設計的，主要是為了程序的健壯性和完整性，無論有沒有異常發生都執行代碼。 3、native是方法修飾符。Native方法是由另外一種語言（如c/c++，FORTRAN，匯編）實現的本地方法。因為在外部實現了方法，所以在java代碼中，就不需要聲明了，有點類似於介面方法。Native可以和其他一些修飾符連用，但是abstract方法和Interface方法不能用native來修飾。 4、strictfp 修飾類和方法，意思是FP-strict，精確浮點，符合IEEE-754規范的。當一個class或interface用strictfp聲明，內部所有的float和double表達式都會成為strictfp的。Interface method不能被聲明為strictfp的，class的可以。 5、try 當try子句中的某行代碼發生異常，會終止程序的運行，跳轉到catch子句來執行。 6、transient 變數修飾符。標記為transient的變數，在對象存儲時，這些變數狀態不會被持久化。當對象序列化的保存在存儲器上時，不希望有些欄位數據被保存，為了保證安全性，可以把這些欄位聲明為transient。 7、volatile volatile修飾變數。在每次被線程訪問時，都強迫從共享內存中重讀該成員變數的值。而且，當成員變數發生變化時，強迫線程將變化值回寫到共享內存。這樣在任何時刻，兩個不同的線程總是看到某個成員變數的同一個值。 8、goto java中關鍵字表中雖然沒有goto關鍵字但是在聲明變數時是不可以使用該單詞的因為goto 是 Java 中一個沒有使用的關鍵字，如果想叫做保留字也可以。 一般結構化程序，都不需要使用 Goto 語句的，在有分支和循環以及遞歸調用之後，goto 完全可以不使用了。為了程序代碼更簡捷，對於循環結構，還有 break 和 continue 用於跳轉。而且，break 和 continue 都可以帶標簽，更增加了它們的靈活性。
D. java中this的關鍵字用法是什麼
一、this關鍵字主要有三個應用：
(1)this調用本類中的屬性，也就是類中的成員變數；
(2)this調用本類中的其他方法；
(3)this調用本類中的其他構造方法，調用時要放在構造方法的首行。
Public Class Student {
String name; //定義一個成員變數name
private void SetName(String name) { //定義一個參數(局部變數)name
this.name=name; //將局部變數的值傳遞給成員變數
}
}
應用一：引用成員變數
如上面這段代碼中，有一個成員變數name，同時在方法中有一個形式參數，名字也是name，然後在方法中將形式參數name的值傳遞給成員變數name，雖然我們可以看明白這個代碼的含義，但是作為Java編譯器它是怎麼判斷的呢?到底是將形式參數name的值傳遞給成員變數name，還是反過來將成員變數name的值傳遞給形式參數name呢?也就是說，兩個變數名字如果相同的話，那麼Java如何判斷使用哪個變數?此橘睜時this這個關鍵字就起到作用了。this這個關鍵字其代表的就是對象中的成員變數或者方法。也就是說，如果在某個變數前面加上一個this關鍵字，其指的就是這個對象的成員變數或者方法，而不是指成員方法的形式參數或者局部變數。為此在上面這個代碼中，this.name代表的就是對象中的成員變數，又叫做對象的屬性，而後面的name則是方法的形式參數，代碼this.name=name就是將形式參數的值傳遞給成員變數。這就是上面這個代碼的具體含義。
一般情況下，在Java語言中引用成員變數或者成員方法都是以對象名.成員變數或者對象名.成員方法的形式。不過有些程序員即使在沒有相同變數的時候，也喜歡使用this.成員變數的形式來引用變數，這主要是從便於代碼的閱讀考慮的。一看到這個this關鍵字就知道現在引用的變數是成員變數或者成員方法，而不是局部變數。這無形中就提高了代碼的閱讀性。不過話說回來，這是this關鍵字在Java語言中的最簡單的應用。從這個應用中，我們可以看出this關鍵字其代表的就是對象的名字。
其實如果是局部變數的話，也是相同的道理。如在上面的代碼中，name不是形式參數，而是一個局部變數。此時Java也會遇到相同的疑惑，即變數名name代表的到底是局部變數還是形式參數?name=name到底代表的是什麼含義?根據局部變數的作用域，在方法內部，如果局部變數與成員變數同名的話，那麼是以局部變數為准。可是在name=name這個賦值語句中，將局部變數的值賦值給自己，顯然並不是很合適。根芹陸據代碼的含義，本來的意思應該是將局部變數賦值給成員變數。為了更清晰的表達這個含義，為此最好採用如下的書寫格式this.name=name。這里的this關鍵字含義就是對象名student，為此this.name就表示student.name。
應用二：調用類的構造方法
public class Student { //定義一個類，類的名字為student。
public Student() { //定義一個方法，名字與類相同故為構造方法
this(「Hello!」);
}
public Student(String name) { //定義一個帶形式參數的構造方法
}
}
this關鍵字除了可以調用成員變數之外，還可以調用構造方法。在一個Java類中，其方法可以分為成員方法和構造方法兩種。構造方法是一個與類同名的方法，在Java類中必須存在一個構造方法。如果在代碼中沒有顯示的體現構造方法的話，那麼編譯器在編譯的時候會自動添加一個圓首歲沒有形式參數的構造方法。這個構造方法跟普通的成員方法還是有很多不同的地方。如構造方法一律是沒有返回值的，而且也不用void關鍵字來說明這個構造方法沒有返回值。而普通的方法可以有返回值、也可以沒有返回值，程序員可以根據自己的需要來定義。不過如果普通的方法沒有返回值的話，那麼一定要在方法定義的時候採用void關鍵字來進行說明。其次構造方法的名字有嚴格的要求，即必須與類的名字相同。也就是說，Java編譯器發現有個方法與類的名字相同才把其當作構造方法來對待。而對於普通方法的話，則要求不能夠與類的名字相同，而且多個成員方法不能夠採用相同的名字。在一個類中可以存在多個構造方法，這些構造方法都採用相同的名字，只是形式參數不同。Java語言就憑形式參數不同來判斷調用那個構造方法。
在上面這段代碼中，定義了兩個構造方法，一個帶參數，另一個沒有帶參數。構造方法都不會有返回值，不過由於構造方法的特殊性，為此不必要在構造方法定義時帶上void關鍵字來說明這個問題。在第一個沒有帶參數的構造方法中，使用了this(「Hello!」)這句代碼，這句代碼表示什麼含義呢?在構造方法中使this關鍵字表示調用類中的構造方法。如果一個類中有多個構造方法，因為其名字都相同，跟類名一致，那麼這個this到底是調用哪個構造方法呢?其實，這跟採用其他方法引用構造方法一樣，都是通過形式參數來調用構造方法的。如上例中，this關鍵字後面加上了一個參數，那麼就表示其引用的是帶參數的構造方法。如果現在有三個構造方法，分別為不帶參數、帶一個參數、帶兩個參數。那麼Java編譯器會根據所傳遞的參數數量的不同，來判斷該調用哪個構造方法。從上面示例中可以看出，this關鍵字不僅可以用來引用成員變數，而且還可以用來引用構造方法。
不過如果要使用這種方式來調用構造方法的話，有一個語法上的限制。一般來說，利用this關鍵字來調用構造方法，只有在無參數構造方法中第一句使用this調用有參數的構造方法。否則的話，翻譯的時候，就會有錯誤信息。這跟引用成員變數不同。如果引用成員變數的話，this關鍵字是沒有位置上的限制的。如果不熟悉這個限制的話，那麼還是老老實實的採用傳統的構造方法調用方式為好。雖然比較麻煩，但是至少不會出錯。
應用三：返回對象的值
this關鍵字除了可以引用變數或者成員方法之外，還有一個重大的作用就是返回類的引用。如在代碼中，可以使用return this，來返回某個類的引用。此時這個this關鍵字就代表類的名稱。如代碼在上面student類中，那麼代碼代表的含義就是return student。可見，這個this關鍵字除了可以引用變數或者成員方法之外，還可以作為類的返回值，這才是this關鍵字最引人注意的地方。
E. java中this的關鍵字用法是什麼
Java關鍵字this只哪雹擾能用於方法方法體內。當一個對象創建後，Java虛擬機（JVM）就會給這個對象分配一個引用自身的指針，這個指針的名字就是 this。
this主要要三種用法：
表示對當前對象的引用。
表示用類的成員變數，而非函數參數李旦，注意在函數參數和成員變數同名是進行區分。這是第一種用法的特例，比較常用。
用於在構肆談造方法中引用滿足指定參數類型的構造器（其實也就是構造方法）。注意：只能引用一個構造方法且必須位於開始。
this不能用在static方法中！有人給static方法的定義：沒有this的方法。
F. java 中的 final 關鍵字有哪些用法
根據程序上下文環境，Java關鍵字final有「這是無法改變的」或者「終態的」含義，它可以修飾非抽象類、非抽象類成員方法和變數。你可能出於兩種理解而需要阻止改變：設計或效率。
final類不能被繼承，沒有子類，final類中的方法默認是final的。
final方法不能被子類的方法覆蓋，但可以被繼承。
final成員變數表示常量，只能被賦值一次，賦值後值不再改變。
final不能用於修飾構造方法。
注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。
G. java使用什麼關鍵字實現繼承
Java 用關鍵字extends實現繼承，具體為 class 子類名 extends 父類名{}
如果父類中無無參構造函數，記得使用super()調用父類的有參構造函數，如果父類中有抽象方法，也請記得實現
H. java中關鍵字 this 和super的作用及用法
Java關鍵字this、super使用總結
一、this
Java關鍵字this只能用於方法方法體內。當一個對象創建後，Java虛擬機（JVM）就會給這個對象分配一個引用自身的指針，這個指針的名字就是this。因此，this只能在類中的非靜態方法中使用，靜態方法和靜態的代碼塊中絕對不能出現this，這在「Java關鍵字static、final使用總結」一文拿森中給出了明確解釋。並且this只和特定的對象關聯，而不和類關聯，同一個類的不同對象有不同的this。下面給出一個使用this的綜合實例，以便說明問題：
package org.leimin;
public class Test6 {
private int number;
private String username;
private String password;
private int x = 100;
public Test6(int n) {
number = n; // 這個還可以寫為: this.number=n;
}
public Test6(int i, String username, String password) {
// 成員變數和參數同名,成員變數被屏蔽,用"this.成員變數"的方式訪問成員變數.
this.username = username;
this.password = password;
}
// 默認不帶參數的構造方法
public Test6() {
this(0, "未知", "空"); // 通過this調用另一個構造方法
}
public Test6(String name) {
this(1, name, "空"); // 通過this調用另一個構造方法
}
public static void main(String args[]) {
Test6 t1 = new Test6();
Test6 t2 = new Test6("遊客");
t1.outinfo(t1);
t2.outinfo(t2);
}
private void outinfo(Test6 t) {
System.out.println("-----------");
System.out.println(t.number);
System.out.println(t.username);
System.out.println(t.password);
f(); // 這個可以寫為: this.f();
}
private void f() {
// 局部變數與成員變消螞畝量同名,成員變數被屏蔽,用"this.成員變數"的方式訪問成員變數.
int x;
x = this.x++;
System.out.println(x);
System.out.println(this.x);
}
//返回當前實例的引用
private Test6 getSelf() {
return this;
}
}
運行結果如下：
-----------
0
未知
空
100
101
-----------
0
遊客
空
100
101
通過上面的例子，說明在什麼情況下需要用到this：
第一、通過this調用另一個構造方法，用發是this(參數列表)，這個僅僅在類的構造方法中，別的地方不能這么用。
第二、函數參數或者函數中的局部變數和成員變數同名的情況下，成員變數被屏蔽，此時要訪問成員變數則需要用「this.成員變數名」的方式來引用成員變數。當然，在沒有同名的情況下，可以直接用成員變數的名字，而不用this，用了也不為錯，呵呵。
第三、在函數中，需要引用該函所屬類的當前對象時候，直接用this。
其實這些用法總結都是從對「this是指向對象本身物扮的一個指針」這句話的更深入的理解而來的，死記不然容易忘記而且容易搞錯，要理解！
二、super
super關鍵和this作用類似，是被屏蔽的成員變數或者成員方法或變為可見，或者說用來引用被屏蔽的成員變數和成員成員方法。
不過super是用在子類中，目的是訪問直接父類中被屏蔽的成員，注意是直接父類（就是類之上最近的超類）。下面是一個綜合運用super的例子，有兩個類：一個Father類，一個Father類的子類Son，通過這兩個類完全演示了super的用法，一下是代碼：
package org.leimin;
public class Father {
public String v="Father";
public String x="輸出了Father類的public成員變數x!!!";
public Father() {
System.out.println("Father構造方法被調用!");
}
public Father(String v){
this.v="Father類的帶參數構造方法!運行了.";
}
public void outinfo(){
System.out.println("Father的outinfo方法被調用");
}
public static void main(String[] args) {
// TODO 自動生成方法存根
}
}
package org.leimin;
public class Son extends Father{
public String v="Son";
public Son() {
super(); //調用超類的構造方法,只能放到第一行.
System.out.println("Son無參數構造方法被調用!");
//super(); //錯誤的,必須放到構造方法體的最前面.
}
public Son(String str){
super(str);
System.out.println("Son帶參數構造方法被調用!");
}
//覆蓋了超類成員方法outinfo()
public void outinfo(){
System.out.println("Son的outinfo()方法被調用");
}
public void test(){
String v="哈哈哈哈!"; //局部變數v覆蓋了成員變數v和超類變數v
System.out.println("------1-----");
System.out.println(v); //輸出局部變數v
System.out.println(this.v); //輸出(子類)成員變數v
System.out.println(super.v); //輸出超類成員變數v
System.out.println("------2-----");
System.out.println(x); //輸出超類成員變數v,子類繼承而來
System.out.println(super.x); //輸出超類成員變數v
System.out.println("------3-----");
outinfo(); //調用子類的outinfo()方法
this.outinfo(); //調用子類的outinfo()方法
super.outinfo(); //調用父類的outinfo()方法
}
public static void main(String[] args) {
new Son().test();
}
}
子類Son運行結果：
Father構造方法被調用!
Son無參數構造方法被調用!
------1-----
哈哈哈哈!
Son
Father
------2-----
輸出了Father類的public成員變數x!!!
輸出了Father類的public成員變數x!!!
------3-----
Son的outinfo()方法被調用
Son的outinfo()方法被調用
Father的outinfo方法被調用
說明：次例子僅僅為了說明super的用法，實際在設計類的時候一般都盡可能私有(private)化。
通過上面的例子，下面總結一下super的用法：
第一、在子類構造方法中要調用父類的構造方法，用「super(參數列表)」的方式調用，參數不是必須的。同時還要注意的一點是：「super(參數列表)」這條語句只能用在子類構造方法體中的第一行。
第二、當子類方法中的局部變數或者子類的成員變數與父類成員變數同名時，也就是子類局部變數覆蓋父類成員變數時，用「super.成員變數名」來引用父類成員變數。當然，如果父類的成員變數沒有被覆蓋，也可以用「super.成員變數名」來引用父類成員變數，不過這是不必要的。
第三、當子類的成員方法覆蓋了父類的成員方法時，也就是子類和父類有完全相同的方法定義（但方法體可以不同），此時，用「super.方法名(參數列表)」的方式訪問父類的方法。
I. java中的關鍵字是是什麼意思
abstract :表明類或類中的方法是抽象的；
assert ：聲明斷言；
boolean ：基本數據類型之一，布爾類型；
break ：提前跳出一個塊；
byte ：基本數據類型之一，位元組類型；
case ：在switch語句中，表明其中的一個分支
catch ：用於處理例外情況，用來捕捉異常；
char ：基本數據類型之一，字元類型；
class ：類；
continue ：回到一個塊的開始處；
default ：用在switch語句中，表明一個默認的分支；
do ：用在「do while」循環結構中；
double ：基本數據類型之一，雙精度浮點數類型；
else ：在條件語句中，表明當條件不成立時的分支；
extends ：用來表明一個類是另一個類的子類；
final ：用來表明一個類不能派生出子類，或類中的方法不能被覆蓋，或聲明一個變數是常量；
finally ：用於處理異常情況，用來聲明一個肯定會被執行到的塊；
float ：基本數據類型之一，單精度浮點數類型；
for ：一種循環結構的引導詞；
if ：條件語句的引導詞；
implements ：表明一個類實現了給定的介面；
import ：表明要訪問指定的類或包；
instanceof ：用來測試一個對象是否是一個指定的類的實例；
int ：基本數據類型之一，整數類型；
interface ：介面；
long ：基本數據類型之一，長整數類型；
native ：用來聲明一個方法是由與機器相關的語言（如C/C++/FORTRAN語言）實現的；
new ：用來申請新的對象；
package ：包；
private ：一種訪問模式：私有模式；
protected ：一種訪問模式：保護模式；
public ：一種訪問模式：公共模式；
return ：從方法中返回值；
short ：基本數據類型之一，短整數類型；
static ：表明域或方法是靜態的，即該域或方法是屬於類的；
strictfp ：用來聲明FP-strict（雙精度或單精度浮點數）表達式；
算術規范：
super ：當前對象的父類對象的引用；
switch ：分支結構的引用詞；
synchronized ：表明一段代碼的執行需要同步；
this ：當前對象的引用；
throw ：拋出一個異常；
throws ：聲明方法中拋出的所有異常；
thansient ：聲明不用序列化的域；
try ：嘗試一個可能拋出異常的程序塊；
void ：表明方法不返回值；
volatile ：表明兩個或多個變數必須同步地發生變法；
while ：用在循環結構中；
enum ：聲明枚舉類型；
說明：
⑴Java的關鍵字也是隨新的版本發布在不斷變動中的，不是一成不變的。
⑵所有關鍵字都是小寫的。
⑶除這些關鍵字外，Java還定義了一些保留字，也就是說Java保留了它們，但是沒有使用它們，這些詞不 能作為標識符使用。
cast、goto、future、generic、inner、operator、outer、rest、var
⑷true和false不是關鍵字，而是boolean類型直接量。
⑸null也不是關鍵字。
⑹無sizeof運算符；所有類型的長度和表示是固定的，不依賴執行。
J. java關鍵字是什麼
C、D都不是，屬於java字面常量
java關鍵字是電腦語言里事先定義的，有特別意義的標識符，有時又叫保留字，還有特別意義的變數。
Java的關鍵字對java的編譯器有特殊的意義，他們用來表示一種數據類槐臘型，或者表示程序的結構等，關鍵字不能用作變數名、方法名、類名、包名和參數。
以下是java 關鍵字分類列表：（共50個，供大家參考）
訪問控制:
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 短整型
變數引用
super 父類,超類
this 本類
void 無返回值
Java Language Keywords
Here's a list of keywords in the Java programming language. You cannot use any of the following as identifiers in your programs. The keywords const and goto are reserved, even though they are not currently used. true, false, and null might seem like keywords, but they are actually literals; you cannot use them as identifiers in your programs.
abstract
continue
for
new
switch
assert***
default
goto*
package
synchronized
boolean
do
if
private
this
break
double
implements
protected
throw
byte
else
import
public
throws
case
enum****
instanceof
return
transient
catch
extends
int
short
try
char
final
interface
static
void
class
finally
long
strictfp**
volatile
const*
float
native
super
while
*
not used
**
added in 1.2
***
added in 1.4
****
added in 5.0