Java中一些關(guān)鍵字的使用技巧總結(jié)

更新時間：2015年09月10日 09:30:53 作者：leizhimin

這篇文章主要介紹了Java中一些關(guān)鍵字的使用技巧總結(jié),其中重點講述了this和super兩個關(guān)鍵字的用法,需要的朋友可以參考下

final——

final用于類表示該類不能派生子類。

final用于方法表示該方法不能被子類重寫。

final用于變量時表示常量，類似于C/C++的const關(guān)鍵字。

final用于成員變量表示該成員變量為常量，不能被修改，必須在變量定義時賦值。

final用于局部變量表示該局部變量為常量，不能被修改，可以在變量定義時賦值，也可以先定義變量后賦值。

static——

static用于成員變量表示該變量只有一份，也就是說靜態(tài)成員變量屬于類而不屬于某個具體的類實例對象，所有的類實例對象共享這個靜態(tài)成員變量，訪問靜態(tài)成員變量時通過對應(yīng)的類名完成。靜態(tài)成員變量在定義時可初始化賦值，也可不賦值，不賦值時會被自動初始化，切記局部變量不可以是靜態(tài)的。

static用于方法，使得不需要實例化類就可以通過類名來調(diào)用靜態(tài)方法，需要注意的是在靜態(tài)方法內(nèi)不可以使用this關(guān)鍵字，不可以調(diào)用非靜態(tài)方法，也不可以引用非靜態(tài)成員變量。

static用于類，這里指的是內(nèi)部類，那么在別的地方就可以通過外部類名來引用這個靜態(tài)的內(nèi)部類。

static還可以用于類的代碼塊，叫做靜態(tài)代碼塊，是在類中獨立于類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內(nèi)，JVM加載類時會執(zhí)行這些靜態(tài)的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現(xiàn)的先后順序依次執(zhí)行它們，每個代碼塊只會被執(zhí)行一次。

類的訪問權(quán)限（Y/N）

|| 關(guān)鍵字 || 類 || 包 || 子類 || 其它包 ||
| public | Y | Y | Y | Y |
| protected | Y | Y | Y | N |
| default | Y | Y | N | N |
| private | Y | N | N | N |

public、protected和private三個關(guān)鍵字，可以用于類（內(nèi)部類）、成員變量和成員函數(shù)，默認(rèn)的訪問權(quán)限是包內(nèi)有效，當(dāng)類訪問權(quán)限與成員變量或成員函數(shù)的訪問權(quán)限不同時，選擇最低訪問權(quán)限。

interface/implements/extends/class——

interface用于聲明接口，接口中的方法只有聲明，沒有實現(xiàn)，訪問權(quán)限可以是public或者默認(rèn)權(quán)限，還可以指定為abstract。

implements用于實現(xiàn)接口，需要實現(xiàn)接口中的所有方法，可以同時實現(xiàn)多個接口。

extends用于繼承父類或父接口，繼承父類時只能是單繼承，與C++的多繼承不同，接口繼承支持多繼承。

class用于聲明類，訪問權(quán)限可以是public或者默認(rèn)權(quán)限，還可以指定為abstract、final，訪問權(quán)限對于頂層類和內(nèi)部類的限制是不同的。

abstract——

abstract用于類表示這個類為抽象類，不能實例化。

abstract用于方法表示這個方法為抽象方法，只需聲明，不用實現(xiàn)，由子類實現(xiàn)，抽象方法不能用private和static關(guān)鍵字。

下面來著重講一下this和super的使用：

