关键词

导航语言基础主题： ( 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

单例示例