Java中一些关键字的使用技巧总结

Java中一些关键字的使用技巧总结

final——

final用于类表示该类不能派生子类。

final用于方法表示该方法不能被子类重写。

final用于变量时表示常量，类似于C/C++的const关键字。

final用于成员变量表示该成员变量为常量，不能被修改，必须在变量定义时赋值。

final用于局部变量表示该局部变量为常量，不能被修改，可以在变量定义时赋值，也可以先定义变量后赋值。

static——

static用于成员变量表示该变量只有一份，也就是说静态成员变量属于类而不属于某个具体的类实例对象，所有的类实例对象共享这个静态成员变量，访问静态成员变量时通过对应的类名完成。静态成员变量在定义时可初始化赋值，也可不赋值，不赋值时会被自动初始化，切记局部变量不可以是静态的。

static用于方法，使得不需要实例化类就可以通过类名来调用静态方法，需要注意的是在静态方法内不可以使用this关键字，不可以调用非静态方法，也不可以引用非静态成员变量。

static用于类，这里指的是内部类，那么在别的地方就可以通过外部类名来引用这个静态的内部类。

static还可以用于类的代码块，叫做静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

类的访问权限（Y/N）

|| 关键字 || 类 || 包 || 子类 || 其它包 ||

| public | Y | Y | Y | Y |

| protected | Y | Y | Y | N |

| default | Y | Y | N | N |

| private | Y | N | N | N |

public、protected和private三个关键字，可以用于类（内部类）、成员变量和成员函数，默认的访问权限是包内有效，当类访问权限与成员变量或成员函数的访问权限不同时，选择最低访问权限。

interface/implements/extends/class——

interface用于声明接口，接口中的方法只有声明，没有实现，访问权限可以是public或者默认权限，还可以指定为abstract。

implements用于实现接口，需要实现接口中的所有方法，可以同时实现多个接口。

extends用于继承父类或父接口，继承父类时只能是单继承，与C++的多继承不同，接口继承支持多继承。

class用于声明类，访问权限可以是public或者默认权限，还可以指定为abstract、final，访问权限对于顶层类和内部类的限制是不同的。

abstract——

abstract用于类表示这个类为抽象类，不能实例化。

abstract用于方法表示这个方法为抽象方法，只需声明，不用实现，由子类实现，抽象方法不能用private和static关键字。

下面来着重讲一下this和super的使用：

this

        java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，这在“Java关键字static、final使用总结”一文中给出了明确解释。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。下面给出一个使用this的综合实例，以便说明问题：

package org.leizhimin;

public class Test6 {

private int number;

private String username;

private String password;

private int x = 100;

public Test6(int n) {

number = n; // 这个还可以写为: this.number=n;

}

public Test6(int i, String username, String password) {

// 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.

this.username = username;

this.password = password;

}

// 默认不带参数的构造方法

public Test6() {

this(0, "未知", "空"); // 通过this调用另一个构造方法

}

public Test6(String name) {

this(1, name, "空"); // 通过this调用另一个构造方法

}

public static void main(String args[]) {

Test6 t1 = new Test6();

Test6 t2 = new Test6("游客");

t1.outinfo(t1);

t2.outinfo(t2);

}

private void outinfo(Test6 t) {

System.out.println("-----------");

System.out.println(t.number);

System.out.println(t.username);

System.out.println(t.password);

f(); // 这个可以写为: this.f();

}

private void f() {

// 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.

int x;

x = this.x++;

System.out.println(x);

System.out.println(this.x);

}

//返回当前实例的引用

private Test6 getSelf() {

return this;

}

}

运行结果如下：

-----------

0

未知

空

100

101

-----------

0

游客

空

100

101

看着上面的例子，说明在什么情况下需要用到this：

        第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。

        第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。

        第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。

        其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的，死记不然容易忘记而且容易搞错，要理解！

super

        super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。

不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。下面是一个综合运用super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：

package org.leizhimin;

public class Father {

public String v="Father";

public String x="输出了Father类的public成员变量x!!!";

public Father() {

System.out.println("Father构造方法被调用!");

}

public Father(String v){

this.v="Father类的带参数构造方法!运行了.";

}

public void outinfo(){

System.out.println("Father的outinfo方法被调用");

}

public static void main(String[] args) {

// TODO 自动生成方法存根

}

}

package org.leizhimin;

public class Son extends Father{

public String v="Son";

public Son() {

super(); //调用超类的构造方法,只能放到第一行.

System.out.println("Son无参数构造方法被调用!");

//super(); //错误的,必须放到构造方法体的最前面.

}

public Son(String str){

super(str);

System.out.println("Son带参数构造方法被调用!");

}

//覆盖了超类成员方法outinfo()

public void outinfo(){

System.out.println("Son的outinfo()方法被调用"http://);

}

public void test(){

String v="哈哈哈哈!"; //局部变量v覆盖了成员变量v和超类变量v

System.out.println("------1-----");

System.out.println(v); //输出局部变量v

System.out.println(this.v); //输出(子类)成员变量v

System.out.println(super.v); //输出超类成员变量v

System.out.println("------2-----");

System.out.println(x); //输出超类成员变量v,子类继承而来

System.out.println(super.x); //输出超类成员变量v

System.out.println("------3-----");

outinfo(); //调用子类的outinfo()方法

this.outinfo(); //调用子类的outinfo()方法

super.outinfo(); //调用父类的outinfo()方法

}

public static void main(String[] args) {

new Son().test();

}

}

子类Son运行结果：

Father构造方法被调用!

Son无参数构造方法被调用!

------1-----

哈哈哈哈!

Son

Father

------2-----

输出了Father类的public成员变量x!!!

输出了Father类的public成员变量x!!!

------3-----

Son的outinfo()方法被调用

Son的outinfo()方法被调用

Father的outinfo方法被调用

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。