java关键字整理

什么是关键字？

答：关键字：被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方法时候会转入内嵌机制，大大提高执行效率。