關鍵詞

導航語言基礎主題： ( v • d • e ) 語句條件塊迴圈塊布林表示式變數基本型別算術表示式字面量方法字串物件包陣列數學函式大數隨機數 Unicode 註釋關鍵字編碼規範 Lambda 表示式

關鍵字是語言中的特殊標記，在語言中具有保留用途。關鍵字不能用作 Java 中的識別符號 - 例如，您不能宣告一個名稱為關鍵字的欄位。

關鍵字的示例包括基本型別，int 和 boolean；控制流語句 for 和 if；訪問修飾符，如 public，以及用於標記 Java 類、包和介面的宣告和定義的特殊詞：class、package、interface。

以下是所有 Java 語言關鍵字

abstract
assert （從 Java 1.4 開始）
boolean
break
byte
case
catch
char
class
const （未使用）
continue
default
do
double
else
enum （從 Java 5.0 開始）
extends
final
finally
float
for
goto （未使用）
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
strictfp （從 Java 1.2 開始）
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while

此外，識別符號 null、true 和 false 表示字面量值，不能用於建立識別符號。

abstract

abstract 是一個 Java 關鍵字。它可以應用於類和方法。抽象類不能直接例項化。它必須放在變數型別或方法返回型別之前。建議將其放在訪問修飾符之後，以及 static 關鍵字之後。非抽象類是具體類。抽象類不能是 final。

只有抽象類可以有抽象方法。抽象方法只宣告，不實現

程式碼清單 1：AbstractClass.javapublic abstract class AbstractClass {
    // This method does not have a body; it is abstract.
    public abstract void abstractMethod();
 
    // This method does have a body; it is implemented in the abstract class and gives a default behavior.
    public void concreteMethod() {
        System.out.println("Already coded.");
    }
}

抽象方法不能是 final、static 也不可能是 native。由於抽象類不能直接例項化，您必須要麼例項化一個具體的子類，要麼透過實現其抽象方法以及一個 new 語句來例項化抽象類

程式碼部分 1：抽象類使用。

AbstractClass myInstance = new AbstractClass() {
    public void abstractMethod() {
        System.out.println("Implementation.");
    }
};

私有方法不能是 abstract。

assert

assert 是一個 Java 關鍵字，用於定義一個 斷言語句。斷言語句用於在程式中宣告預期的布林條件。如果程式在啟用斷言的情況下執行，則該條件將在執行時進行檢查。如果條件為假，Java 執行時系統將丟擲一個 AssertionError 斷言可以使用以下語法宣告

assert expression1 [: expression2];

expression1 是一個布林值，如果它為假，將丟擲斷言。當它被丟擲時，斷言錯誤異常將使用引數 expression2（如果適用）建立。

一個例子

assert list != null && list.size() > 0 : "list variable is null or empty";
Object value = list.get(0);

斷言通常用作除錯輔助工具。它們不應用於代替驗證公共方法的引數，也不應用於代替更精確的執行時錯誤異常。

斷言使用 Java -ea 或 -enableassertions 執行時選項啟用。有關控制斷言的更多選項，請參閱您的 Java 環境文件。

boolean

boolean 是一個關鍵字，它指定了 boolean 基本型別。只有兩個可能的 boolean 值：true 和 false。boolean 欄位的預設值為 false。

以下聲明瞭一個名為 initialized 的 private boolean 欄位，並在名為 synchronizeConnection 的方法中使用它。

程式碼部分 1：連線同步。

private boolean initialized = false;

public void synchronizeConnection() {
   if (!initialized) {
      connection = connect();
      initialized = true;
   }
}

前面的程式碼只在第一次方法呼叫時建立一個連線。請注意，在 Java 中，不像一些語言（如 C）那樣，整數型別（如 int）與 boolean 之間沒有自動轉換。相反，必須使用等效的表示式，例如 (i != 0)，如果 i 不為零，則該表示式計算結果為 true。

break

break 是一個 Java 關鍵字。

從迴圈中跳出（中斷）。也用於 switch 語句。

例如

for ( int i=0; i < maxLoopIter; i++ ) {
   System.out.println("Iter=" +i);
   if ( i == 5 ) {
      break;  // -- 5 iteration is enough --
   }
}

另請參閱

Java Programming/Keywords/switch

byte

byte 是一個關鍵字，它指定了 8 位有符號整數基本型別。

當需要儲存 byte 值但需要物件引用時，java.lang.Byte 類是名義上的包裝類。

語法：byte <變數名稱> = <整數值>;

例如

byte b = 65;

或者

byte b = 'A';

數字 65 是 ASCII 中 'A' 的程式碼。

另請參閱

Java Programming/Primitive Types

case

case 是一個 Java 關鍵字。

這是 switch 語句的一部分，用於查詢傳遞給 switch 語句的值是否與 case 後面的值匹配。

例如

int i = 3;
switch(i) {
case 1:
   System.out.println("The number is 1.");
   break;
case 2:
   System.out.println("The number is 2.");
   break;
case 3:
   System.out.println("The number is 3."); // this line will print
   break;
case 4:
   System.out.println("The number is 4.");
   break;
case 5:
   System.out.println("The number is 5.");
   break;
default:
  System.out.println("The number is not 1, 2, 3, 4, or 5.");
}

