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()方法被调用");
 } 
 
 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方法被调用