Java关键字归纳

1005班 王哲

Java 关键字全部由小写字母组成

关键字 package包裹，包 为了防止同一个目录下面存在于两个相同名字的源文件，使用打包的用处和文件夹的作用是相似的。要注意，打包语句一定只能放在源文件的第一句话，并且不能在同一个源文件中出现两个或者两个以上的打包语句。包可以嵌套，通常来讲，第一个包称之为根包，后面的嵌套包称之为子包。 例子： package com.zhang; public class Clock{ private int hour; private int min; private int sec; public void display(){ System.out.println(hour+”:”+min+”:”+sec);

} }

import解释：引入，导入 用法：相对应打包而言，当一个类被放在包下面了，如果要使用这个类就必须到这个包下面去寻找这个类，因此出现了导包语句。导包可以有多条语句。 例子： import com.zhang.*;

//或者是

import com.zhang.Clock; public class Test{ Public static void main(String[] args){ Clock c = new Clock();

} }

boolean 布尔型又名 逻辑型 布尔常量 为 true和false

Ture为真 false为假 java中布尔型数据不对应任何整数值 与C++不同。 true 真，布尔型值 false 假，布尔型值

char 字符型变量 java的文本编码采用Unicode码，java字符是16位无符号型数据 一个字符变量占2字节。 byte 字节型变量 占字节数 1 范围-2^7 ~ 2^7-1 short 短整型变量 占字节数 2 范围-2^15 ~ 2^15-1 int 整形变量 占字节数 4 范围-2^31 ~ 2^31-1 long 长整形变量 占字节数 8 范围-2^63 ~ 2^63-1 float 单精度浮点变量 占字节数 4

范围 3.4e^(-038)~3.4e^(+038) -3.4e^(+038) ~-3.4e^(-038) 要特别说明是单精度常量，可以在末尾加上f或F为后缀。

double 双精度浮点变量 占字节数 8 范围 1.74e^(-308)~1.74e^(+308) -1.74e^(+038) ~-1.74e^(-038)

要特别说明是双精度常量，可以在末尾加上d或D为后缀。

class 类 种类 1定义一个类，这时候定义的类，在内存空间里面没有分配空间。换句话说，它还没有存在于现实生活中，它不是一个实体。类里面有方法有属性，要想访问它里面的方法和属性就要通过对象去使用。格式如下: 访问权限修饰符 class 类名{} 例子： //定义一个类 public class helloword{

} new 创建对象时使用，当一看倒new关键字，意味着在内存的堆空间里开辟了一个空间，存放了相对应类型的对象出来。创建的对象由一个相对应类型的引用去指向访问，类似与C语言中指针的用法。格式如下：类名 引用名 = new 类名() 例子： public class Test{ public static void main(String[] args){ String str = new String(); StringBuffer sb = new StringBuffer();

} } null 空 对象的一种取值，= null时，内存里面还没有得到这个对象空间。 例子： public class Test{ public static void main(String[] args){ String str = null; StringBuffer sb = null;

} }

interface 接口 它本质上是一个类，一个完全抽象的类，里面没有任何实现的方法。它不是用来继承的，是用来实现的。某个类如果实现了接口就必须要实现接口里面的所有方法。并且接口是不能用来实例化，它也是不能通过new关键字获得对象。 例子： public interface class Animal{ //一个Animal接口 public void cry(); // 方法被定义没有被写，用于去实现 public void run(); // 方法被定义没有被写，用于去实现

}

implements 实现，与接口相对应 用来让一个类实现一个接口的关键字，实现接口的这个类必须实现接口里面所有的方法。 例子： public class Dog implements Animal{ //实现Animal接口 public void cry(){ //实现Animal接口中cry方法 System.out.println(“汪汪叫。。。。。”);

}