catch

catch 是一個關鍵字。

它是 try 塊的一部分。如果在 try 塊中丟擲異常，該異常將與塊中的任何 catch 部分進行比較。如果異常與 catch 部分中的一個異常匹配，則異常將在那裡得到處理。

例如

try {
   //...
     throw new MyException_1();
   //...
} catch ( MyException_1 e ) {
   // --- Handle the Exception_1 here --
} catch ( MyException_2 e ) {
   // --- Handle the Exception_2 here --
}

另請參閱

Java Programming/Keywords/try

char

char 是一個關鍵字。它定義了字元基本型別。char 可以從字元字面量和數字表示中建立。字元字面量由一個單引號字元（'）（ASCII 39，十六進位制 0x27）、一個字元和一個結束引號（'）組成，例如 'w'。除了字元之外，還可以使用 Unicode 轉義序列，但必須恰好有一個。

語法

char 變數名稱₁ = '字元₁';

程式碼部分 1：三個示例。

char oneChar1 = 'A';
char oneChar2 = 65;
char oneChar3 = '\u0041';
System.out.println(oneChar1);
System.out.println(oneChar2);
System.out.println(oneChar3);

程式碼部分 1 的輸出

A
A
A

65 是字元 'A' 的數字表示，或其 ASCII 程式碼。

當需要儲存 char 值但需要物件引用時，名義上的包裝類是 java.lang.Character 類。

程式碼部分 2：char 包裝。

char aCharPrimitiveType = 'A';
Character aCharacterObject = aCharPrimitiveType;

另請參閱

Java Programming/Primitive Types

class

class 是一個 Java 關鍵字，它開始宣告和定義一個類。

使用擴充套件巴克斯-諾爾正規化的類宣告的一般語法為

class-declaration ::= [access-modifiers] class identifier
                      [extends-clause] [implements-clause] 
                      class-body

extends-clause ::= extends class-name
implements-clause ::= implements interface-names 
interface-names ::= interface-name [, interface-names]
class-body ::= { [member-declarations] }
member-declarations = member-declaration [member-declarations]
member-declaration = field-declaration 
                     | initializer 
                     | constructor 
                     | method-declaration
                     | class-declaration

extends 詞是可選的。如果省略，該類將擴充套件 Object 類，因為所有 Java 類都繼承自它。

另請參閱

Java Programming/Keywords/new

const

const 是一個保留關鍵字，目前沒有使用。

在其他程式語言中，如 C，const 通常用於宣告常量。但是，在 Java 中，final 代替使用。

continue

continue 是一個 Java 關鍵字。它跳過迴圈的剩餘部分，並繼續執行下一個迭代。

例如

int maxLoopIter = 7;

for (int i = 0; i < maxLoopIter; i++ ) {
   if (i == 5) {
      continue;  // -- 5 iteration is skipped --
   }
   System.println("Iteration = " + i);
}

結果是

另請參閱

Java Programming/Statements

default

default 是一個 Java 關鍵字。

這是嵌入式系統/Atmel AVRswitch 語句的可選部分，當以上所有情況都不匹配時，才執行該語句。

另請參閱

Java Programming/Keywords/switch

do

do 是一個 Java 關鍵字。

它開始一個 do-while 迴圈塊。do-while 迴圈在功能上類似於 while 迴圈，只是條件是在語句執行之後進行評估。

語法

do {
    //statements;
} while (condition);

例如

do {
    i++;
} while ( i < maxLoopIter );

另請參閱

double

double 是一個關鍵字，它指定 64 位浮點基本型別。

當您需要儲存一個 double 值但需要物件引用時，java.lang.Double 類是名義上的包裝類。

語法

double <variable-name> = <float-value>;

例如

double d = 65.55;

另請參閱

Java Programming/Primitive Types

else

else 是一個 Java 關鍵字。它是分支語句的可選部分。它開始“false”語句塊。

使用擴充套件巴科斯正規化，if 的一般語法是

branching-statement ::= if condition-clause 
                                    single-statement | block-statement
                       [ else 
                                    single-statement | block-statement ]
 
condition-clause    ::= ( Boolean Expression )
single-statement    ::= Statement
block-statement     ::= { Statement [ Statement ] }

例如

if ( expression ) {
   System.out.println("'True' statement block");
} else {
   System.out.println("'False' statement block");
}

另請參閱

Java Programming/Keywords/if

enum

/** Grades of courses */
  enum Grade { A, B, C, D, F };
  // ...
  private Grade gradeA = Grade.A;

然後，這個列舉常量可以傳遞給方法

student.assignGrade(gradeA);
  /**
   * Assigns the grade for this course to the student
   * @param GRADE  Grade to be assigned
   */
  public void assignGrade(final Grade GRADE) {
    grade = GRADE;
  }

列舉也可以有引數

public enum DayOfWeek {
  /** Enumeration constants */
  MONDAY(1), TUESDAY(2), WEDNESDAY(3), THURSDAY(4), FRIDAY(5), SATURDAY(6), SUNDAY(0);

