什么是关键字?
答:关键字:被java语言赋予特定含义的单词。
特点:组成关键字单词的字母全部小写。
Java中的关键字一共包含48个,分别是:abstract、assert、boolean、break、byte、case、catch、char、vlass、continue、default、do、double、else、enum、extends、final、finally、float、for、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while
下面我把常用的关键字进行整理一下:
一.this 关键字的用法:
1.this 是一个引用对象本身的指针,用来表示当前的对象,它只和对象有关。在Java语言中,当创建一个对象后,Java虚拟机就会为其分配一个指向对象本身的指针,这个指针就是this。this只能用在类的非静态方法或者构造方法中。
在类中如果成员变量和方法中的局部变量的名字相同,那么在方法中成员变量将会被屏蔽。这时候还要使用成员变量,就需要使用关键字this,例如:
package wj.wcj.oop;
publicclass ThisKeyWordTest {
privateintage=34;
private String name="赵四";
publicvoid stuInfo(){
int age=29;
String name="李三";
System.out.println("this.name="+this.name+"this.age="+this.age);
System.out.println("name="+name+"age="+age);
}
publicstaticvoid main(String[] args) {
ThisKeyWordTest tkwt=new ThisKeyWordTest();
tkwt.stuInfo();
}
}
输出结果:this.name=赵四this.age=34
name=李三age=29
解析:this.name; this表示当前对象,而此时的对象是tkwt,那么将this.name替换成tkwt.name就不难发现此name为成员属性的name(对象调用属性或方法)。
2.使用this 引用当前对象
如果在类的方法中需要返回一个对象,并且该对象是方法所在类的当前对象,可以使用this关键字作为方法的返回值。例如:
package wj.wcj.oop;
publicclass Car {
public Car getCarObject(){
returnthis;
}
publicstaticvoid main(String[] args) {
Car sc=new Car();
System.out.println(sc.getCarObject()instanceof Car);
}
}
输出:true
解析:这里定义了一个返回类型为Car类型的方法getCarObject(),并使用this关键字返回当前的对象Car,在main()方法中创建一个Car对象并使用instanceof方法判断getCarObject()与Car对象是否匹配。
3.使用this关键字调用构造方法
this(参数列表); 这种方法只适用于构造方法的调用,用于调用重载的构造方法,并且this调用的构造方法必须放在第一位,其他方法不能使用这种方法调用,其实能调用构造方法的也只有这种方法(super也可以,this调用的是本类中其他的构造方法,而super调用的则是父类的构造方法),其他方法都不能调用构造方法(能调用构造方法的只有构造方法)。例如:
package wj.wcj.testkeyword;
publicclass Dog {
private String name;
public Dog(){
this("xiaohei");//this调用重载的构造方法
}
public Dog(String name){
this.name=name;
}
publicstaticvoid main(String[] args) {
}
二.Super关键字的使用:
使用super关键字可以在子类中引用父类(指直接父类)被屏蔽的方法、构造方法和成员变量,这里的父类指的是和子类最近的父类。列如:
package wj.wcj.oop;
class SuperKeyWord{
intintValue=10;
private String s1;
private String s2;
//构造方法
public SuperKeyWord(String s1,String s2){
this.s1=s1;
this.s2=s2;
System.out.println("super_Construction="+s1+s2);
}
publicint method(int i){
i=i*5;
System.out.println("super_mathod="+i);
return i;
}
}
publicclass SuperKeyWordTest extends SuperKeyWord {
intinValue=20;
//构造方法
public SuperKeyWordTest(){
super("super","Class"); }
publicstaticvoid main(String[] args) {
SuperKeyWordTest skwt=new SuperKeyWordTest();
skwt.callMethod();
}
publicint method(int i){
i=i*4;
System.out.println("son_mathod="+i);
return i;
}
publicvoid callMethod() {
System.out.println("son_intValueValue="+intValue);
System.out.println("super_intValueValue="+super.intValue);
method(100);
super.method(100);
}
}
输出:super_Construction=superClass
son_intValueValue=10
super_intValueValue=10
son_mathod=400
super_mathod=500
这里定义了两个类。其中SuperKeyWord是父类,SuperKeyWordTest是子类,在父类中定义了一个构造方法,该方法中有两个String类型的参数,还定义了一个method()方法,它需要一个int类型的参数并将该参数的值扩大5倍后返回。在子类
SuperKeyWordTest中定义了一个无参的构造方法,在该构造方法的第一句中调用了父类的带有两个参数的构造方法,并重写了父类的method()方法,在子类SuperKeyWordTest中定义了一个callMethod()方法,在该方法中直接使用方法名调用该类的method()方法,使用super调用父类的method()方法。在main()方法中创建了子类SuperKeyWordTest的对象,用器句柄调用该类的callMethod()方法。
三.Static关键字的使用
Static修饰的变量和方法是与类关联的,其值和方法会被类的所有实例共享。
1.使用static关键字修饰变量
使用static关键字修饰的变量称为静态变量,也叫类变量。该静态变量会被所有实例共享,不管在类中创建多少个对象,它们引用的都是同一个内存区域中的值,它是属于类的不依赖某个对象。
2.使用static关键字修饰方法
在Java中,静态方法只能访问该类的静态变量和静态方法,不能直接调用该类的非静态变量和方法。我们知道main()方法就是一个被static修饰的静态方法。因此在main()方法中直接调用的变量和方法也应该是静态的变量和方法。例如:
package wj.wcj.oop;
publicclass StaticTest {
intintValue=1;
publicstaticint getVariable(){
returnintValue;//编译错误,无法从静态方法中引用非静态方法
}
//修改变量intVariable
publicint addVariable(){
returnintValue++;
}
publicstaticvoid main(String[] args) {
StaticTest st=new StaticTest();
System.out.println(addVariable());//编译错误,无法从静态方法中引用非静态方法
}
}
getVariable()方法是一个静态方法,而return返回值intVariable却是一个非静态的变量,所以出现第一个编译错误,同样的道理,main()方法是一个静态方法,不能直接调用一个非静态的方法,但是,非静态方法是可以调用该类中的静态变量和静态方法的。
静态方法是属于类的方法,不属于类的对象。所以静态方法中不存在this。
3.使用static关键字静态初始化
Static关键字可以在类的内部、方法的外部使用一个static初始化一个代码段,这种初始化方式称为静态初始化,静态初始化的代码段只在类对象第一次载入时初始化一次,与非静态初始化不同的是,静态初始化需要在大括号前加入一个static关键字,方式如:
public class A{
Static{ //静态初始化
.....
}
在静态初始化里,一般初始化的都是静态变量。
初始化不同于方法,它没有方法名、返回值和参数列表。需要进行静态初始化的变量只需写在static后面的一对大括号内即可。
四.final关键字的使用
final数据:可以在编译时执行的计算,减轻了一些运行时的负担。基本数据类型在定义时,final修饰则必须赋值。对于基本数据类型,final使数值恒定不变,而对于对象引用,则使得该引用不能指向其他对象,但对象本身可以修改!
空白final:
空白final是指被声明为final但为给定初值的域。无论什么情况,编译器都确保空白final在使用前必须被初始化。一个类的final域就可以做到根据对象而有所不同,却又保持其恒定不变的特性。
final参数:
java允许在参数列表中以声明的方式将参数声明为final。这意味着你无法在方法中更改引用所指向的对象!
--------------------------
1.final类:final方法不能被子类的方法覆盖,但可以被继承。
2.final变量:final成员变量表示常量(C++的const),只能被赋值一次(定义时或构造函数中二选一),赋值后值不再改变。
3.final方法:你知道这个方法提供的功能已满足你要求,不需要扩展,并且也不允许任何从此类继承的类来覆写这个方法(就是说final修饰的方法可以被继承但不能被覆盖)。
它会使你在调用final方法时,直接将方法主体插入到调用处,而不是进行例行的方法调用,例如保存断点,压栈等,这样可能会使你的程序效率有所提高,然而当你的方法主体非常庞大时,或你在多处调用此方法,那么你的调用主体代码便会迅速膨胀,可能反而会影响效率,所以你要慎用final进行方法定义。
使用final方法的原因有二:
第一、把方法锁定,防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制,大大提高执行效率。