Java关键字

[/size]java中的关键字有总共有51个，再加上2个保留字
goto
const

1.访问修饰符

private：  可见性范围最小的限定符，添加了private的方法或者属性都只能在类内部调用，不能被子类继承，一般属性都会用private来修饰
           private String name;   
            若在Student类中定义一个public String name，则可以通过实例 化对象直接调用属性
           Student stu = new Student();  stu.name = "……";
          
protected：介于private和public之间，一般被protected限定的方法子类可以继承，同一个包下可以访问，不同包则不可以，类中方法默认为protected
           
public ：  公开性最高的关键字，放在类前表示这个类可以被其他包中的类对象所访问，public限定的类在一个文件中只能有一个，且类名必须与文件名相同，interface和abstract class中方法默认为public的
           public class 类名;    public static void 方法名(参数列表){}

2.包

package:   包，用来定义类存放位置的关键字，通常一些实现了同一个功能的类。不同的包下可以有相同名字的文件。package可以由多级组成，在文件系统中，每一级表示一个文件夹，多级之间由.隔开，同时，还可以使用
            全额定名使用外包中的类：cn.netjava.lesson4.Student stu =
           new cn.netjava.lesson4.Student();

import：   在未使用import导入某个包前，定义对象需要加上包名，书写过于复杂，在导入包后，即可直接定义
           javax.swing.JFrame jf = new javax.swing.JFrame();
            或者 import javax.swing.*  然后直接写JFrame jf = new JFrame();

static:    用来修饰方法时可以使方法成为静态的，此时可以通过类名.静态方法名()直接进行调用，而非静态方法 的调用则必须要创建对象，再通过对象来调用
           public class Student{
             public static void main(String [] args){
               Student.study();
               Student stu = new Student();
               stu.study("java");
             }
             public static void study(){
               System.out.println("I am studying !");
             }
             public void study(String book){
               System.out.println("I am studying through looking "+book);
             }
           }
           static类型的变量相当于一个全局变量，一旦某一个地方出现的值发生了改变，变量即可改变
           private static int count = 0;
           Student.count = 10;
           for(int i=0;i<5;i++){
             count = i;
           }
           System.out.println("the static count is "+count);//结果会为4
            内部类可以用static修饰，外部类不可以
           public class Test{
           public static class Score{
             }
           }

final:     final关键字可以用来定义常量，格式为：public static final 数据类型 常量名 = 值;
            常量名必须要大写，不能改变常量值，否则系统会报错
           final放在方法前，子类在继承时就不可重写父类的此方法，这常用来保护父类中不能被子类重写，又要标识为public让外部调用的方法

super:     super指的是当前类的父类对象，可以通过此关键字来调用父类中的方法
           public class Student{
             public Student(){
               this("默认名字");
             }
           }
           public class UNStudent extends Student{
           public UNStudent(){
             super("未知大学生");
             }
           }

3.基本数据类型

byte：     字节型 8bit

char：     字符型 16bit

short：    短整型 16bit

int：      整型   32bit

long：     长整型 64bit

float：    单精度 32bit

double：   双精度 64bit

boolean：  布尔型 true或者false

void：     空，一般用来修饰返回值,指代某一方法无返回值  public void setName(name){}

null：     空，常用来为对象赋初值，指示其为空，即还未分配内存空间  private int [][] array = null;

4.定义类和定义接口，实现以及继承

class：    用来修饰类  public class Test{}

interface:用来修饰接口  public interface List{}

implements:实现接口的关键字  public class STList implements List,……{}//可以同时实现多个接口

extends：  实现继承的关键字  public class ArrayList extends STList{}//每次只能继承一个类

abstract： 用来修饰抽象类  public abstract class QueueList{}

5.流程控制

if：       选择判断语句，if内的条件如果成立，就执行括号内的语句
          int sum =0;
          for(int i =0;i<=100;i++){
            if(i<=10){
              sum += i
            }else{
              System.out.println(i);
            }
          }else
             break;

else：     同上例，与if搭配使用，表示如果括号内的条件不成立，则执行以下语句

for：      同上例，for循环有三个条件，表示初始值，循环终止条件以及递变方法，若执行至超出终止条件，用 break退出

while：   表示当满足某一条件时执行循环体内代码，先判断，再执行
          while(i<=10){
             i = i+1;
          }