  /** Code for the days of the week */
  private byte dayCode = 0;

  /**
   * Private constructor
   * @param VALUE  Value that stands for a day of the week.
   */
  private DayOfWeek(final byte VALUE) {
    dayCode = java.lang.Math.abs(VALUE%7);
  }
 
  /**
   * Gets the day code
   * @return  The day code
   */
  public byte getDayCode() {
    return dayCode;
  }
}

也可以讓列舉實現除 java.lang.Comparable 和 java.io.Serializable 之外的介面，這些介面已經被每個列舉隱式實現。

public enum DayOfWeek implements Runnable {
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
 
  /**
   * Run method prints all elements
   */
  public void run() {
    System.out.println("name() = " + name() +
      ", toString() = \"" + toString() + "\"");
  }
}

extends

extends 是一個 Java 關鍵字。

在 class 和 interface 定義中使用，用於宣告要擴充套件的類或介面。

語法

public class MyClass extends SuperClass 
{
  //...
}
 
public interface MyInterface extends SuperInterface
{
  //...
}

在 Java 1.5 及更高版本中，“extends”關鍵字也用於在泛型中指定型別引數的上限。

class Foo<T extends Number> { /*...*/ }

另請參閱

final

final 是一個關鍵字。注意！它在用於類、方法或變數時具有不同的含義。它必須放在變數型別或方法返回型別之前。建議將其放在訪問修飾符之後以及 static 關鍵字之後。

程式碼部分 1：關鍵字順序。

private static final long serialVersionUID = -5437975414336623381L;

對於變數

final 關鍵字只允許對變數進行一次賦值。也就是說，一旦變數被賦值，它的值就變成了只讀。如果變數是基本型別，它的值將不再改變。如果它是物件，只有它的引用將不再改變。請記住，它的值仍然可以改變。

程式碼部分 2：禁止二次賦值。

final int a = 1;
a = 2;

程式碼部分 3：只修改物件的值。

final ArrayList list = new ArrayList();
System.out.println(list.size());
list.add("One item");
System.out.println(list.size());

程式碼部分 3 的控制檯

0
1

最終變數通常用於通用常量，例如 pi

程式碼部分 4：Pi 常量。

static final double PI = 3.1415926;

final 關鍵字也可以用於方法引數

程式碼部分 5：最終方法引數。

public int method(final int inputInteger) {
   int outputInteger = inputInteger + 1;
   return outputInteger;
}

它對於使用副作用來更新某些物件的方法很有用。此類方法會修改傳遞給引數的物件的內容。方法呼叫者將收到物件更新。如果物件引數在方法中被重新分配，這將失敗。另一個物件將被更新。最終方法引數也可以用於保持程式碼整潔。

final 關鍵字類似於其他語言中的 const 關鍵字以及 C# 中的 readonly 關鍵字。最終變數不能是 volatile。

對於類

final 關鍵字禁止建立子類。例如 Integer 或 String 類。

程式碼清單 1：SealedClass.javapublic final class SealedClass {
  public static void main(String[] args) {
  }
}

最終類不能是 abstract。final 關鍵字類似於 C# 中的 sealed 關鍵字。

對於方法

final 關鍵字禁止在子類中覆蓋該方法。如果類已經是最終類，則它沒有用，私有方法隱式地是 final。最終方法不能是 abstract。

程式碼清單 2：NoOverwriting.javapublic class NoOverwriting {
  public final void sealedMethod() {
  }
}

興趣

final 關鍵字主要用於保證程式碼的良好使用。例如（非static）方法，這允許編譯器擴充套件該方法（類似於行內函數），如果該方法足夠小。有時需要使用它。例如，巢狀類只能訪問頂層類的成員，如果它們是最終的。

另見訪問修飾符。

finally

finally 是一個關鍵字，它是 try 塊的可選結束部分。

程式碼部分 1：try 塊。

try {
  // ...
} catch (MyException1 e) {
  // Handle the Exception1 here
} catch (MyException2 e) {
  // Handle the Exception2 here
} finally {
  // This will always be executed no matter what happens
}

finally 程式碼塊中的程式碼將始終執行。這對於 try 程式碼塊中存在異常或執行 ` return` 語句的情況也是如此。

try 程式碼塊中可能發生三種情況。首先，沒有丟擲異常

程式碼段 2：沒有丟擲異常。

System.out.println("Before the try block");
try {
  System.out.println("Inside the try block");
} catch (MyException1 e) {
  System.out.println("Handle the Exception1");
} catch (MyException2 e) {
  System.out.println("Handle the Exception2");
} finally {
  System.out.println("Execute the finally block");
}
System.out.println("Continue");

程式碼段 2 的控制檯

Before the try block
Inside the try block
Execute the finally block
Continue

您可以看到，我們已經通過了 ` try` 程式碼塊，然後我們執行了 ` finally` 程式碼塊，並繼續執行。現在，丟擲了一個捕獲的異常：|

程式碼段 3：丟擲了一個捕獲的異常。

