java关键字总结用法

java中约有五十个关键字，我认为关键字是人机交流最重要的媒介语句，可以帮助机器识别人的命令，因此运用好关键字意味着可以更方便简洁地书写代码，可以避免很多冗长的代码。印象比较深的是在做五子棋游戏中，由于同一个数组在多个不同类中要多次使用，当时没有想到用“static”关键字来定义数组，结果在不同类中创建了很多个相同的数组，每个类中还要定义很多重复的方法，动一发而牵百身，十分不方便。
    不同的关键字必然对应着不同方面的规则，因此是有必要对关键字进行分类记忆的。
    有个很容易记忆的规则是，所有的关键字都是“小写字母”。
    当然，这么分显然还不够，那么下面就以我个人的记忆链来再次分类吧。
   
 **0.java是完全面向对象的，因此“类”的概念是非常重要的，关于“类”最基础的关键字有两个：
——class：声明类
——interface：声明接口

 **0.首先每个类，都是在一定的包内，那么对于“包”的声明和引用，有两个关键字：
——import：1.导入包或类，使导入的包或类的源代码在当前你写的类可见；                
              e.g.    import javax.swing.*；
                   //如果不导入包，则用到类时，要写类的全称限定；
                    2.如果要继承内部类，除非都是同一类中的内部类，否则必须要用import导入该内部类，即使子类写在同一页java文件中；
——package：指定书写的类所驻留的java包
               e.g.   package com.mycompany;
                      public class MyClass{ }
                     //MyClass类是在mycompangy包下的
   
**0.其次书写每个类的时候，类前都有“修饰限定符”，来表示该类的访问级别，有八个关键字是关于修饰限定符的：
——public：1.用于修饰类、方法、变量，所有类和包都可以访问,即“公开的”；
                  2.一个类内，只能含有一个public的类；
                  3.接口、抽象类里面默认的方法都是public的；
                  4.子类继承父类的方法，如果是public类型的，则重写不得小于public；
              e.g.  public class A{
                        public void function(){
                            public int a;
       }
   }
       
——protected：1.用于修饰类（但不能是顶级类）、方法、变量，在同一个包下可以访问，即“受保护的”；
                        2.系统里默认类的修饰符是protected；
——private：1.用于修饰类（只能是内部类）、方法、变量，只能在本类里访问，不能在任何的外部类甚至是子类中访问，即“私有的”；
——static：1.用于修饰类（只能是内部类）、方法、变量；
                 2.如果是用static定义了的方法，则可以直接用“类名.方法名”的方式直接调用该方法，而不必实例化类的对象；static方法中只能调用static属性；
                 3.如果是用static定义了的属性，则可以直接调用属性，不必实例化类的对象；
                 4.类的某一个对象的static属性值被改变后，这个类所有的static属性都会改变；
                 5.static代码块，这是独立存在的，java按顺序向下读取，且只读取一次：
                    e.g.    Test3（图）
              
              e.g.

——final：1.用于修饰非抽象类、非抽象类成员方法和变量；
               2.意为“最终的，固定不变的”，所以final类没有子类（终极类）；final方法可以被继承，但是不能被重写（固定不变的）；final修饰的变量（可以是对象变量）就是常量（固定不变的）；
               3.“final空白”的情况：就是用final声明一个final变量，但是先不赋值：
                         a.在类的构造函数里给其写赋值的方法，那么类的每个对象都可以有不同值的final变量，但是还是具有final属性，即只能赋值一次。
                         b.在普通方法中先声明一个final变量，之后再赋值；
             e.g.（图）
            
——abstract：用于修饰类、方法；            
         abstract类是抽象类，可以拓展子类；
                      abstract方法用于抽象类与接口，在本类中不能实现方法体，是在某个子类中重写方法体实现，因此abstract类不能直接实例化对象；
                      由于abstract类必须要子类来继承实现，所以不能应用于private、static、final方法，因为这些方法不能在子类中重写；同时在final类中也不能有abstract方法，因为final类没有子类；
                  
——native：应用于方法，以指示该方法是用 Java 以外的语言实现的。
——volatile：表明两个或多个变量必须同步地发生变化，在“线程”概念中用到；
——synchronized：表明一段代码需要同步执行，在“线程”概念中用到；