public void run(){ //实现Animal接口中run方法 System.out.println(“跑的方法…….”); } }

extends 继承 一个类继承另一个类的关键字，当出现了这个关键字，两个类就有了继承关系，extends前面的类，我们称之为父类。extends后面的类，我们称之为子类。有了继承关系之后，我们就说子类拥有父类继承下来的所有非私有的成员（包括了属性，方法），但是不包括构造方法。 例子： public class Person{ public String name; public int age; public void dinning(){

}

System.out.println(“吃饭…..”);

}

public class Student extends Person{ //学生继承人的属性和方法 }

super 代表了当前类中父类的对象。能够去调用父类的构造方法，属性，方法。需要注意，如果是在当前类的构造方法中去调用父类的构造方法，必须把调用语句写在本类构造方法的第一句上。 例子： public class Person{ public String name; public int age; public void dinning(){ System.out.println(“吃饭…..”);

} }

public class Student extends Person{ public Student(){ super(); //放在第一句话 super.dinning();

} }

this 用来表示离它最近类的当前对象，他能够调用本类中的属性，方法，构造方法。需要注

意的是在静态方法中不能使用this关键字。 例子： public class Mp3{ public String name; public Mp3(String name){ this.name = name;

}

public void running(){

}

System.out.println(“播放”+this.name+”歌曲”);

}

Abstract 抽象，抽象的

类修饰符的一种，可以用来修饰类，方法，被修饰的类不能够实例化（即不能用new关键字得到对象），被修饰的方法也不能够实现。一个抽象类中不一定要有抽象方法，但是一个类里面有抽象方法就一定是抽象类。如果由类要继承抽象类的话，必须要实现里面的抽象方法。构造方法和静态方法不可以修饰为抽象。 例子： public abstract class Animal { public abstract void cry(); public void run(){

}

}

System.out.println(“跑的方法……”);

instanceof是Java的一个二元操作符，和==，>，<是同一类东西。但它是由字母组成。它的作用是测试它左边的对象是否是它右边的类的实例，返回booean类型的数据。可以用在继承中的子类的实例是否为父类的实现

例子：

public class Bill { }

public class PhoneBill extends Bill { } public class GasBill extends Bill { }

public double calculate(Bill bill) { if (bill instanceof PhoneBill) { //计算电话账单 }

if (bill instanceof GasBill) { //计算燃气账单 } ...

}

在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断

public 访问权限修饰符的一种，公开，公共的意思。用来修饰类，属性，方法。对于外部的任何类都能够访问。

protected 访问权限修饰符的一种，受保护的意思。用来修饰属性，方法。只能符合有包内友好关系，或者是父子友好的类才能够访问,不能修饰 类.

private 访问权限修饰符的一种，私有的意思。用来修饰属性，方法。只能类的内部本身才能够访问,不能修饰 类.

final 最终的，决定性的 修饰符的一种，它可以用来修饰 类，方法，属性。当一个属性被修饰成final的之后，这个属性变成了常量，它的值必须在定义的时候初始化，并且后面的代码不能对其进行修改,它的命名应该全部都是大写。当一个方法被修饰成final的之后，这个方法在继承中是不能够被进行覆盖的。当一个类被修饰成final的之后，这个类不能再有子类。 例子： public final class Math{ private final float PI = 3.1415926; public final int abs(int i){

return i>=0?i:-I; } }

static 静态的 修饰符的一种，能够用来修饰属性和方法。需要注意的是被修饰的属性和方法，不再属于对象所有，而是属于类，意味着，要访问这些属性和方法不再通过对象而是直接用类名来访问。另外，静态的方法不能够访问非静态属性，非静态的方法能够访问静态的属性。 例子： public class Dog{

private int blood; //生命值 private static int count;

public static void display(){ System.out.println(“生命值还有：”+blood); System.out.println(“狗的个数为”+(++count)); }

//错误的 //正确的

}

void 无类型。常用在程序编写中对定义函数的参数类型、返回值、函数中指针类型进行声明。

strictfp 可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。

简单的说就是想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp.

transient 变量修饰符，声明一个实例变量，当对象存储时，它的值不需要维持。

synchronized 代表这个方法加锁,相当于不管哪一个线程A每次运行到这个

方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。

volatile是一个类型修饰符。它是用来修饰被不同线程访问和修改的变量。如果没有volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器失去大量优化的机会。

例子：

public class MyTestThread extends MyTest implements Runnable { private volatile boolean done = false; public void run( ) { while (!done) { repaint( ); try {

Thread.sleep(100);

} catch (InterruptedException ie) { return; } } }

public void setDone(boolean b) { done = b;

} }

native 简单地讲，一个Native 方法就是一个java调用非java代码的接口。该

方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern \"C\"告知C＋＋编译器去调用一个C的函数。Java不是完美的，Java的不足除了体现在运行速度上要比传统的C++慢许多之外，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。

if 是基本的分支语句。通过条件的直接判断，转向不同的程序流程。 if（条件） 语句块

else if条件语句条件为假执行else语句

if（条件）

语句块 Else

语句块

do 与while连用 构成循环判断语句 , 不论是否满足条件，先执行一次代码。 do {

}while（条件）；

while 条件判断的循环语句，满足条件执行，不满足跳出循环。 While（条件） { }

for 条件循环语句

for（表达式1；表达式2；表达式3） {

}

switch 条件分支语句

switch ( 变量 ) {

case constantExpression1 : break； case constantExpression2 : break；

case constantExpression3 : break； case constantExpression : break； ...

default : break;

}

case switch语句中得分支条件 （见上）

default switch语句 所有case条件 不满足时执行此语句（见上）

break 用来中断程序的执行，一般用在循环语句中，用来跳出本层循环，

转去执行下面的程序。

continue其作用为结束本次循环。即跳出循环体中下面尚未执行的语句，对于while循环，继续求解循环条件。而对于for循环程序流程接着求解for语句头中的第三个部分expression表达式。 continue语句和break语句的区别是： continue语句只结束本次循环，而不终止整个循环的执行。而break语句则是结束整个循环过程，不再判断执行循环的条件是否成立。

return 表示从被调方法返回到主调方法继续执行，返回时可附带一个返回值，由return后面的参

数指定

try 监视，考验，审问 try块用来监视所有又可能发生异常的代码，它可以和catch块组合，也可以和final块组合，也可以和catch块，final块一起组合使用。 例子： public class Test{ public static void main(String[] args){ int i = 10; try{

System.out.println(i/0); }

catch(ArithmeticException ame){ ame. printStackTrace(); } } }

catch 捕捉，捕获异常 当发现被监视的代码中有异常出现的时候,catch就用相对应的异常类进行捕捉。并且打印出相应的异常信息。catch块，必须要配合try块一起使用，不能单独使用，也不能直接和finally块一起使用。 例子： public class Test{ public static void main(String[] args){ int i = 10; try{

System.out.println(i/0); }

catch(ArithmeticException ame){ ame. printStackTrace(); } } }

throw 抛出，扔异常 用法：用户自己人为的抛出一个异常。可以让本没有异常的代码中出现一个人造的异常出来。既然自己抛出一个异常那就要自己负责到底，自己用catch块去将这个异常给捕捉。其语法格式如下：throw 异常对象。 例子： public class Test{ public static void main(String[] args){ try{

throw new Exception(); }

catch(Exception ex){ ex. printStackTrace(); } } }

throws 抛出，扔异常 将方法体内产生的异常，自己不想再去负责捕捉，于是使用throws关键字将异常抛出方法体外部去。注意体内产生了什么类型的异常就应该抛出什么样的异常。并且抛出去之后总有一个人要负起这个责任，也就是谁调用了这个方法，谁去捕捉。 例子： public class Student{ private int age; public void display(int age) throws Exception{

throw new Exception(); } }

public class Test{ public static void main(String[] args){ Student s = new Student(); try{ s.display(300);

}

catch(Exception ex){ ex. printStackTrace();

} } }

Finally 最后，终于， 在异常处理机制当中，它的作用就像是人吃饭一样，必须得做的，不论有异常还是没有异常都要执行的代码就可以放到finally块当中去。finally块，必须要配合try块一起使用，不能单独使用，也不能直接和catch块一起使用。

例子： public class Test{ public static void main(String[] args){ int i = 10; try{

System.out.println(i/0); }

catch(ArithmeticException ame){ ame. printStackTrace(); }

finally{ System.out.println(“一定执行的部分。。。”):

} } }