this
Java關(guān)鍵字this只能用于方法方法體內(nèi)。當(dāng)一個對象創(chuàng)建后，Java虛擬機(jī)（JVM）就會給這個對象分配一個引用自身的指針，這個指針的名字就是this。因此，this只能在類中的非靜態(tài)方法中使用，靜態(tài)方法和靜態(tài)的代碼塊中絕對不能出現(xiàn)this，這在“Java關(guān)鍵字static、final使用總結(jié)”一文中給出了明確解釋。并且this只和特定的對象關(guān)聯(lián)，而不和類關(guān)聯(lián)，同一個類的不同對象有不同的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) {
 // 成員變量和參數(shù)同名,成員變量被屏蔽,用"this.成員變量"的方式訪問成員變量.
 this.username = username;
 this.password = password;
 }
 // 默認(rèn)不帶參數(shù)的構(gòu)造方法
 public Test6() {
 this(0, "未知", "空"); // 通過this調(diào)用另一個構(gòu)造方法
 }
 public Test6(String name) {
 this(1, name, "空"); // 通過this調(diào)用另一個構(gòu)造方法
 }
 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);
 }
 
 //返回當(dāng)前實例的引用
 private Test6 getSelf() {
 return this; 
 }
}

運行結(jié)果如下：

-----------
0
未知
空
100
101
-----------
0
游客
空
100
101

        看著上面的例子，說明在什么情況下需要用到this：
        第一、通過this調(diào)用另一個構(gòu)造方法，用發(fā)是this(參數(shù)列表)，這個僅僅在類的構(gòu)造方法中，別的地方不能這么用。
        第二、函數(shù)參數(shù)或者函數(shù)中的局部變量和成員變量同名的情況下，成員變量被屏蔽，此時要訪問成員變量則需要用“this.成員變量名”的方式來引用成員變量。當(dāng)然，在沒有同名的情況下，可以直接用成員變量的名字，而不用this，用了也不為錯，呵呵。
        第三、在函數(shù)中，需要引用該函所屬類的當(dāng)前對象時候，直接用this。
        其實這些用法總結(jié)都是從對“this是指向?qū)ο蟊旧淼囊粋€指針”這句話的更深入的理解而來的，死記不然容易忘記而且容易搞錯，要理解！

super

        super關(guān)鍵和this作用類似，是被屏蔽的成員變量或者成員方法或變?yōu)榭梢?，或者說用來引用被屏蔽的成員變量和成員成員方法。
不過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構(gòu)造方法被調(diào)用!");
 }
 
 public Father(String v){
 this.v="Father類的帶參數(shù)構(gòu)造方法!運行了.";
 }
 public void outinfo(){
 System.out.println("Father的outinfo方法被調(diào)用");
 } 
 public static void main(String[] args) {
 // TODO 自動生成方法存根
 }
}
 
package org.leizhimin;
public class Son extends Father{
 public String v="Son";
 
 public Son() {
 super();   //調(diào)用超類的構(gòu)造方法,只能放到第一行.
 System.out.println("Son無參數(shù)構(gòu)造方法被調(diào)用!");
 //super();   //錯誤的,必須放到構(gòu)造方法體的最前面.
 } 
 
 public Son(String str){
 super(str);
 System.out.println("Son帶參數(shù)構(gòu)造方法被調(diào)用!");
 }
 //覆蓋了超類成員方法outinfo()
 public void outinfo(){ 
 System.out.println("Son的outinfo()方法被調(diào)用");
 } 
 
 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();  //調(diào)用子類的outinfo()方法
 this.outinfo(); //調(diào)用子類的outinfo()方法
 super.outinfo(); //調(diào)用父類的outinfo()方法
 } 
 
 public static void main(String[] args) {
 new Son().test();
 
 }
}

子類Son運行結(jié)果：

Father構(gòu)造方法被調(diào)用!
Son無參數(shù)構(gòu)造方法被調(diào)用!
------1-----
哈哈哈哈!
Son
Father
------2-----
輸出了Father類的public成員變量x!!!
輸出了Father類的public成員變量x!!!
------3-----
Son的outinfo()方法被調(diào)用
Son的outinfo()方法被調(diào)用
Father的outinfo方法被調(diào)用

您可能感興趣的文章: