JAVA关键字总结.docx
《JAVA关键字总结.docx》由会员分享，可在线阅读，更多相关《JAVA关键字总结.docx（15页珍藏版）》请在冰豆网上搜索。
JAVA关键字总结
JAVA关键字单词记忆表（Beta版）
名称：
public
解释：
访问权限修饰符的一种，公开，公共的意思。
用法：
用来修饰类，属性，方法。
对于外部的任何类都能够访问。
例子：
publicclassStudent{
publicStringname;
publicvoiddisplay（）{
System.out.println（name）;
}
}
名称：
protected
解释：
访问权限修饰符的一种，受保护的意思。
用法：
用来修饰属性，方法。
只能符合有包内友好关系，或者是父子友好的类才能够访问,不能修饰类.
例子：
publicclassTeacher{
protectedfloatsalary;
protectedvoiddisplay（）{
System.out.println（“薪水是:
”+salary）;
}
}
名称：
private
解释：
访问权限修饰符的一种，私有的意思。
用法：
用来修饰属性，方法。
只能类的内部本身才能够访问,不能修饰类.
例子：
publicclassDesk{
privateintprice;
privatevoiddisplay（）{
System.out.println（“价格是:
”+price）;
}
}
名称：
byte
解释：
数据类型，字节型
用法：
用来定义临时变量、形参、属性的数据类型。
格式如下：
byte【变量名、形参名、属性名】
例子：
publicclassBook{
privatebytepage;
publicbytedisplay（bytep）{
bytep1=p;
page=p;
returnp1;
}
}
名称：
boolean
解释：
数据类型，布尔型,它的取值只能为true或者false。
用法：
用来定义临时变量、形参、属性的数据类型。
格式如下：
boolean【变量名、形参名、属性名】
例子：
publicclassBook{
privatebooleanflag;
publicbooleandisplay（booleanp）{
booleanp1=p;
flag=p;
returnp1;
}
}
名称：
true
解释：
真，布尔型的字面值
用法：
boolean类型的取值范围之一.
例子：
publicclassBook{
privatebooleanflag=true;
publicbooleandisplay（booleanp）{
booleanp1=false;
flag=p;
returnp1;
}
}
名称：
false
解释：
假，布尔型的字面值
用法：
boolean类型的取值范围之一.
例子：
publicclassBook{
privatebooleanflag=true;
publicbooleandisplay（booleanp）{
booleanp1=false;
flag=p;
returnp1;
}
}
名称：
null
解释：
空
用法：
对象的一种取值，称呼为：
“null值”，这时候我们理解成内存里面还没有得到这个对象空间。
例子：
publicclassTest{
publicstaticvoidmain（String[]args）{
Stringstr=null;
StringBuffersb=null;
}
}
名称：
new
解释：
新建
用法：
创建对象时使用，当一看倒new关键字，意味着在内存的堆空间里开辟了一个空间，存放了相对应类型的对象出来。
创建的对象由一个相对应类型的引用去指向访问，类似与C语言中指针的用法。
格式如下：
类名引用名=new类名（）
例子：
publicclassTest{
publicstaticvoidmain（String[]args）{
Stringstr=newString（）;
StringBuffersb=newStringBuffer（）;
}
}
名称：
class
解释：
类，种类
用法：
定义一个类，这时候定义的类，在内存空间里面没有分配空间。
换句话说，它还没有存在于现实生活中，它不是一个实体。
类里面有方法有属性，要想访问它里面的方法和属性就要通过对象去使用。
格式如下:
访问权限修饰符class类名{}
例子：
//定义一个类
publicclassMp3{
}
名称：
abstract
解释：
抽象，抽象的
用法：
类修饰符的一种，可以用来修饰类，方法，被修饰的类不能够实例化（即不能用new关键字得到对象），被修饰的方法不能够实现。
一个抽象类中不一定要有抽象方法，但是一个类里面有抽象方法就一定是抽象类。
如果由类要继承抽象类的话，必须要实现里面的抽象方法。
构造方法和静态方法不可以修饰为抽象。
例子：
publicabstractclassAnimal{
publicabstractvoidcry（）;
publicvoidrun（）{
System.out.println（“跑的方法……”）;
}
}
名称：
interface
解释：
接口，界面
用法：
它本质上是一个类，一个完全抽象的类，里面没有任何实现的方法。
它不是用来继承的，是用来实现的。
某个类如果实现了接口就必须要实现接口里面的所有方法。
并且接口是不能用来实例化的，它也是不能通过new关键字获得对象。
例子：
publicinterfaceclassAnimal{
publicvoidcry（）;
publicvoidrun（）;
}
名称：
implements
解释：
实现
用法：
用来让一个类实现一个接口的关键字，实现接口的这个类必须实现接口里面所有的方法。
例子：
publicclassDogimplementsAnimal{
publicvoidcry（）{
System.out.println（“汪汪叫。
。
。
。
。
”）;
}
publicvoidrun（）{
System.out.println（“跑的方法…….”）;
}
}
名称：
final
解释：
最终的，决定性的
用法：
修饰符的一种，它可以用来修饰类，方法，属性。
当一个属性被修饰成final的之后，这个属性变成了常量，它的值必须在定义的时候初始化，并且后面的代码不能对其进行修改,它的命名应该全部都是大写。
当一个方法被修饰成final的之后，这个方法在继承中是不能够被进行覆盖的。
当一个类被修饰成final的之后，这个类不能再有子类。
例子：
publicfinalclassMath{
privatefinalfloatPI=3.1415926;
publicfinalintabs（inti）{
returni>=0?
i:
-I;
}
}
名称：
extends
解释：
扩充，扩展
用法：
一个类继承另一个类的关键字，当出现了这个关键字，两个类就有了继承关系，extends前面的类，我们称之为父类。
extends后面的类，我们称之为子类。
有了继承关系之后，我们就说子类拥有父类继承下来的所有非私有的成员（包括了属性，方法），但是不包括构造方法。
例子：
publicclassPerson{
publicStringname;
publicintage;
publicvoiddinning（）{
System.out.println（“吃饭…..”）;
}
}
publicclassStudentextendsPerson{
}
名称：
super
解释：
上一级的，超级的
用法：
代表了当前类中父类的对象。
能够去调用父类的构造方法，属性，方法。
但是需要注意，如果是在当前类的构造方法中去调用父类的构造方法，必须把调用语句写在本类构造方法的第一句上。
例子：
publicclassPerson{
publicStringname;
publicintage;
publicvoiddinning（）{
System.out.println（“吃饭…..”）;
}
}
publicclassStudentextendsPerson{
publicStudent（）{
super（）;//放在第一句话
super.dinning（）;
}
}
名称：
this
解释：
这，这个
用法：
指离它最近类的当前对象，他能够调用本类中的属性，方法，构造方法。
需要注意的是在静态方法中不能使用this关键字。
例子：
publicclassMp3{
publicStringname;
publicMp3（Stringname）{
this.name=name;
}
publicvoidrunning（）{
System.out.println（“播放”+this.name+”歌曲”）;
}
}
名称：
static
解释：
静态的
用法：
修饰符的一种，能够用来修饰属性和方法。
需要注意的是被修饰的属性和方法，不再属于对象所有，而是属于类，意味着，要访问这些属性和方法不再通过对象而是直接用类名来访问。
另外，静态的方法不能够访问非静态属性，非静态的方法能够访问静态的属性。
例子：
publicclassDog{
privateintblood;//生命值
privatestaticintcount;
publicstaticvoiddisplay（）{
System.out.println（“生命值还有：
”+blood）;//错误的
System.out.println（“狗的个数为”+（++count））;//正确的
}
}
名称：
package
解释：
包裹，包
用法：
为了防止同一个目录下面存在于两个相同名字的源文件，使用打包的用处和文件夹的作用是相似的。
要注意，打包语句一定只能放在源文件的第一句话，并且不能在同一个源文件中出现两个或者两个以上的打包语句。
包可以嵌套，通常来讲，第一个包称之为根包，后面的嵌套包称之为子包。
例子：
packagecom.zhang;
publicclassClock{
privateinthour;
privateintmin;
privateintsec;
publicvoiddisplay（）{
System.out.println（hour+”:
”+min+”:
”+sec）;
}
}
名称：
import
解释：
引入，导入
用法：
相对应打包而言，当一个类被放在包下面了，如果要使用这个类就必须到这个包下面去寻找这个类，因此出现了导包语句。
导包可以有多条语句。
例子：
importcom.zhang.*;
//或者是
importcom.zhang.Clock;
publicclassTest{
Publicstaticvoidmain（String[]args）{
Clockc=newClock（）;
}
}
名称：
try
解释：
监视，考验，审问
用法：
try块用来监视所有又可能发生异常的代码，它可以和catch块组合，也可以和final块组合，也可以和catch块，final块一起组合使用。
例子：
publicclassTest{
publicstaticvoidmain（String[]args）{
inti=10;
try{
System.out.println（i/0）;
}
catch（ArithmeticExceptioname）{
ame.printStackTrace（）;
}
}
}
名称：
catch
解释：
捕捉，捕获
用法：
当发现被监视的代码中有异常出现的时候,catch就用相对应的异常类进行捕捉。
并且打印出相应的异常信息。
catch块，必须要配合try块一起使用，不能单独使用，也不能直接和finally块一起使用。
例子：
publicclassTest{
publicstaticvoidmain（String[]args）{
inti=10;
try{
System.out.println（i/0）;
}
catch（ArithmeticExceptioname）{
ame.printStackTrace（）;
}
}
}
名称：
throw
解释：
抛出，扔
用法：
用户自己人为的抛出一个异常。
可以让本没有异常的代码中出现一个人造的异常出来。
既然自己抛出一个异常那就要自己负责到底，自己用catch块去将这个异常给捕捉。
其语法格式如下：
throw异常对象。
例子：
publicclassTest{
publicstaticvoidmain（String[]args）{
try{
thrownewException（）;
}
catch（Exceptionex）{
ex.printStackTrace（）;
}
}
}
名称：
throws
解释：
抛出，扔
用法：
将方法体内产生的异常，自己不想再去负责捕捉，于是使用throws关键字将异常抛出方法体外部去。
注意体内产生了什么类型的异常就应该抛出什么样的异常。
并且抛出去之后总有一个人要负起这个责任，也就是谁调用了这个方法，谁去捕捉。
例子：
publicclassStudent{
privateintage;
publicvoiddisplay（intage）throwsException{
thrownewException（）;
}
}
publicclassTest{
publicstaticvoidmain（String[]args）{
Students=newStudent（）;
try{
s.display（300）;
}
catch（Exceptionex）{
ex.printStackTrace（）;
}
}
}
名称：
finally
解释：
最后，终于，不可更改地
用法：
在异常处理机制当中，它的作用就像是人吃饭一样，必须得做的，不论有异常还是没有异常都要执行的代码就可以放到finally块当中去。
finally块，必须要配合try块一起使用，不能单独使用，也不能直接和catch块一起使用。
例子：
publicclassTest{
publicstaticvoidmain（String[]args）{
inti=10;
try{
System.out.println（i/0）;
}
catch（ArithmeticExceptioname）{
ame.printStackTrace（）;
}
finally{
System.out.println（“一定执行的部分。
。
。
”）:
}
}
}
升级会员 