Java幾個重要的關(guān)鍵字詳析

更新時間：2022年07月25日 11:41:36 作者：??欣欣子生胖氣?

這篇文章主要介紹了Java幾個重要的關(guān)鍵字詳析，文章圍繞主題展開詳細(xì)的內(nèi)容介紹，具有一定的參考一下，需要的小伙伴可以參考一下，希望對你的學(xué)習(xí)有所幫助

1.extends

用于類繼承類，用法：class+子類名+extends+父類名+{}

class Animal{}//父類
class cat extends Animal{}//子類用extends實(shí)現(xiàn)繼承

注意：一個類只能用extends關(guān)鍵字聲明繼承一個父類

用于接口繼承接口，用法：interface+接口名+extends+接口名+{}

interface Clippers {}
interface Warriors {}
interface Lakers extends Clippers,Warriors {}//接口類用extends關(guān)鍵字繼承其他接口（可多個）

注意：

接口不能用extends聲明繼承別的類
接口只能用extends聲明繼承別的接口，且可以繼承多個接口
當(dāng)一個類用implements實(shí)現(xiàn)了一個接口時，不僅要實(shí)現(xiàn)該接口的方法，也要實(shí)現(xiàn)該接口繼承的接口的方法

2.implements

用于聲明一個類實(shí)現(xiàn)了一個接口類，用法：class+類名+implements+接口名+{}

class Nets implements Clippers,Warriors{}//用implements關(guān)鍵字聲明實(shí)現(xiàn)了兩個接口類

注意：

一個普通類可以implements關(guān)鍵字聲明實(shí)現(xiàn)多個接口，但必須實(shí)現(xiàn)所有接口中的所有方法
抽象類實(shí)現(xiàn)接口，可以不用實(shí)現(xiàn)接口的方法（因?yàn)槌橄箢愔锌梢杂谐橄蠓椒ǎ?/li>

意義：可以用implements關(guān)鍵字聲明實(shí)現(xiàn)多個接口來實(shí)現(xiàn)類似多繼承

3.final

使用方法：

修飾類，使該類不能被繼承
修飾方法，使該方法不能被子類重寫（仍可以被繼承和調(diào)用）
修飾屬性，使該屬性的值不能被修改（使為常量）
修飾局部變量，使該變量不能被修改（局部常量）

使用細(xì)節(jié)：

final修飾的屬性在定義時必須賦初值，且不能修改，可以在以下位置賦初值

定義時（顯示初始化）
在構(gòu)造器中
在代碼塊中

static final：全局常量

如果final修飾的屬性是靜態(tài)（static）的，則不能在構(gòu)造器中賦初值，原因：靜態(tài)屬性要求在類加載時就有初值，而構(gòu)造器在創(chuàng)建對象時才被調(diào)用，所以可能導(dǎo)致調(diào)用靜態(tài)屬性時沒有創(chuàng)建對象而沒有給靜態(tài)屬性賦值
final不能修飾構(gòu)造方法，沒有意義
被final和static同時修飾的屬性在調(diào)用時不會導(dǎo)致類的加載，效率更高

4.native

基本介紹：

native用來修飾方法，被修飾的方法即成為了一個Java調(diào)用但非Java代碼實(shí)現(xiàn)的接口（本地方法） ，該方法在外部可以用任何語言去實(shí)現(xiàn)

"A native method is a java method whose implementation is provided by non-java code."

使用方法：

native修飾方法的位置必須在方法返回類型之前，和方法訪問修飾符位置沒有要求，如：public native int hashCode();

native細(xì)節(jié)：

native方法沒有方法體，也沒有{}
用native修飾后的方法不能用abstract修飾，因?yàn)?code>abstract指明該方法無實(shí)現(xiàn)體，而native方法是有實(shí)現(xiàn)體的，只是用非Java代碼實(shí)現(xiàn)的
native方法的返回類型可以是任意類型
如果一個有native方法的類被繼承，子類會繼承這個native方法，并且可以用java語言重寫

使用JNI(Java Native Interface) 與其他語言交互

JNI是Java平臺的一部分，它允許Java代碼和其他語言寫的代碼進(jìn)行交互。

使用步驟：