System.out.println("Before the try block");
try {
  System.out.println("Enter inside the try block");
  throw new MyException1();
  System.out.println("Terminate the try block");
} catch (MyException1 e) {
  System.out.println("Handle the Exception1");
} catch (MyException2 e) {
  System.out.println("Handle the Exception2");
} finally {
  System.out.println("Execute the finally block");
}
System.out.println("Continue");

程式碼部分 3 的控制檯

Before the try block
Enter inside the try block
Handle the Exception1
Execute the finally block
Continue

我們已經通過了 ` try` 程式碼塊，直到發生異常的位置，然後我們執行了匹配的 ` catch` 程式碼塊、` finally` 程式碼塊，並繼續執行。現在，丟擲了一個未捕獲的異常

程式碼段 4：丟擲了一個未捕獲的異常。

System.out.println("Before the try block");
try {
  System.out.println("Enter inside the try block");
  throw new Exception();
  System.out.println("Terminate the try block");
} catch (MyException1 e) {
  System.out.println("Handle the Exception1");
} catch (MyException2 e) {
  System.out.println("Handle the Exception2");
} finally {
  System.out.println("Execute the finally block");
}
System.out.println("Continue");

程式碼段 4 的控制檯

Before the try block
Enter inside the try block
Execute the finally block

我們已經通過了 ` try` 程式碼塊，直到發生異常的位置，然後我們執行了 ` finally` 程式碼塊。try-catch 程式碼塊之後的 **沒有程式碼** 被執行。如果在 try-catch 程式碼塊之前發生了異常，則不會執行 ` finally` 程式碼塊。

如果 ` return` 語句在 finally 程式碼塊中使用，它將覆蓋 try-catch 程式碼塊中的 return 語句。例如，結構

程式碼段 5：Return 語句。

 try {
   return 11;
 }  finally {
   return 12;
 }

將返回 12，而不是 11。專業程式碼幾乎從不包含改變執行順序的語句（如 ` return`、` break`、` continue`）在 finally 程式碼塊中，因為這樣的程式碼更難閱讀和維護。

float

` float` 是一個關鍵字，它指定 32 位浮點數基本型別。

當您需要儲存 ` float` 值但需要物件引用時，`java.lang.Float` 類是名義上的包裝類。

語法

float <variable-name> = <float-value>;

例如

float price = 49.95;

另請參閱

Java Programming/Primitive Types

for

` for` 是一個 Java 關鍵字。

它啟動一個迴圈程式碼塊。

使用擴充套件巴科斯正規化，` for` 的通用語法是

for-looping-statement ::= for condition-clause 
                                    single-statement | block-statement
 
condition-clause    ::= ( before-statement;  Boolean Expression ; after-statement )
single-statement    ::= Statement
block-statement     ::= { Statement [ Statement ] }

例如

for ( int i=0; i < maxLoopIter; i++ ) {
    System.println("Iter: " +i);
}

另請參閱

goto

` goto` 是一個 **保留關鍵字**，目前沒有使用。

if

` if` 是一個 Java 關鍵字。它啟動一個分支語句。

使用擴充套件巴科斯正規化，if 的一般語法是

branching-statement ::= if condition-clause 
                                    single-statement | block-statement
                       [ else 
                                    single-statement | block-statement ]
 
condition-clause    ::= ( Boolean Expression )
single-statement    ::= Statement
block-statement     ::= { Statement [ Statements ] }

例如

if ( boolean Expression )
{
   System.out.println("'True' statement block");
}
else
{
   System.out.println("'False' statement block");
}

另請參閱

Java Programming/Keywords/else

implements

` implements` 是一個 Java 關鍵字。

在 ` class` 定義中使用，宣告要由類實現的介面。

語法

public class MyClass implements MyInterface1, MyInterface2
 {
   ...
 }

另請參閱

import

` import` 是一個 Java 關鍵字。

它宣告一個 Java 類，以便在 import 語句下方的程式碼中使用。一旦聲明瞭 Java 類，就可以在程式碼中使用類名，而無需指定類所屬的包。

使用 '*' 字元宣告屬於該包的所有類。

語法

import package.JavaClass;
import package.*;

靜態匯入結構允許在沒有從包含靜態成員的型別繼承的情況下對靜態成員進行非限定訪問

   import static java.lang.Math.PI;

一旦靜態成員被匯入，就可以在沒有限定的情況下使用它們。

   double r = cos(PI * theta);

注意：儘量不要使用靜態匯入，以避免汙染程式的名稱空間！

另請參閱

Java Programming/Packages

instanceof

` instanceof` 是一個關鍵字。

它檢查物件引用是否是一個型別的例項，並返回一個布林值；

語法

<object-reference> instanceof TypeName

例如

class Fruit
 {
  //...	
 } 
 class Apple extends Fruit
 {
  //...
 }
 class Orange extends Fruit
 {
  //...
 }
 public class Test 
 {
    public static void main(String[] args) 
    {
       Collection<Object> coll = new ArrayList<Object>();
 
       Apple app1 = new Apple();
       Apple app2 = new Apple();
       coll.add(app1);
       coll.add(app2);
 
       Orange or1 = new Orange();
       Orange or2 = new Orange();
       coll.add(or1);
       coll.add(or2);
 
       printColl(coll);
    }
 
    private static String printColl( Collection<?> coll )
    {
       for (Object obj : coll)
       {
          if ( obj instanceof Object )
          {
             System.out.print("It is a Java Object and");
          }
          if ( obj instanceof Fruit )
          {
             System.out.print("It is a Fruit and");
          }
          if ( obj instanceof Apple )
          {
             System.out.println("it is an Apple");
          } 
          if ( obj instanceof Orange )
          {
             System.out.println("it is an Orange");
          }
       }
    }
 }

