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(“一定执行的部分。
。
。
”):
}
}
}