編寫帶有native方法的java類，生成.java文件
使用javac命令編譯生成.class文件
使用javah -jni 類名 生成.h文件
使用C/C++（或者其他編程語言）實(shí)現(xiàn)native方法，創(chuàng)建.cpp（或其他）文件
將C/C++編寫的文件創(chuàng)建動態(tài)鏈接庫（生成DLL文件）
native方法中使用System.loadLibrary()方法加載動態(tài)庫，將DLL文件名作為參數(shù)傳入，這時候再運(yùn)行.java程序即可實(shí)現(xiàn)對本地方法的調(diào)用

詳細(xì)步驟參考

native意義：

Java無法直接訪問到操作系統(tǒng)底層（如系統(tǒng)硬件），但通過使用native關(guān)鍵字修飾方法可以借用其他的語言來擴(kuò)展Java程序的功能，提高程序的效率

5.static

修飾變量，成為靜態(tài)變量或者類變量

使用方法：訪問修飾符+``static``+數(shù)據(jù)類型+變量名

注意事項(xiàng)：

靜態(tài)變量會被類的所有對象實(shí)例所共享，并且在類加載的時候就會初始化。
靜態(tài)變量的訪問方法（遵守相關(guān)訪問權(quán)限）：類名.靜態(tài)變量名 或者 對象名.靜態(tài)變量名

修飾方法，成為靜態(tài)方法或者類方法

使用方法：訪問修飾符+``static``+返回?cái)?shù)據(jù)類型+方法名+{}

注意事項(xiàng)：

調(diào)用方法（遵守相關(guān)訪問權(quán)限）：類名.靜態(tài)方法名 或者 對象名.靜態(tài)方法名
靜態(tài)方法和普通方法都是隨著類加載而加載，將結(jié)構(gòu)信息存儲在方法區(qū)
靜態(tài)方法中不允許使用this和super關(guān)鍵字
靜態(tài)方法中只能訪問靜態(tài)變量和靜態(tài)方法
普通方法可以訪問靜態(tài)成員和普通成員
修飾代碼塊，成為靜態(tài)代碼塊：

靜態(tài)代碼塊會在類加載時被加載，優(yōu)先級和靜態(tài)屬性一樣，有多個靜態(tài)代碼塊和靜態(tài)屬性時，初始化順序按定義順序執(zhí)行

好處：static關(guān)鍵字的使用，將類中的一些成員修飾成靜態(tài)的，這樣我們不需要創(chuàng)建該類的對象就可以調(diào)用該成員，大大提高了編程效率

6.transient

基本介紹：

transient用于修飾實(shí)現(xiàn)了Serilizable接口的類中的成員變量，在該類的實(shí)例對象進(jìn)行序列化處理時，被transient修飾的成員變量不會進(jìn)行序列化。

