Java面向對象之final、abstract抽象、和變量生命週期

final修飾符

final是最終、不可修改的意思，在Java中它可以修飾非抽象類，非抽象方法和變量。但是需要注意的是：構造方法不能使用final修飾，因爲構造方法不能夠被繼承。下面，咱們就來一一看看吧！

使用final關鍵字修飾類

先考慮下圖的代碼例子：

代碼顯示錯誤，無法從SuperClass繼承，編譯器提示刪除final關鍵字；刪除final關鍵字後，代碼正確無誤。

由此可得出：final修飾的類:，表示最終的類,，即該類不能再有子類，不能再被繼承。只要滿足以下條件就可以考慮把一個類設計成final類：

在設計之初就考慮不進入繼承體系的類。
出於安全考慮，類的實現細節不允許被拓展和修改。比如：基本數據類型的包裝類就是一個典型的例子。
該類不會再被拓展。

java裏final修飾的類有很多，比如八大基本數據類型的包裝類（Byte，Character、Short、Integer、Long、Float、Double、Boolean）和String等。

// Byte
public final class Byte extends Number implements Comparable<Byte> { }
// Character
public final class Character implements java.io.Serializable, Comparable<Character> { }
// Short
public final class Short extends Number implements Comparable<Short> { }
// Integer
public final class Integer extends Number implements Comparable<Integer> { }
// Long
public final class Long extends Number implements Comparable<Long> { }
// Float
public final class Float extends Number implements Comparable<Float> { }
// Double
public final class Double extends Number implements Comparable<Double> { }
// Boolean
public final class Boolean implements java.io.Serializable, Comparable<Boolean> { }
// String 
public final class String implements java.io.Serializable, Comparable<String>, CharSequence { }

使用final關鍵字修飾方法

如果用final關鍵字修飾方法呢？先考慮以下的代碼：

若是用final修飾方法，繼承該方法時會報編譯錯誤；刪除該關鍵字後，doWork()可被繼承，代碼編譯通過；final修飾的方法爲最終的方法，該方法不能被子類覆蓋，故也不能使用方法重寫。那麼什麼樣的情況下方法需要使用final修飾呢？

在父類中提供了統一的算法骨架，不允許子類通過方法覆蓋來修改其實現細節，此時使用final修飾。比如在模板方法設計模式中。
在構造器中調用的方法(初始化方法)，此時一般使用final修飾。這也是構造器不能被繼承的原因。

注意: final修飾的方法了，子類可以調用，但是不能覆蓋（重寫）。

類常量：使用final關鍵字修飾的字段

常量分類：

字面值常量(直接給出的數據值/直接量)；比如：整數常量1，2，3，小數常量3.14，布爾常量false，true等。
final關鍵字修飾的常量。

通過上述代碼，不難看出，final關鍵字修飾的字段無法被修改。通常開發中，我們建議final修飾的常量名用大寫字母表示，多個單詞之間使用下劃線（_）連接：如：

public static final String USER_NAME = "用戶名";

且在Java中多個修飾符之間是沒有先後關係的，以下的三種修飾符排列順序都是ok的：

public static final 
或者 
public final static 
亦或者 
final static public

final修飾的變量是最終的變量，常量；該變量只能賦值一次，也只能在聲明時被初始化一次，不能被修改。在使用時需注意：

final變量必須顯式地指定初始值，系統不會爲final字段初始化。
final變量一旦賦予初始值，就不能再被重新賦值。
常量名規範：常量名符合標識符，單詞全部使用大寫字母，如果是多個單詞組成，多個單詞之間使用下劃線（_）連接。全局靜態常量: public static final 修飾的變量，直接使用類名調用即可。

final修飾的引用類型變量到底表示引用的地址不能改變，還是其存儲的數據不能改變

修飾基本類型變量：表示該變量的值不能改變，即不能用“=”號重新賦值。
修飾引用類型變量：表示該變量的引用的地址不能變，而不是其存儲的數據內容不能變，其存儲的數據內容是可以被修改的。

什麼時候使用常量：

當在程序中，多個地方使用到共同的數據，而且該數據不會改變，此時可以將其定義全局的常量；
一般的，在開發中我們會專門定義一個常量類，專門用來存儲常量數據。