執行程式

java Test

輸出

"It is a Java Object and It is a Fruit and it is an Apple"
"It is a Java Object and It is a Fruit and it is an Apple"
"It is a Java Object and It is a Fruit and it is an Orange"
"It is a Java Object and It is a Fruit and it is an Orange"

請注意，` instanceof` 運算子也可以應用於介面。例如，如果上面的例子被增強了介面

interface Edible 
{
 //...
}

並且類被修改為實現此介面

class Orange extends Fruit implements Edible
 {
  ...
 }

我們可以詢問我們的物件是否可以食用。

if ( obj instanceof Edible )
 {
   System.out.println("it is edible");
 }

int

` int` 是一個關鍵字，它指定 32 位有符號整數基本型別。

當您需要儲存 ` int` 值但需要物件引用時，`java.lang.Integer` 類是名義上的包裝類。

語法

int <variable-name> = <integer-value>;

例如

int i = 65;

另請參閱

Java Programming/Primitive Types

interface

` interface` 是一個 Java 關鍵字。它啟動 Java 介面的宣告。

例如

public interface SampleInterface
{
   public void method1();
   //...
}

另請參閱

Java Programming/Keywords/new

long

long 是一個關鍵字，它指定 64 位有符號整數基本型別。

當您需要儲存一個 long 值但需要物件引用時，java.lang.Long 類是名義上的包裝類。

語法

long <variable-name> = <integer-value>;

例如

long timestamp = 1269898201;

另請參閱

Java Programming/Primitive Types

native

native 是一個 Java 關鍵字。它標記一個方法，該方法將在其他語言中實現，而不是在 Java 中。該方法宣告時沒有主體，也不能是 abstract。它與 JNI（Java 本地介面）協同工作。

語法

[public|protected|private] native method();

過去，原生方法用於編寫效能關鍵部分，但隨著 Java 的速度越來越快，現在這種情況越來越少見。目前，在以下情況下需要原生方法：

您需要從 Java 呼叫以其他語言編寫的庫。
您需要訪問只能從其他語言（通常是 C）訪問的系統或硬體資源。實際上，許多與實際計算機（例如磁碟和網路 I/O）互動的系統功能之所以能夠做到這一點，是因為它們呼叫了原生程式碼。

要完成原生方法的編寫，您需要使用 javah 工具處理您的類，該工具將生成 C 語言中的頭程式碼。然後，您需要提供頭程式碼的實現，生成動態載入庫（在 Linux 下為 .so，在 Windows 下為 .dll）並載入它（在最簡單的情況下，使用 System.load(library_file_name)）。如果只傳遞了整數之類的原始型別，則程式碼完成非常簡單，但如果需要從 C 程式碼交換字串或物件，則會變得更加複雜。一般來說，一切都可以在 C 層進行，包括建立新物件和回撥在 Java 中編寫的方法。

要呼叫其他語言（包括 C++）中的程式碼，您需要編寫從 C 到該語言的橋接器。這通常很簡單，因為大多數語言都可以在 C 中呼叫。

另請參閱

[1] - JNI 程式設計教程。
[2] - JNI 規範。

new

new 是一個 Java 關鍵字。它建立一個 Java 物件，並在堆上為其分配記憶體。new 也用於陣列建立，因為陣列也是物件。

語法

<JavaType> <variable> = new <JavaObject>();

例如

LinkedList list = new LinkedList();
int[] intArray = new int[10];
String[][] stringMatrix = new String[5][10];

另請參閱

Java Programming/Creating Objects

package

package 是一個 Java 關鍵字。它為 Java 類宣告一個“名稱空間”。它必須放在 Java 檔案的頂部，它應該是第一個 Java 語句行。

為了確保包名稱在不同的供應商之間是唯一的，通常會使用從後向前開始的公司 URL。

語法

package package;

例如

package com.mycompany.myapplication.mymodule;

另請參閱

private

private 是一個 Java 關鍵字，它將成員的訪問許可權宣告為私有。也就是說，該成員只在類內部可見，不在任何其他類（包括子類）中可見。private 成員的可見性擴充套件到巢狀類。

請注意：由於訪問修飾符不是在例項級別處理，而是在類級別處理，因此物件的私有成員在同一個類的其他例項中是可見的！

語法

private void method();

另請參閱

Java Programming/Access Modifiers

protected

protected 是一個 Java 關鍵字。

此關鍵字是一個訪問修飾符，用於在方法或其他類成員之前，表示該方法或變數只能被駐留在其自身類或同一包中的類（如預設可見性級別）的元素訪問，但此外還可以從其自身類的子類訪問，包括外國包中的子類（如果訪問是針對表示式的，其型別是此子類的型別）。

語法

