java关键字小结二（转）

31.private Java 关键字
private 关键字是访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）。

示例
   public class MyPublicClass
   {
      private class MyPrivateClass
      {
      }

      private int i;

      private String myMethod()
      {
        <statements>
      }
   }

注释
只能在声明 private（内部）类、方法或字段的类中引用这些类、方法或字段。在类的外部或者对于子类而言，它们是不可见的。

所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

 

 

 

32.protected Java 关键字
protected 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。

示例
   public class MyPublicClass
   {
      protected class MyPrivateClass
      {
      }

      protected int i;

      protected String myMethod()
      {
        <statements>
      }
   }

注释
可以在声明 protected 类、方法或字段的类、同一个包中的其他任何类以及任何子类（无论子类是在哪个包中声明的）中引用这些类、方法或字段。

所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

 

 

 

 

33.public Java 关键字
public 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。

示例
   public class MyPublicClass
   {
      public class MyPrivateClass
      {
      }

      public int i;

      public String myMethod()
      {
        <statements>
      }
   }

注释
可能只会在其他任何类或包中引用 public 类、方法或字段。

所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

 

 

 

34.return Java 关键字
return 关键字会导致方法返回到调用它的方法，从而传递与返回方法的返回类型匹配的值。

示例
   public void myVoidMethod()
   {
      <statements>
      return;
   }

   public String myStringMethod()
   {
      String s = "my response";
      return s;
   }

   public int myIntMethod()
   {
      int i = 5;
      return(i);
   }

注释
如果方法具有非 void 的返回类型，return 语句必须具有相同或兼容类型的参数。

返回值两侧的括号是可选的。

 

 

 

35.short Java 关键字
short 是 Java 原始类型。

short 变量可以存储 16 位带符号的整数。

示例
   short number = 5;
   short octalNumber = 0077;
   short hexNumber = 0xff;

注释
Short 类是 short 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和 MAX_VALUE 常量。

Java 中的所有整数值都是 32 位的 int 值，除非值后面有 l 或 L（如 235L），这表示该值应解释为 long。

 

 

 

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

 

 

 

 

37.super Java 关键字
super 关键字用于引用使用该关键字的类的超类。

示例
   public class MyClass
   {
      public MyClass(String arg)
      {
         super(arg);
      }

      public String myStringMethod()
      {
         return super.otherStringMethod();
      }

注释
作为独立语句出现的 super 表示调用超类的构造方法。

super.<methodName>() 表示调用超类的方法。只有在如下情况中才需要采用这种用法：要调用在该类中被重写的方法，以便指定应当调用在超类中的该方法。

 

 

 

 

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

 

 

 

 

 

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

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

 

 

 

 

40.this Java 关键字
this 关键字用于引用当前实例。

示例
   public class MyClass
   {
      int number;

      public MyClass(int number)
      {
         this.number = number;
      }
   }

注释
当引用可能不明确时，可以使用 this 关键字来引用当前的实例。

在上面的示例中，构造方法参数 number 与类的成员变量同名。this.number 明确表示 MyClass 的该实例的 number 成员变量。

 

 

 

 

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

 

 

 

 

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

 

 

 

 

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

示例
   public class MyClass
   {
      private transient String password;
   }

 

 

 

 

44.try Java 关键字
try 关键字用于包含可能引发异常的语句块。

示例
   try
   {
      <可能引发异常的块>
   }
   catch (<java.lang.Exception 或子类> e)
   {
      <处理异常 e 的代码>
   }

   try
   {
      <可能引发其他异常的块>
   }
   catch (FooException e)
   {
      <处理 FooException e 的代码>
   }
   catch (BarException e)
   {
      <处理 BarException e 的代码>
   }

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

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

如果某个特定异常类未被任何 catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息。

 

 

 

 

45.true Java 关键字
true 关键字表示 boolean 变量的两个合法值中的一个。

示例
   boolean isComplete = true;

 

 

 

 

46.void Java 关键字
void 关键字表示 null 类型。

示例
   public class MyClass
   {
      public void doSomething();
      {
         <statements>
         return;
      }
   }

注释
void 可以用作方法的返回类型，以指示该方法不返回值。

 

 

 

 

47.volatile Java 关键字
volatile 关键字用于表示可以被多个线程异步修改的成员变量。

注意：volatile 关键字在许多 Java 虚拟机中都没有实现。

示例
   public class MyClass
   {
      volatile int sharedValue;
   }

注释
volatile 的目标用途是为了确保所有线程所看到的指定变量的值都是相同的。

 

 

 

 

 

48.while Java 关键字
while 关键字用于指定一个只要条件为真就会重复的循环。

示例
   while (!found)
   {
      <statements>
   }