爲何要使用final修飾符呢？在繼承關係中最大弊端就是會破壞封裝，子類能訪問父類的實現細節,，而且可以通過方法重寫（方法覆蓋）的方式修改方法的實現細節。且 final還是是唯一可以修飾局部變量的修飾符。

抽象方法和抽象類

考慮如下的案例：求圓(Circle)、矩形(rectangle)的面積

上述代碼設計是存在問題的：

每一個圖形都有面積。但是不同圖形求面積的算法是不一樣的，也就是說，每一個圖形的子類都必須去重寫getArea方法，如果不覆蓋，應該編譯報錯，無法計算其面積。
在圖形類（Graph）中定義了getArea方法，該方法不應該存在方法體，因爲不同圖形子類求面積算法不一樣，父類是不存在計算面積的方法的，故無法提供方法體。

案例：求圓(Circle)、矩形(rectangle)的面積引入抽象的設計

抽象方法

使用abstract關鍵字修飾且沒有方法體的方法，稱爲抽象方法。其特點是：

使用抽象abstract關鍵字修飾，方法沒有方法體，留給子類去實現/覆蓋其實現細節。
抽象方法修飾符不能是private 和 final以及static，因爲抽象方法是要被重寫的；
抽象方法必須定義在抽象類或接口中。接口中的方法魔人都是使用public abstract 修飾的；

一般會把abstract寫在方法修飾符最前面，一看就知道是抽象方法；當然如果不這樣寫也沒錯。

抽象類

使用abstract關鍵字修飾的類，稱爲抽象類。其特點是：

抽象類不能創建實例，也就是不能使用new創建一個抽象類對象，即使創建出抽象類對象，調用了抽象方法，也無法實現功能，因爲抽象方法沒有方法體。
抽象類可以不包含抽象方法，倘若包含，哪怕是一個，該類也必須作爲抽象類，抽象類可以包含普通方法，可以給子類調用；抽象類是有構造器的，且其子類構造器必須先調用父類構造器。
若子類沒有實現/覆蓋父類所有的抽象方法，那麼子類也得作爲抽象類(抽象派生類)。
構造方法不能都定義成私有的，否則不能有子類，因爲子類構造器無法調用其構造器(創建子類對象前先調用父類構造方法)。
抽象類不能使用final修飾，因爲其必須有子類重寫其抽象方法，抽象方法才能得以實現。
抽象類是不完整的類，需作爲父類，由子類實現其功能細節，功能才能得以實現。

抽象類在命名時，一般使用Abstract作爲前綴，讓調用者見名知義，看類名就知道其是抽象類。

抽象類中可以不存在抽象方法，這樣做雖然沒有太大的意義，但是可以防止外界創建其對象，所以我們會發現有些工具類沒有抽象方法，但卻是使用abstract來修飾類的。

普通類有的成員(方法、字段、構造器)，抽象類本質上也是一個類，故其都有。抽象類不能創建對象，但抽象類中是可以包含普通方法的。

變量生命週期

程序中的變量是用來存儲數據的，其又分爲常量和變量兩種，關於變量的詳情可以查看我的另一篇文章：[JAVA] Java 變量、表達式和數據類型詳解。定義變量的語法：

數據類型 變量名 = 值;

變量根據在類中定義位置的不同，分成兩大類：

成員變量：全局變量/字段(Field)，是定義在類中，方法作用域外的變量；可以先使用後定義（使用在前，定義在後）。

類成員變量：使用static修飾的字段。
實例成員變量：也稱爲對象變量，即沒有使用static修飾的字段。

**局部變量：**變量除了成員變量，其他都是局部變量，主要體現在方法內，方法參數，代碼塊內；局部變量必須先定義而後才能使用。

方法內部的變量。
方法的形參。
代碼塊中的變量，一對{}中的變量。

變量的初始值：變量只有在初始化後纔會在內存中開闢空間。

成員變量：默認是有初始值的。

局部變量：沒有初始值。所以必須先初始化才能使用，而且其初始化是在方法執行開始時才進行的。

變量的作用域：變量根據定義的位置不同，也決定了各自的作用域是不同的，最直觀的就是看變量所在的那對花括號{}，也就是離得最近的那對{}。成員變量的作用域在整個類中都有效。局部變量的作用域在開始定義的位置開始，到緊跟着結束的花括號爲止。