修饰符的访问范围如下：    
|        修饰符             |  类  |成员访求|构造方法|成员变量|局部变量|
|   abstract 抽象的    |  √  |   √      |   －       |   －     |   －      |
|    static 静态的        |  －  |   √      |   －      |   √      |   －      |
|    public 公共的        |  √  |   √      |   √       |   √      |   －     |
| protected 受保护的 |       |   √      |   √      |   √       |   －     |
|   private 私有的       |  －  |   √      |   √      |   √       |   －     |
|synchronized 同步的|  －  |   √      |   －      |   －      |   －     |
|    native 本地的       |  －  |   √      |   －      |   －      |   －     |
|  transient 暂时的    |  －   |   －     |   －      |   √       |   －     |
|   volatile 易失的      |  －   |   －     |   －      |   √       |   －     |
|  final 不要改变的      |  √   |   √      |   －      |   √       |   √     |

 
**0.而每个子类可以继承一个父类或者实现多个接口，关于“继承与实现”，有2个关键字：
——extends：1.用于子类继承父类或者接口，或者接口继承接口；
                      2.注意子类只能有一个父类（就像一个孩子只有能有一个生父），但可以有多个接口
——implements：1.用于接口在类中的实现；
                           2.注意，接口中所有的方法都要进行重写；
   
**0.接着每个类里面可以定义许多属性，而属性可以是“基本类型”或者“引用类型”，对应前者，有9个关键字：
      byte：       8位
      char：       16位   字符型
      short:        16位   短整型
      int:             32位  整形
      float:          32位  单精度浮点型
      long:          64位  长整型
      double:      64位  双精度浮点型
      blooean:    true 和 false  布尔型
      enum：枚举型
  
    引用类型又称类类型，由接口，抽象类，数组等组成，而类一般都是大写字母开头，所以可以排除在关键字外，这个只是记忆的一种方法，其中细究的原因我还没研究，因此暂不展开了。
   
**0.而对应不同的数据类型的访问值，又有三个关键字：
      false：布尔型的一个值
      true：布尔型的一个值
      null：除了基本数据类型的其他类型的初始值
   
**0.然后开始写方法体，那么方法可以分为有返回值和无返回值类型，这里对应的有两个关键字：
      void：表示返回值为空，写在方法名之前
          e.g.    public void B(){ }
      return：表示有返回值，写在方法体内
          e.g.    public  int  A(){
                        int k;
                        return  k;}
 
**0.方法体内如果有“引用”父类或者自己的类，则又有两个关键字：
      this：1.可以区别形参还是属性：this.属性名  代表“我的属性”；不带this的是形参；
               2.代表当前对象；
      super：当父类的方法被重写后可以用"super.父类的方法"来调用父类的方法；

**0.在方法体中我们常常会用循环、判断等流程控制，对应此，又有10个关键字：
      if：                    条件语句的引导词
      else：                用在条件语句中，表明当条件不成立时的分支
      for：                 一种循环语句的引导词
      do：                 用在do-while循环结构中
      while：              用于指定一个“只要条件为真就会重复”的循环。
      switch：           分支结构语句的引导词
      case：              用在switch语句中，表明其中的一个分支
      default：          默认，例如，用在switch语句中，表明一个默认的分支
      break：           用于提前退出 for、while 或 do 循环，或者在 switch 语句中用来结束 case 块；
      continue：      用来跳转到 for、while 或 do 循环的下一个迭代，而不是跳出循环；

**0.当我们创建了一个类以后就可以实例化一个对象，这里就会关系到一个关键字：
      new：开辟一块新的内存空间来存储要创建的新对象；

**0.而以后看到一个对象却不知道其属于哪个类，那么确定对象就有一个关键字：
      instanceof：用来确定对象所属的类
            e.g.     if (node instanceof TreeNode){ }
                      //  判断node是否是TreeNode类的

**0.还有，我们书写代码的时候一定会有可能引发异常的语句，对于“异常处理”，java中又有5个关键字：
      try：尝试
      catch：捕获
      finally：最终地
      throw：抛出
      throws：抛出 

此外，Java还有两个保留字:
const常量
goto转到        
（这些只是保留字，最好不用）