理解几个重要的Java 关键字

[b]abstract Java 关键字[/b]

abstract 关键字可以修改类或方法。

abstract 类可以扩展（增加子类），但不能直接实例化。

abstract 方法不在声明它的类中实现，但必须在某个子类中重写。

示例

 public abstract class MyClass
  {
  }
    public abstract String myMethod();

注释
采用 abstract 方法的类本来就是抽象类，并且必须声明为 abstract。

abstract 类不能实例化。

仅当 abstract 类的子类实现其超类的所有 abstract 方法时，才能实例化 abstract 类的子类。这种类称为具体类，以区别于 abstract 类。

如果 abstract 类的子类没有实现其超类的所有 abstract 方法，该子类也是 abstract 类。

abstract 关键字不能应用于 static、private 或 final 方法，因为这些方法不能被重写，因此，不能在子类中实现。

final 类的方法都不能是 abstract，因为 final 类不能有子类。



[b]extends Java 关键字[/b]

extends 关键字用在 class 或 interface 声明中，用于指示所声明的类或接口是其名称后跟有 extends 关键字的类或接口的子类。

示例

  public class Rectangle extends Polygon
  {
  }

注释
在上例中，Rectangle 类继承 Polygon 类的所有 public 和 protected 变量和方法。

Rectangle 类可以重写 Polygon 类的任何非 final 方法。

一个类只能扩展一个其他类。


[b]final Java 关键字[/b]

final 关键字可以应用于类，以指示不能扩展该类（不能有子类）。

final 关键字可以应用于方法，以指示不能重写任何子类中的方法。

示例

  public final class MyFinalClass
  {
  }
    public class MyClass
  {
     public final String myFinalMethod()
	 {
	    <statements>
	 }
  }

注释
一个类不能同时是 abstract 又是 final。abstract 意味着必须扩展类，final 意味着不能扩展类。

一个方法不能同时是 abstract 又是 final。abstract 意味着必须重写方法，final 意味着不能重写方法。





[b]finally Java 关键字[/b]

finally 关键字用来定义始终在 try-catch-finally 语句中执行的块。

finally 块通常包含清理代码，用在部分执行 try 块后恢复正常运行。

示例

try
  {
     <可能引发异常的块>
  }
  catch (<java.lang.Exception 或子类> e)
  {
     <处理异常 e 的代码>
  }
  finally
  {
     <有异常或无异常情况下都执行的语句>
  }

注释
开始和结束标记 { 和 } 是 finally 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。

每个 try 块都必须至少有一个 catch 或 finally 子句。

如果执行 try 块的任何部分，不论是否出现异常，也不论 try 或 catch 块是否包含 return、continue 或 break 语句，都一定会执行 finally 块中的代码。

如果不出现异常，控件将跳过 try 块，进入 finally 块。

如果在执行 try 块期间出现异常，并且相应的 catch 块包含 break、continue 或 return 语句，控件将首先穿过 finally 块，之后再执行 break、continue 或 return。


[b]implements Java 关键字[/b]

implements 关键字在 class 声明中使用，以指示所声明的类提供了在 implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。

示例

 public class Truck implements IVehicle
  {
  }

注释
在上例中，Truck 类必须提供在 IVehicle 接口中所声明的所有方法的实现。

否则，Truck 类将是独立的；它可以声明其他方法和变量，并扩展另一个类。

一个类可以实现多个接口。



[b]
instanceof Java 关键字[/b]

instanceof 关键字用来确定对象所属的类。

示例

  if (node instanceof TreeNode)
  {
     <statements>
  }

注释
在上例中，如果 node 是 TreeNode 类的实例，或者是 TreeNode 的子类的实例，则 instanceof 表达式的值将为 true。



[b]interface Java 关键字[/b]

interface 关键字用来声明新的 Java 接口，接口是方法的集合。

接口是 Java 语言的一项强大功能。任何类都可声明它实现一个或多个接口，这意味着它实现了在这些接口中所定义的所有方法。

示例

public interface IPolygon
  {
     public float getArea();
     public int getNumberOfSides();
     public int getCircumference();
  }

注释
实现了接口的任何类都必须提供在该接口中的所有方法的实现。

一个类可以实现多个接口。





[b]static Java 关键字[/b]

static 关键字可以应用于内部类（在另一个类中定义的类）、方法或字段（类的成员变量）。

示例

public class MyPublicClass
  {
     public final static int MAX_OBJECTS = 100;
     static int _numObjects = 0;

     static class MyStaticClass
     {
     }

     static int getNumObjects()
     {
     }
  } 

注释
通常，static 关键字意味着应用它的实体在声明该实体的类的任何特定实例外部可用。

static（内部）类可以被其他类实例化和引用（即使它是顶级类）。在上面的示例中，另一个类中的代码可以实例化 MyStaticClass 类，方法是用包含它的类名来限定其名称，如 MyClass.MyStaticClass。

static 字段（类的成员变量）在类的所有实例中只存在一次。

可以从类的外部调用 static 方法，而不用首先实例化该类。这样的引用始终包括类名作为方法调用的限定符。在上面的示例中，MyClass 类外部的代码以 MyClass.getNumObjects() 的形式调用 getNumObjects() static 方法。

模式：

public final static <type> varName = <value>;

通常用于声明可以在类的外部使用的类常量。在引用这样的类常量时需要用类名加以限定。在上面的示例中，另一个类可以用 MyClass.MAX_OBJECTS 形式来引用 MAX_OBJECTS 常量。





[b]switch Java 关键字[/b]


switch 语句用于基于某个表达式选择执行多个代码块中的某一个。

示例

int arg = <some value>;
  switch (arg)
  {
     case 1:
        <statements>
        break;
     case 2:
        <statements>
        break;
     default:
        <statements>
        break;
  }
    char arg = <some value>;
  switch (arg)
  {
     case 'y':
     case 'Y':
        <statements>
        break;
     case 'n':
     case 'N':
        <statements>
        break;
     default:
        <statements>
        break;
  }

注释
switch 条件的计算结果必须等于 byte、char、short 或 int。

case 块没有隐式结束点。break 语句通常在每个 case 块末尾使用，用于退出 switch 语句。

如果没有 break 语句，执行流将进入所有后面的 case 和/或 default 块。



[b]synchronized Java 关键字[/b]

synchronized 关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。

示例

public class MyClass
  {
     public synchronized static String mySyncStaticMethod()
     {
     }

     public synchronized String mySyncMethod()
     {
     }
  {
    public class MyOtherClass
  {
     Object someObj;

     public String myMethod()
     {
        <statements>
        synchronized (someObj)
        {
           <statements affecting someObj>
        }
     }
  }

注释
synchronized 关键字可防止代码的关键代码段一次被多个线程执行。

如果应用于静态方法（如上例中的 MySyncStaticMethod），那么，当该方法一次由一个线程执行时，整个类将被锁定。

如果应用于实例方法（如上例中的 MySyncMethod），那么，当该方法一次由一个线程访问时，该实例将被锁定。

如果应用于对象或数组，当关联的代码块一次由一个线程执行时，对象或数组将被锁定。





[b]throw Java 关键字[/b]


throw 关键字用于引发异常。

示例

import java.io.IOException;

  public class MyClass
  {
     public method readFile(String filename) throws IOException
     {
        <statements>
        if (error)
        {
           throw new IOException("error reading file");
        }
     }
  }

注释
throw 语句将 java.lang.Throwable 作为参数。Throwable 在调用栈中向上传播，直到被适当的 catch 块捕获。

引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。


[b]throws Java 关键字[/b]

throws 关键字可以应用于方法，以便指出方法引发了特定类型的异常。

示例

import java.io.IOException;

  public class MyClass
  {
     public method readFile(String filename) throws IOException
     {
        <statements>
        if (error)
        {
           throw new IOException("error reading file");
        }
     }
  }

注释
throws 关键字将逗号分隔的 java.lang.Throwables 列表作为参数。

引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。

要在 try-catch 块中包含带 throws 子句的方法的调用，必须提供该方法的调用者。





[b]transient Java 关键字[/b]

transient 关键字可以应用于类的成员变量，以便指出该成员变量不应在包含它的类实例已序列化时被序列化。

示例

  public class MyClass
  {
     private transient String password;
  }