變量的生命週期

變量的作用域指的是變量的可使用的範圍，只有在這個範圍內，程序代碼才能訪問它。當一個變量被定義時，它的作用域就確定了。變量的作用域決定了變量的生命週期，作用域不同，生命週期就不一樣。

變量的生命週期指的是一個變量被創建並分配內存空間開始，到該變量被銷燬並清除其所佔內存空間的過程。

package 關鍵字

在開發中，一個項目會有成百上千個Java文件，如果所有的Java文件都在一個目錄中，那麼管理起來就會很痛苦，很難想象這樣的項目會是什麼樣子。在Java中，引入了稱之爲包(package)的概念。即：關鍵字：package ，專門用來給當前Java文件設置包名（也就是命名空間）。其語法格式如下：

package 包名.子包名.子包名;

必須把package語句作爲Java文件中的第一行代碼，在所有代碼之前。

package 語句和java編譯

在編譯java文件時的編譯命令爲:

javac -d . Hello.java

如果此時Hello.java文件中沒有使用package語句，表示在當前目錄中生成字節碼文件。運行時也不需要考慮包名。

如果此時Hello.java文件中使用了package語句，此時表示在當前目錄中先生成包名目錄，再在包名目錄中生成字節碼文件。運行命令如下：

 java 包名.類名;

package命名：

a.自定義的包名不能以java開頭，會和java語言基礎類庫衝突。
b.包名必須遵循標識符規範/全部小寫。
c.企業開發中，包名由公司域名倒寫來決定。
d.如果域名是以數字開頭的，不符合規範，可以考慮使用下劃線_開頭；但是在Android中，如果package中使用了_，則不能部署到模擬器上。此時，我們也可以使用一個字母來代替_。

package命名格式：

package 域名倒寫.模塊名.組件名;

1.package下的類名：

類的簡單名稱: PackageDemo.java
類的全限定名稱: com._520.hello.PackageDemo.java

2.建議：先定義package名稱，再在定義的package內定義類。

import 關鍵字

當A類和B類不在同一個包中，若A類需要使用到B類中的功能，此時就得讓A類中去引入B類。使用import語句，把某個包下的類導入到當前類中。

語法格式:    import 需要導入類的全限定名;

引入後在當前類中，只需要使用類的簡單名稱即可訪問。

如果我們需要引入包中的多個類，我們還得使用多個import語句，要寫很多次；此時可以使用通配符(*)。

import 類的全限定名; 只能導入某一個類。
import 包名.子包名.*; 表示會引入該包下的所有的在當前文件中使用到的類。
import java.util.*; 表示導入java.util包下的所有類。

注意：編譯器會默認導入java.lang包下的類，但是並不會導入java.lang的子包下的類。比如:java.lang.reflect.Method類，此時我們也得使用import java.lang.reflect.Method；來導入Method類。

靜態import

**靜態import，**靜態導入，是指將通過import static導入其他類的靜態成員。以下代碼實例：

package demo.importdir;
public class StaticDemo {	
    public static final int COUNT = 10;
}

package demo.dir;
import static demo.importdir.StaticDemo.COUNT;
public class StaticImportDemo {	
    public static void main(String[] args) {	
        System.out.println(COUNT);	
    }
}

然後我們對StaticImportDemo反編譯，觀察JVM是如何處理靜態導入的：

import java.io.PrintStream;
import demo.importdir.StaticDemo;
public class StaticImportDemo{	
    public StaticImportDemo() {	}	
    public static void main(String args[]) {	
        System.out.println(StaticDemo.COUNT);	
    }
}

通過上述的反編譯代碼，不難發現，其實所謂的靜態導入也是一個語法糖/編譯器級別的新特性，其實在底層也是類名.靜態成員去訪問的。

所以在企業項目開始中不建議使用靜態導入，容易引起字段名，方法名混淆，不利於項目維護。

字段不存在多態

通過對象調用字段，在編譯時期就已經決定了調用哪一塊內存空間的數據。所以字段不存在覆蓋的概念，也就是字段不會有多態特徵，在運行時期體現的也會是子類特徵。

public class FieldDemo {		
    public static void main(String[] args) {	
        SubClass subClass = new SubClass();	
        System.out.println(subClass.name);	
    }
}

class SuperClass {	
    protected String name = "SuperClass.name";
}

class SubClass {	
    protected String name= "SubClass.name";
}

// 運行結果：SubClass.name

通過運行上述代碼，不難發現，當子類和父類存在相同的字段的時候，無論修飾符是什麼(即使是private)，都會在各自的內存空間中存儲數據，字段並沒有體現出多態；

其實通過方法重寫字面意思也能發現其是針對方法的。所以只有方法纔有覆蓋的概念，而字段並不會被覆蓋。

代碼塊

什麼是代碼塊：在類或者在方法中，直接使用**"{}"**括起來的一段代碼，表示一塊代碼區域，我們將其稱爲代碼塊。代碼塊裏變量屬於局部變量，只在自己所在的作用域(所在的{})內有效。根據代碼塊定義的位置的不同,我們又分成三種形式：

1.局部代碼塊：直接定義在方法內部的代碼塊；一般不會直接使用局部代碼塊，而是會結合if，while，for，try等關鍵字配合使用，還有匿名內部類，表示一塊代碼區域。示例如下：

if (true) {	......    }

2.初始化代碼塊(構造代碼塊)：定義在類中，每次創建對象的時候都會執行，並且是在構造器調用之前先執行本類中的初始化代碼塊。但其實JVM在處理初始化代碼塊時是將其移動到構造器中的最前面，從而達到先執行初始化代碼塊，再執行構造器的功能。

在實際開發中，很少使用初始化代碼塊；初始化操作會在構造器中進行，如果做初始化操作的代碼比較複雜，可以另外定義一個方法做初始化操作，然後再在構造器中調用。

3.靜態代碼塊：使用static修飾的初始化代碼塊。格式如下：

class StaticDemo {		
    static {    	......    }    
}

靜態代碼塊會在主方法（main方法）執行之前執行，而且只執行一次。在Java中，main方法是程序的入口，靜態代碼塊優先於main方法執行；是因爲靜態成員是隨着字節碼的加載而進入JVM中的，但此時此時main方法還沒執行，因爲main方法需要JVM調用方能執行。

以下是一個代碼塊的示例：

public class CodeBlockDemo {		
    {		
        System.out.println("執行初始化代碼塊");	
    }		
    
    public CodeBlockDemo() {		
        System.out.println("執行無參構造器");	
    }		
    
    static {		
        System.out.println("執行靜態代碼塊");	
    }		
    
    public static void main(String[] args) {		
        new CodeBlockDemo();		
        new CodeBlockDemo();		
        new CodeBlockDemo();	
    }
}

其運行結果爲：

執行靜態代碼塊
執行初始化代碼塊
執行無參構造器
執行初始化代碼塊
執行無參構造器
執行初始化代碼
塊執行無參構造器

不難發現，調用順序依次爲：靜態代碼塊–》初始化代碼塊–》構造器，且靜態代碼塊只執行一次。然後再對上述示例代碼做反編譯：

import java.io.PrintStream;
public class CodeBlockDemo{	
    public CodeBlockDemo()	{		
        System.out.println("執行初始化代碼塊");		
        System.out.println("執行無參構造器");	
    }	
    
    public static void main(String args[])	{		
        new CodeBlockDemo();		
        new CodeBlockDemo();		
        new CodeBlockDemo();	
    }	
    
    static 	{		
        System.out.println("執行靜態代碼塊");	
    }
    
}

通過反編譯結果，發現JVM在處理初始化代碼塊時是將初始化代碼塊的代碼移動到構造器中的最前面，從而達到先執行初始化代碼塊，再執行構造器的功能。

完結。老夫雖不正經，但老夫一身的才華

[JAVA] Java面向對象之final、abstract抽象、和變量生命週期

final修飾符

抽象方法和抽象類

變量生命週期

package 關鍵字

import 關鍵字

字段不存在多態

代碼塊

編程語言之美，在動、靜之態，在強、弱之間，分解釋、編譯之道

「JAVA」線程生命週期分階段詳解，哲學家們深感死鎖難解

通過實現生產者、消費者案例再次實踐Java 多線程

[JAVA] Java switch的使用細節

[JAVA] 初識Java 和 Java的跨平臺實現原理

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結