`

JAVA的关键字小结

    博客分类:
  • 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: 

  1. public interface TestInterface {  
  2.      void doMethod();  
  3. }  
  4. public class Test implements TestInterface {  
  5.     public native void doMethod();  
  6.     private native int doMethodB();  
  7.   public native synchronized String doMethodC();  
  8.   static native void doMethodD();  
  9. }  

 

 

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

strictfp

 

  1. 自Java2以来,Java语言增加了一个关键字strictfp,虽然这个关键字在大多数场合比较少用,但是还是有必要了解一下。  
  2.   
  3. strictfp的意思是FP-strict,也就是说精确浮点的意思。在Java虚拟机进行浮点运算时,如果没有指定strictfp关键字时,Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作,以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时,那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确,而且不会因为不同的硬件平台所执行的结果不一致的话,那就请用关键字strictfp。  
  4.   
  5. 你可以将一个类、接口以及方法声明为strictfp,但是不允许对接口中的方法以及构造函数声明strictfp关键字,例如下面的代码:  
  6.   
  7. 1. 合法的使用关键字strictfp  
  8.   
  9. strictfp interface A {}  
  10.   
  11. public strictfp class FpDemo1 {  
  12.     strictfp void f() {}  
  13. }  
  14.   
  15. 2. 错误的使用方法  
  16.   
  17. interface A {  
  18.     strictfp void f();  
  19. }  
  20.   
  21. public class FpDemo2 {  
  22.     strictfp FpDemo2() {}  
  23. }  
  24.   
  25. 一旦使用了关键字strictfp来声明某个类、接口或者方法时,那么在这个关键字所声明的范围内所有浮点运算都是精确的,符合IEEE-754规范的。例如一个类被声明为strictfp,那么该类中所有的方法都是strictfp的。  

修饰类和方法,意思是FP-strict,精确浮点,符合IEEE-754规范的。当一个class或interface用strictfp声明,内部所有的float和double表达式都会成为strictfp的。Interface method不能被声明为strictfp的,class的可以。 
Example: 
  1. strictfp interface FPTest {  
  2.      void methodA();  
  3. }  
  4. class FPClass implements FPTest {  
  5.     public void methodA() {  
  6.     }  
  7.     public void methodB() {  
  8.   }  
  9.   public strictfp void methodC() {  
  10.   }  
  11. }  
  12. class FPClassB {  
  13.     strictfp void methodA() {  
  14.     }  
  15. }  

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

  1. class Test {  
  2.     static int i = 0, j = 0;  
  3.     static void one() { i++; j++; }  
  4.     static void two() {  
  5.         System.out.println("i=" + i + " j=" + j);  
  6.     }  
  7. }  

 

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

  1. class Test {  
  2.     static int i = 0, j = 0;  
  3.     static synchronized void one() { i++; j++; }  
  4.     static synchronized void two() {  
  5.         System.out.println("i=" + i + " j=" + j);  
  6.     }  
  7. }  

 

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

 

  1. class Test {  
  2.     static volatile int i = 0, j = 0;  
  3.     static void one() { i++; j++; }  
  4.     static void two() {  
  5.         System.out.println("i=" + i + " j=" + j);  
  6.     }  
  7. }

 

分享到:
评论

相关推荐

    Java中this关键字使用小结

    在 Java 编程语言中,`this` 关键字是一个非常重要的概念,它用来引用当前对象的实例。本文将深入探讨 `this` 关键字的三种主要用途,并通过实例代码来解析其工作原理。 首先,`this` 关键字的基本含义是引用当前...

    Java的关键字与标识符小结

    "Java关键字与标识符小结" Java语言中,关键字和标识符是两个重要的概念。关键字是被Java语言赋予了特殊含义的单词,总共有50个。它们被用来定义数据类型、流程控制、访问权限修饰符、类、函数、变量修饰符、类之间...

    Java语言基础小结

    ### Java语言基础小结 #### 一、JDK, JRE, JVM的关系 - **JVM(Java Virtual Machine)**:Java虚拟机是Java程序跨平台运行的核心,它负责执行Java字节码(.class文件),确保Java程序可以在不同的平台上运行而...

    java小结

    #### 小结 通过以上内容,我们对Java的基础知识有了更深入的理解。了解这些基础知识对于编程非常重要,特别是对于初学者来说。掌握了这些概念后,你可以更好地理解和编写Java代码,同时也能避免一些常见的错误和...

    java异常小结

    在Java编程语言中,异常处理是一个关键的概念,它确保了程序在遇到错误时能够优雅地终止,而不是崩溃。本文主要总结了Java异常处理机制及其相关知识点。 首先,异常机制是Java中用于处理程序运行时错误的框架。当...

    java课程小结.rar_北京理工大学JAVA课程

    这个“java课程小结.rar_北京理工大学JAVA课程”压缩包中包含的“课程小结”文件,很可能是教授精心编写的教学精华,旨在帮助学生巩固所学知识并为后续学习打下坚实基础。 在Java课程中,有几个核心概念和技术是必...

    java异常机制小结

    Java 异常机制小结 Java 异常机制是 Java 语言中一个非常重要的方面,也是程序设计的一大难点。Java 语言在设计的当初就考虑到异常处理的框架的方案,使得所有的异常都可以用一个类型来表示,不同类型的异常对应...

    java基础小结

    《Java基础小结》 Java,作为一种广泛应用的编程语言,以其跨平台、面向对象的特点深受开发者喜爱。这篇博文和随附的PDF笔记旨在总结Java的基础知识,帮助初学者巩固理解,同时也为有经验的开发者提供回顾参考。 1...

    Java的关键字与保留字小结

    Java是一种强类型、面向对象的编程语言,它的语法中包含了关键字和保留字,这些词汇具有特殊的含义,用于构建程序的基本结构。本篇文章将详细解析Java的关键字和保留字。 首先,关键字是Java语言中预定义的,有特殊...

    java试题小结可以下载的

    【Java试题小结】 1. **Applet生命周期与方法**: - 在Java中,Applet的生命周期包括初始化、启动、绘画、停止和销毁几个阶段。`init()`方法用于初始化Applet所需资源,`paint()`方法负责在屏幕上绘制图形,如线条...

    C#与java相似点和差异小结.doc

    以下是关于这两种语言相似点和差异的小结: 1. **源文件约定**: - **C#** 允许一个源文件(.cs)中包含多个顶级公共类,文件名不必与类名相同。 - **Java** 则要求每个源文件(.java)只能有一个顶级类,且文件名...

    Java零基础-this关键字.md

    #### 小结 通过本文的学习,读者应该能够掌握`this`关键字在Java中的基本用法及其应用场景。在实际开发中灵活运用`this`关键字,不仅有助于提高代码的可读性和维护性,还能够避免因变量命名冲突带来的问题。希望...

    Java排序小结:常用的排序方法

    本篇文章将详细解析Java中常见的排序方法,结合"javaeye 收集的java排序小结"资料,旨在帮助读者理解和掌握这些排序算法。 1. 冒泡排序(Bubble Sort) 冒泡排序是最简单的排序算法之一,通过重复遍历数组,比较...

    JAVA Static关键字的用法

    小结 JAVA Static关键字的用法非常广泛,它可以用来修饰成员变量和方法。静态变量和静态方法都是整个类共享的,可以在不创建类对象的情况下访问和修改它们。了解Static关键字的用法可以帮助我们更好地理解和学习...

    Java类与对象小结

    这篇小结将深入探讨这两个关键概念,以及它们在实际编程中的应用。 首先,类是Java中的蓝图,它定义了一组特性和行为,这些特性和行为共同构成一个特定实体。类可以包含字段(或称为属性),它们代表对象的状态,...

    Java多线程小结

    ### Java多线程小结 #### 一、多线程的概念与意义 多线程是Java编程中的一个重要概念,指的是程序在运行时可以同时执行多个线程的能力。它能够提高程序的性能,尤其是在多核处理器的环境下。多线程使得程序能够更...

    Java中类的继承学习小结

    下面是对"Java中类的继承学习小结"的详细讲解。 首先,类的继承使用关键字`extends`来实现。子类(也称为派生类)声明时,会指定一个父类(或超类): ```java public class DerivedClass extends BaseClass { //...

    关于static的小结(Java内存溢出)

    在《关于static的小结(Java内存溢出)》这篇文章中,作者主要探讨了与Java中的`static`关键字相关的知识点,以及如何可能导致内存溢出的情况。下面我们将深入分析这些内容。 #### Java中的`static`关键字 `static...

Global site tag (gtag.js) - Google Analytics