使用例子：

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;
import java.io.Serializable;
public class outStream {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\Cat.txt";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        oos.writeObject(new Cat("小花貓", 3));
        oos.close();
    }
}
class Cat implements Serializable {
    private String name;
    private int age; //沒有用transient修飾
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Car{" +

                "name='" + name + ''' +

                ", age=" + age +

                '}';
    }
}
public class inStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filePath = "d:\Cat.txt";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        System.out.println(ois.readObject());
        ois.close();
    }
}

可以在Cat.txt文件內(nèi)看到兩個成員變量都能被序列化，并且能被反序列化讀出信息。

當(dāng)小花貓覺得自己的年齡是隱私不想被讀出時，用transient修飾成員變量age:

......
private String name;
private transient int age; //使用transient修飾
......

這時在Cat.txt文件中可以看到只有name一個成員變量被序列化，反序列化后的成員變量age讀出的是int類型的默認(rèn)值，說明對于transient修飾的成員變量，在類的實(shí)例對象序列化的過程中會被忽略

transient細(xì)節(jié)

對transient修飾的成員變量可以理解為：不會參與進(jìn)行對象的序列化和反序列化過程，生存周期僅存于調(diào)用者的內(nèi)存而不會寫進(jìn)磁盤里進(jìn)行持久化
static修飾的成員變量（靜態(tài)變量）也是不可序列化的，不論被transient修飾與否

因?yàn)樾蛄谢潜４娴膶?shí)例對象的狀態(tài)，而靜態(tài)變量保存的是類的狀態(tài)

transient關(guān)鍵字只能修飾變量，不能修飾方法和類
transient關(guān)鍵字不能修飾局部變量
如transient關(guān)鍵字修飾的是自定義類的變量，則該類需要實(shí)現(xiàn)Serilizable接口

注意：

實(shí)現(xiàn)Serilizable接口的類的實(shí)例對象是自動進(jìn)行序列化的，如果序列化對象的類實(shí)現(xiàn)的是Externalizable接口，則序列化不會自動進(jìn)行，需要實(shí)現(xiàn)接口內(nèi)的方法指定要序列化的變量，這時與有無Transient修飾無關(guān)

7.synchronized

基本介紹：

關(guān)鍵字synchronized可以保證在同一時刻，只有一個線程可以執(zhí)行被synchronized修飾的方法或代碼塊

線程同步：

程序中多個線程都要使用同一個方法，而這個方法用synchronized進(jìn)行了修飾，在多個線程調(diào)用這個方法時必須遵循同步機(jī)制

線程同步機(jī)制：

當(dāng)一個線程使用synchronized修飾的方法時，其他線程想使用這個方法時就必須等待，直到這個線程使用完synchronized方法

synchronized使用方法：

普通同步方法：public synchronized void m () {}

public class syn implements Runnable {
    static int i = 0;
    public static void main(String[] args) throws InterruptedException {
        syn test = new syn();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
    }
    public synchronized void increase() {//被synchronized修飾的同步方法
        System.out.println(Thread.currentThread().getName() + "調(diào)用：" + i++);

    }
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            increase();
        }
    }
}

兩個線程同時調(diào)用一個對象的一個同步方法，由于一個對象只有一把鎖，所以只有一個線程能夠獲得該對象的鎖，另一個線程無法獲得，就不能調(diào)用該對象的synchronized方法，需要等對象被釋放后才能調(diào)用。

從運(yùn)行結(jié)果中可以證明線程1搶到了鎖，線程0必須等待線程1執(zhí)行完畢，否則不能訪問該同步方法。

靜態(tài)同步方法：public static synchronized void m () {}

public class syn implements Runnable {
    static int i = 0;
    public static void main(String[] args) throws InterruptedException {
        syn test = new syn();
        syn test1 = new syn();
        Thread t1 = new Thread(test);//傳入實(shí)例對象test
        Thread t2 = new Thread(test1);//傳入實(shí)例對象test1
        t1.start();
        t2.start();
    }
    public static synchronized void increase() {//同步靜態(tài)方法
        System.out.println(Thread.currentThread().getName() + "調(diào)用：" + i++);
    }
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            increase();
        }
    }
}

雖然兩個線程實(shí)例化了兩個不同的對象，但是synchronized修飾的是靜態(tài)方法，兩個線程仍然發(fā)生了互斥，因?yàn)?strong>靜態(tài)方法是依附與類的而不是對象，線程1先搶到了類的鎖，而線程0必須等待線程1執(zhí)行完畢釋放才能調(diào)用同步方法

同步代碼塊：synchronized(object) {}

public class syn implements Runnable {
    static Object object = new Object();//共享對象
    public static void main(String[] args) throws InterruptedException {
        syn test = new syn();
        syn test1 = new syn();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test1);
        t1.start();
        t2.start();

    }
    @Override
    public void run() {
        synchronized (object) {//代碼塊用靜態(tài)成員變量上鎖
            for (int j = 0; j < 100; j++) {
                System.out.println(Thread.currentThread().getName() + "調(diào)用第" + j + "次");
            }
        }
    }
}

同步代碼塊用兩個實(shí)例變量共享的靜態(tài)成員object對象來上鎖，雖然是兩個線程實(shí)例化兩個不同的對象，但是對整個syn類來說只有一個共享的object對象，所以只有一把鎖，每當(dāng)有線程來訪問代碼塊時需持有鎖，對象鎖被其他線程持有時需等待。線程1需要等線程0執(zhí)行完畢才能訪問同步代碼塊

同步的局限性：

由于同步的方法或代碼塊只能同一時間讓一個線程訪問，所以會導(dǎo)致程序的執(zhí)行效率降低

盡可能讓synchronized修飾的范圍最小化，來減少互斥對程序執(zhí)行帶來的影響

8.volatile

基本介紹：

volatile用于修飾變量，用volatile修飾的變量的值被某個線程修改時，會強(qiáng)制將修改的值立即寫入主存中，主存中的值更新會使得緩存中的該變量的值失效，對比與非volatile變量，可能會被其他線程讀取到更新前的值。

使用方法：

//現(xiàn)在有線程1和線程2同時執(zhí)行下列代碼
int i = 0;
i = i + 1;

執(zhí)行完畢后預(yù)想的結(jié)果是 i = 2;但是可能存在這樣一種情況：兩個線程先同時把i的值讀取到自己的工作內(nèi)存中，然后再分別執(zhí)行 i = i + 1 的操作，再將結(jié)果寫入主存，這樣兩個線程寫入的都是 i = 1，最終 i 的結(jié)果是 1 ，而不是 2

但如果 i 是 volatile 修飾的變量就會不一樣了，在一個線程修改 i的值后，會立即強(qiáng)制在主存中更新 i 的值，這樣會導(dǎo)致另一個線程的工作內(nèi)存中 i 的緩存值無效，所以另一個線程再次從主存中讀取新的 i 的值，這樣保證了i的值是最新并正確的

并發(fā)編程的三大概念：

原子性：執(zhí)行一個操作時，要么全部步驟執(zhí)行完畢且不被中斷，要么就不執(zhí)行

x = 100;//是原子性操作
y = x;//不是原子性操作，可分解為：1.先讀取x的值    2.將x的值寫入主存
x ++;//不是原子性操作，可分解為：1.讀取x的值    2.進(jìn)行加一操作    3.寫入主存

可見性：多個線程對同一個變量進(jìn)行操作時，一個線程修改了變量的值，其他線程能立即看到修改的值
有序性：程序執(zhí)行的順序按照代碼的先后順序執(zhí)行

volatile的意義

保證了不同線程對變量進(jìn)行修改時的可見性：因?yàn)閷τ?code>volatile變量來說，被修改后新值對其他線程來說是立即可見的
保證了有序性：volatile禁止了指令重排，它能保證在對volatile修飾的變量進(jìn)行操作時，之前的代碼語句已經(jīng)全部被執(zhí)行，并且后面的語句都未執(zhí)行，但是對其他語句的順序是不做保證的

注意： volatile不能保證原子性,因?yàn)椴荒鼙ＷC對變量的操作是原子性操作

9.this

在方法中修飾屬性，this理解為當(dāng)前對象，用來區(qū)別成員方法和形參，通常省略
修飾方法，this理解為當(dāng)前對象，通常省略；不能在靜態(tài)方法中使用
調(diào)用構(gòu)造器，在構(gòu)造器中使用this(形參列表)顯式調(diào)用指定的其他構(gòu)造器
- 必須在首行調(diào)用其他構(gòu)造器
- 一個構(gòu)造器中不能調(diào)用多個其他構(gòu)造器
- 不能在構(gòu)造器中調(diào)用遞歸調(diào)用，不能成環(huán)調(diào)用

10.super

super可以理解為：父類的

修飾屬性：去父類中找對應(yīng)屬性，用來區(qū)分子父類重名的屬性
修飾方法：調(diào)用重寫之前的方法
調(diào)用構(gòu)造器：使用super(形參列表)指定調(diào)用父類構(gòu)造器
- super(形參列表)必須放在構(gòu)造器的首行
- super(形參列表)和this(形參列表)只能二選一
- 在構(gòu)造器首行如果沒有顯式聲明super(形參列表)或this(形參列表)則默認(rèn)調(diào)用父類的空參構(gòu)造器super()（如果此時父類中沒有空參構(gòu)造器就會報錯）
不能在靜態(tài)方法中使用

當(dāng)一個方法和屬性被static屬性修飾時，這些方法和屬性是優(yōu)先于對象加載進(jìn)入內(nèi)存的，是隨著類的加載而加載的；this是當(dāng)前對象的引用，super是指父類的引用，當(dāng)靜態(tài)方法加載進(jìn)內(nèi)存進(jìn)棧時，如果在靜態(tài)方法中有this和super關(guān)鍵字時,this和super也被加載到了內(nèi)存，但是這個時候并沒有對象的引用，this和super沒有初始化，所有編譯會報錯。