JAVA的关键字小结

abstract Java 关键字 

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 类不能有子类。 



extends Java 关键字 

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

示例 

public class Rectangle extends Polygon
  {
  }

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

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

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

final Java 关键字 

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

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

示例 

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

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

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

finally Java 关键字 

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。 


implements Java 关键字 

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

示例 

public class Truck implements IVehicle
  {
  }

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

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

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

instanceof Java 关键字 

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

示例 

if (node instanceof TreeNode)
  {
     <statements>
  }

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

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

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

示例 

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

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

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

static Java 关键字 

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 常量。 

switch Java 关键字 


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 块。 



synchronized Java 关键字 

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），那么，当该方法一次由一个线程访问时，该实例将被锁定。 

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


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 修饰符来声明它引发的异常。 



throws Java 关键字 

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 子句的方法的调用，必须提供该方法的调用者。 

transient Java 关键字 

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

示例 

public class MyClass
  {
     private transient String password;
  }

native 
native是方法修饰符。Native方法是由另外一种语言（如c/c++，FORTRAN，汇编）实现的本地方法。因为在外部实现了方法，所以在java代码中，就不需要声明了，有点类似于借口方法。Native可以和其他一些修饰符连用，但是abstract方法和Interface方法不能用native来修饰。 
Example： 

public interface TestInterface {
     void doMethod();
}
public class Test implements TestInterface {
    public native void doMethod();
    private native int doMethodB();
　　public native synchronized String doMethodC();
　　static native void doMethodD();
}

 

 

为什么需要使用native method？请参考： 
http://www.javaeye.com/topic/72543  java Native Method初涉

strictfp

 

自Java2以来，Java语言增加了一个关键字strictfp，虽然这个关键字在大多数场合比较少用，但是还是有必要了解一下。

strictfp的意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。

你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码：

1. 合法的使用关键字strictfp

strictfp interface A {}

public strictfp class FpDemo1 {
    strictfp void f() {}
}

2. 错误的使用方法

interface A {
    strictfp void f();
}

public class FpDemo2 {
    strictfp FpDemo2() {}
}

一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合IEEE-754规范的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。

修饰类和方法，意思是FP-strict，精确浮点，符合IEEE-754规范的。当一个class或interface用strictfp声明，内部所有的float和double表达式都会成为strictfp的。Interface method不能被声明为strictfp的，class的可以。 
Example： 

strictfp interface FPTest {
     void methodA();
}
class FPClass implements FPTest {
    public void methodA() {
    }
    public void methodB() {
　　}
　　public strictfp void methodC() {
　　}
}
class FPClassB {
    strictfp void methodA() {
    }
}

volatile 
volatile修饰变量。在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 
看看Java Language Specification中的例子。 
条件：一个线程不停的调用方法one()，一个线程不停的调用方法two()。我测试过多次，这种情况好像一直没有出现。 

class Test {
    static int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}

 

结果偶尔会出现j大于i的情况，因为方法没有同步，所以会出现i和j可能不是一次更新。一种防止这种情况发生的办法就是声明两个方法为synchronized 的。

class Test {
    static int i = 0, j = 0;
    static synchronized void one() { i++; j++; }
    static synchronized void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}

 

这样可以防止两个方法同时被执行，还可以保证j和i被同时更新，这样一来i和j的值一直是一样的。 
另外一种途径就是把i和j声明为volatile。

 

class Test {
    static volatile int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}