protected <returnType> <methodName>(<parameters>);

例如

protected int getAge();

protected void setYearOfBirth(int year);

另請參閱

Java Programming/Scope#Access modifiers

public

public 是一個 Java 關鍵字，它將成員的訪問許可權宣告為公共。公共成員對所有其他類可見。這意味著任何其他類都可以訪問 public 欄位或方法。此外，其他類可以修改 public 欄位，除非該欄位被宣告為 final。

最佳實踐是為欄位賦予 private 訪問許可權，並將 public 訪問許可權保留給僅定義類公共 API 的方法集和 final 欄位。這有助於封裝和資訊隱藏，因為它允許您更改類的實現，而不會影響僅使用類公共 API 的使用者。

以下是一個名為 Length 的不可變 public 類的示例，該類維護名為 units 和 magnitude 的 private 例項欄位，但提供一個 public 建構函式和兩個 public 訪問器方法。

程式碼清單：Length.javapackage org.wikibooks.java;

public class Length {
   private double magnitude;
   private String units;

   public Length(double magnitude, String units) {
      if ((units == null) || (units.trim().length() == 0)) {
          throw new IllegalArgumentException("non-null, non-empty units required.");
      }

      this.magnitude = magnitude;
      this.units = units;
   }

   public double getMagnitude() {
      return this.magnitude;
   }

   public String getUnits() {
      return this.units;
   }
}

return

return 是一個 Java 關鍵字。

返回一個原始值，或一個物件引用，或無（void）。它不返回值，而只返回物件引用。

語法

return variable;  // --- Returns variable
or
return;           // --- Returns nothing

short

short 是一個關鍵字。它定義一個 16 位有符號整數基本型別。

語法

short <variable-name> = <integer-value>;

例如

short age = 65;

另請參閱

Java Programming/Primitive Types

static

static 是一個 Java 關鍵字。它可以應用於欄位、方法或內部類。靜態欄位、方法或類對定義它的整個類只有一個例項，即使程式中沒有該類的例項。例如，Java 入口點 (main()) 必須是靜態的。靜態方法不能是 abstract。它必須放在變數型別或方法返回值型別之前。建議將其放在訪問修飾符之後和 final 關鍵字之前。

程式碼部分 1：靜態欄位和方法。

public static final double PI = 3.1415926535;

public static void main(final String[] arguments) {
   //…
}

靜態專案可以對例項化的物件或直接對類呼叫。

程式碼部分 2：靜態專案呼叫。

double aNumber = MyClass.PI;
MyClass.main(new String[0]);

靜態方法不能呼叫非靜態方法。this 當前物件引用也不在靜態方法中可用。

興趣

靜態變數可以作為資料共享，在同一個類的物件之間使用。例如，實現一個計數器，它儲存在給定時間建立的物件數量，可以定義如下

程式碼清單 1：CountedObject.javapublic CountedObject {
   private static int counter;
   …
   public AClass() {
      …
      counter++;
   }
   …
   public int getNumberOfObjectsCreated() {
      return counter;
   }
}

counter 變數在每次建立物件時都會遞增。

不應使用公共靜態變數，因為這些變數會變成全域性變數，可以從程式中的任何地方訪問。但是，可以使用全域性常量。見下文

程式碼部分 3：常量定義。

public static final String CONSTANT_VAR = "Const";

靜態方法可用於實用程式函式或不屬於任何特定物件的函式。例如

程式碼清單 2：ArithmeticToolbox.javapublic ArithmeticToolbox {
   …
   public static int addTwoNumbers(final int firstNumber, final int secondNumber) {
        return firstNumber + secondNumber;
   }
}

另見靜態方法

strictfp

strictfp 是一個 Java 關鍵字，自 Java 1.2 起開始使用。

它確保浮點計算結果精確相同，與底層作業系統和硬體平臺無關，即使可以獲得更高的精度。這與早期版本的 Java 1.1 相容。如果您需要，請使用它。

類語法

public strictfp class MyClass 
{ 
  //...
}

方法語法

public strictfp void method() 
{ 
  ...
}

另請參閱

http://en.wikipedia.org/wiki/Strictfp

super

super 是一個關鍵字。

它用在子類方法定義中，用來呼叫超類中定義的方法。無法呼叫超類的私有方法。只能透過 super 關鍵字呼叫公共方法和受保護方法。
它也用在類建構函式中，用來呼叫其父類的建構函式。
super 關鍵字不使用在靜態方法中。

語法

super.<method-name>([zero or more arguments]);

或者

super([zero or more arguments]);

例如

程式碼清單 1：SuperClass.javapublic class SuperClass {
   public void printHello() {
      System.out.println("Hello from SuperClass");
      return;
   }
}

程式碼清單 2：SubClass.javapublic class SubClass extends SuperClass {
   public void printHello() {
      super.printHello();
      System.out.println("Hello from SubClass");
      return;
   }
   public static main(String[] args) {
      SubClass obj = new SubClass();
      obj.printHello();
   }
}

執行上述程式

程式碼清單 2 的命令

$Java SubClass

程式碼清單 2 的輸出

Hello from SuperClass
Hello from SubClass