do：      常与while搭配使用，先执行一遍程序，再进行判断

continue：在循环体内部使用，表示若此时条件不满足，则跳出此段操作，执行接下来的代码

break：   与循环搭配使用，表示若循环条件不满足或者操作已执行后，跳出此段循环，循环内的其他代码也不予执行

switch： 选择语句，内包括多个执行选择
         System.out.println("Please choose a,b or c:");
         ch = (char)System.in.read();
         switch(ch){
         case'a':System.out.println("you choose a");break;
         case'b':System.out.println("you choose b");break;
         case'c':System.out.println("you choose c");break;
         default:System.out.println("your input is illegal");
         }

case：   同上例，switch语句中的选择条件，如果等于a则执行什么语句……

default：同上例，如果读取的输入不满足任何一个case，则执行default

6.异常

try:    程序在运行时会尝试运行try块中所写的内容

catch:  如果在try块中的代码运行出现异常，如文件找不到等，会抛出异常，由catch捕获进行处理
        try{
    //如果文件不存在，则创建一个新的newFile文件
    boolean state = f.createNewFile();
    if(state)
     System.out.println("文件创建成功！");
    else
     System.out.println("文件创建失败！");
   }catch(java.io.IOException e){
   
   }

finally:不论代码运行成功还是抛出异常，finally中的部分都要执行

throws: 用于在某个方法或者主函数外部抛出异常，在此方法的调用处用try、catch处理，或者继续抛出异常
         如下：FileNotFoundException被抛出，而IOException在内部被解决
        public void  copyFile(String srcPath,String desPath) throws FileNotFoundException{
  System.out.println("I am copying");
  long start = System.currentTimeMillis();
  try {
   InputStream is = new FileInputStream(srcPath);
   OutputStream os = new FileOutputStream(desPath);
   int i = 0;
   while((i = is.read())!= -1){
    os.write(i);
   }
   System.out.println("文件拷贝成功！");
   long end = System.currentTimeMillis();
   System.out.println(end-start);
   is.close();
   os.flush();
   os.close();
  }catch (IOException e) {
    e.printStackTrace();
   }
     }
       

throw:  可以用来抛出一个新的异常
        public void test (int i) throws Exception{
  if(i!= 5)
   throw new Exception("你输入的值不等于5！");
  else
   System.out.println("你输入的值等于五");
     }

7.返回

return： 表示在某一方法之后返回一个值
         public void setName(name){
            this.name = name;
            return;//即返回值为空
         }
         public String getName(){
            return this.name;
         }

true：   表示某一判定表达式的值为真

false：  表示某一判定表达式的值为假，即不成立

new：    用构造函数实例化一个对象，此时new的对象在内存中被创建，可以调用构造函数所在类的公开方法，属性等
         Student stu = new Student();

this：   指代当前对象，在return的例子中，this.name表示此类中定义的属性name
         public Student(){
              this("name,number");//即实际调用了下方的这个构造函数
            }
            public Student(String name,String number){
              this.name = name;
              this.number = number;
         }

instanceof：判断当前对象是否是该类的实例
            ClassA(Object temp){  
            if(temp instanceof Integer){//判断输入的是整型  
            a = Integer.parseInt(temp.toString());  
            System.out.println("this is an "+ temp.getClass().getName()
               +" Integer value" + a);
            }else if(temp instanceof String){//判断输入的是字符串  
            b = temp.toString();  
            System.out.println("this is a "+ temp.getClass().getName()
               +" String value=" + b);
              
8.其它      

enum：      枚举类型
            private enum Seasons { winter， spring，
            summer， fall }
           //代码中使用到时
           if(string.equals(enum.winter)){
              System.out.println（"winter"）；
           }
           else if(string.equals(enum.spring)){
              System.out.println（"spring"）；
           }
          

transient： 表示瞬时，transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
            
synchronized：同步，synchronized可以用来修饰方法或者语句块，也就是平时所说的同步方法和同步语句块。同时,无论此关键字时加在方法还是对象上，它所取得的锁都是一个对象

assert：    断言，一般来说assert在开发的时候是检查程序的安全性的，在发布的时候通常都不使用assert

native：    简单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言 都有这一机制，比如在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数

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

volatile：  Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是synchronized 的一部分。Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值
                                                            艾儿~~~~