在 Java 1.5 及更高版本中，“super” 關鍵字還用於在泛型中指定萬用字元型別引數的下限。

程式碼部分 1：萬用字元型別引數的下限。

public void sort(Comparator<? super T> comp) {
  ...
}

另請參閱

extends

switch

switch 是一個 Java 關鍵字。

它是一個基於數字的分支操作。該“數字”必須是 char、byte、short 或 int 基本型別。

語法

switch ( <integer-var> )
{
   case <label₁>: <statements>;
   case <label₂>: <statements>;
   ...
   case <label_n>: <statements>;
   default: <statements>;
}

當 <integer-var> 值與某個 <label> 匹配時，則：匹配標籤後的語句將被執行，包括以下標籤的語句，直到 switch 塊結束，或者遇到 break 關鍵字。

例如

int var = 3;
switch ( var )
{
   case 1: 
      System.out.println( "Case: 1" );
      System.out.println( "Execute until break" );
      break;		  	
   case 2: 
      System.out.println( "Case: 2" );
      System.out.println( "Execute until break" );
      break;
   case 3:
      System.out.println( "Case: 3" );
      System.out.println( "Execute until break" );
      break;  	
   case 4:
      System.out.println( "Case: 4" );
      System.out.println( "Execute until break" );
      break;      
   default:
      System.out.println( "Case: default" );
      System.out.println( "Execute until break" );
      break;	      
}

上面程式碼的輸出是

Case: 3
Execute until break

相同的程式碼可以用 if-else 塊來編寫"

int var = 3;
if ( var == 1 ) {
   System.out.println( "Case: 1" );
   System.out.println( "Execute until break" );
} else if ( var == 2 ) {
   System.out.println( "Case: 2" );
   System.out.println( "Execute until break" );
} else if ( var == 3 ) {
   System.out.println( "Case: 3" );
   System.out.println( "Execute until break" );
} else if ( var == 4 ) {
   System.out.println( "Case: 4" );
   System.out.println( "Execute until break" );
} else {
   // -- This is the default part -- 
   System.out.println( "Case: default" );
   System.out.println( "Execute until break" );
}

另請參閱

Java Programming/Keywords/if

synchronized

synchronized 是一個關鍵字。

它標記一個臨界區。臨界區是指只有一個執行緒正在執行的區域。因此，要進入標記的程式碼，執行緒必須同步，一次只能進入一個執行緒，其他執行緒必須等待。有關詳細資訊，請參見同步執行緒方法或 [3]。

synchronized 關鍵字可以用兩種方式使用

建立一個 synchronized 塊
將一個方法標記為 synchronized

一個 synchronized 塊被標記為

程式碼部分 1：同步塊。

synchronized(<object_reference>) {
   // Thread.currentThread() has a lock on object_reference. All other threads trying to access it will
   // be blocked until the current thread releases the lock.
}

將方法標記為 synchronized 的語法是

程式碼部分 2：同步方法。

public synchronized void method() {
   // Thread.currentThread() has a lock on this object, i.e. a synchronized method is the same as
   // calling { synchronized(this) {…} }.
}

同步始終與物件相關聯。如果方法是靜態的，則關聯的物件是類。如果方法是非靜態的，則關聯的物件是例項。雖然允許將 abstract 方法宣告為 synchronized，但這樣做毫無意義，因為同步是實現的一個方面，而不是宣告的一個方面，而抽象方法沒有實現。

單例示例

例如，我們可以展示單例的執行緒安全版本

程式碼清單 1：Singleton.java/**
 * The singleton class that can be instantiated only once with lazy instantiation
 */
public class Singleton {
    /** Static class instance */
    private volatile static Singleton instance = null;

    /**
     * Standard private constructor
     */
    private Singleton() {
        // Some initialisation
    }
   
    /**
     * Getter of the singleton instance
     * @return The only instance
     */
    public static Singleton getInstance() {
        if (instance == null) {
            // If the instance does not exist, go in time-consuming
            // section:
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }

        return instance;
    }
 }

this

this 是一個 Java 關鍵字。它包含當前物件的引用。

解決例項變數和引數之間的歧義。
用於將當前物件作為引數傳遞給另一個方法。

語法

this.method();
or
this.variable;

情況 1 的示例 #1

public class MyClass
 { 
    //...
    private String value;
    //...
    public void setMemberVar( String value )
    {
        this.value= value;
    }
 }

情況 1 的示例 #2

public class MyClass
 { 
    MyClass(int a, int b) {
        System.out.println("int a: " + a);
        System.out.println("int b: " + b);
    }
    MyClass(int a) {
        this(a, 0);
    }
    //...
    public static void main(String[] args) {
        new MyClass(1, 2);
        new MyClass(5);
    }
 }

throw

throw 是一個關鍵字；它“丟擲”一個異常。在 throw 語句中，可以丟擲的三種類型的物件是：Exception、java:Throwable 和 java:Error

語法

throw <Exception Ref>;

例如

public Customer findCustomer( String name ) throws '''CustomerNotFoundException'''
 {
    Customer custRet = null;
 
    Iterator iter = _customerList.iterator();
    while ( iter.hasNext() )
    {
        Customer cust = (Customer) iter.next();
        if ( cust.getName().equals( name ) )
        {
           // --- Customer find --
           custRet = cust;
           break;
        }
     }
     if ( custRet == null )
     {
        // --- Customer not found ---
        throw new '''CustomerNotFoundException'''( "Customer "+ name + " was not found" );
     }
 
    return custRet
  }

另請參閱

Java 程式設計/關鍵字/throws

throws

throws 是一個 Java 關鍵字。它用在方法定義中，用來宣告方法要丟擲的異常。

語法

public myMethod() throws MyException1, MyException2
{MyException1
  ...
}

示例

class MyDefinedException extends Exception
 {
  public MyDefinedException(String str) 
  {
     super(str);
  }   
 }

 public class MyClass
 {
    public static void showMyName(String str) throws MyDefinedException
    {
          if(str.equals("What is your Name?"))
                throw new MyDefinedException("My name is Blah Blah");
    }
    public static void main(String a[])
    {
       try
       {
          showMyName("What is your Name?");
       }
       catch(MyDefinedException mde)
       {
          mde.printStackTrace();
       }
     }
 }

transient

transient 是一個 Java 關鍵字，它標記一個成員變數，使其在持久化到位元組流時不會被序列化。當物件透過網路傳輸時，需要對物件進行“序列化”。序列化將物件狀態轉換為序列化位元組。這些位元組透過網路傳送，並從這些位元組中重新建立物件。用 Java transient 關鍵字標記的成員變數不會被傳輸；它們會被有意丟失。

語法

private transient <member-variable>;
or 
transient private <member-variable>;

例如

public class Foo implements Serializable
 {
   private String saveMe;
   private transient String dontSaveMe;
   private transient String password;
   //...
 }

另請參閱

Java 語言規範參考：jls
可序列化介面。可序列化

try

try 是一個關鍵字。

它開始一個 try 塊。如果在 try 塊內部丟擲異常，則會將異常與塊中的任何 catch 部分進行比較。如果異常與 catch 部分中的一個異常匹配，則將在那裡處理異常。

try 塊中可能發生三件事

沒有丟擲異常
- try 塊中的程式碼
- 加上 finally 塊中的程式碼將被執行
- 加上 try-catch 塊後的程式碼將被執行
丟擲異常並在 catch 塊中找到匹配項
- 執行 try 塊中的程式碼，直到異常發生
- 加上匹配的 catch 塊被執行
- 加上 finally 塊被執行
- 加上 try-catch 塊後的程式碼將被執行
丟擲異常並在 catch 塊中沒有找到匹配項
- 執行 try 塊中的程式碼，直到異常發生
- 加上 finally 塊被執行
- 無程式碼 在 try-catch 塊之後被執行

例如

public void method() throws NoMatchedException
 {
   try {
     //...
     throw new '''MyException_1'''();
     //...
   } catch ( MyException_1 e ) {
     // --- '''Handle the Exception_1 here''' --
   } catch ( MyException_2 e ) {
     // --- Handle the Exception_2 here --
   } finally {
     // --- This will always be executed no matter what --
   }
   // --- Code after the try-catch block
 }

catch 塊的評估方式請參見捕獲規則

另請參閱

void

void 是一個 Java 關鍵字。

在方法宣告和定義中使用它來指定方法不返回任何型別，方法返回 void。它不是一種型別，並且在 C/C++ 中沒有 void 引用/指標。

例如

public void method()
 {
   //...
   return;   // -- In this case the return is optional
//and not necessary to use public but some changes will be there
 }

另請參閱

Java Programming/Keywords/return

volatile

volatile 是一個關鍵字。

當成員變數用此關鍵字標記時，它會以在多個執行緒訪問這些變數時可見的方式更改執行時行為。如果沒有 volatile 關鍵字，一個執行緒可能會觀察到另一個執行緒以不符合原始碼中指定的順序更新成員變數。與 synchronized 關鍵字不同，允許併發訪問 volatile 欄位。

語法

private volatile <member-variable>;
or 
volatile private <member-variable>;

例如

private volatile changingVar;

另請參閱

Java Programming/Keywords/synchronized

while

while 是一個 Java 關鍵字。

它啟動一個迴圈程式碼塊。

使用擴充套件巴科斯-諾爾正規化，while 的一般語法是

while-looping-statement ::= while condition-clause 
                                    single-statement | block-statement
 
condition-clause    ::= ( Boolean Expression )
single-statement    ::= Statement
block-statement     ::= { Statement [ Statements ] }

例如

while ( i < maxLoopIter )
 {
    System.out.println("Iter=" +i++);
 }

另請參閱

註釋

Java 程式設計
關鍵詞

編碼規範

abstract

assert

boolean

break

byte

case

catch

char

class

const

continue

另請參閱

default

do

double

else

enum

extends

final

對於變數

對於類

對於方法

興趣

finally

float

for

goto

if

implements

import

instanceof

int

interface

long

native

另請參閱

new

package

private

protected

public

return

short

static

興趣

strictfp

super

switch

synchronized

單例 示例

this

throw

另請參閱

throws

transient

try

void

volatile

while

單例示例