怎麼一本正經地秀技
前言
修飾符怎麼使用也是Java基礎中比較重要的知識點，徹底理解了之後，後面學習更高深的東西才能得心應手。今天，以修飾符中比較常見的final為切入點，來談談final的使用的奇淫技巧以及一些相關的知識點。學廢了記得三連哦。
初始化塊
在final的運用中，經常和初始化塊和構造器結合起來一起使用。上篇文章已經介紹完什麼是構造器，那麼現在先來談談什麼是初始化塊。
Java會使用構造器對對象進行初始化操作，在使用的構造器的時候需要完成初始化整個Java對象的狀態的功能，然後再將整個完整的Java對象返回給程序使用。那麼，在Java中，有一個與構造器功能類似的東西，就是初始化塊，它能夠對Java對象實現初始化操作。
在Java中，一個類中可以有多個初始化塊，相同類型的初始化塊的執行順序是有要求的，先定義的先執行（前面的先執行），後面定義的後執行。
初始化塊的語法其實很簡單了，就是:
修飾符 {
//初始化塊中的可執行代碼塊
...
...
...
}
那初始化塊的分類也很簡單，就分為靜態初始化塊和非靜態初始化塊兩種,其中非靜態初始化塊也叫做普通初始化塊
非靜態初始化塊
在生成每個對象的時候都會執行一次，可以初始化類的實例變量。非靜態初始化塊會在類的構造器之前執行
先來看一段代碼
`public class CodeVald {
` int a = 6;
`//第一個初始化塊
{
int a = 3;
if (this.a > 4) {
System.out.println("codevald的初始化塊: 成員變量a的值大於4");
}
System.out.println("codevald的初始化塊");
}
//第二個初始化塊
{
System.out.println("codevald的第二個初始化塊");
}
//定義一個無參數的構造器
public CodeVald() {
System.out.println("codevald的無參數構造器");
}
public static void main(String[] args) {
new CodeVald();
}
}
}
上面的代碼定義了兩個普通初始化塊和一個構造器，那麼執行的順序也很簡單了，先定義的初始化塊先執行，然後執行後定義的初始化塊，接着執行構造器的內容
來看下編譯運行結果
靜態初始化塊
使用static定義，當類裝載到系統只會執行一次。如果在靜態初始化塊中想初始化變量的話，就只能初始化類變量了，即是由static修飾的數據成員。
來看一個靜態初始化塊、普通初始化塊和構造器結合的例子：
public class JingTai_CodeBlock {
public static void main(String[] args) {
new C();
new C();
}
}
//定義第一個類A，這是父類
class A {
static {
System.out.println("A的靜態初始化塊");
}
{
System.out.println("A的普通初始化塊");
}
public A() {
System.out.println("A的無參數構造器");
}
}
//定義一個子類B
class B extends A {
static {
System.out.println("B的靜態初始化塊");
}
{
System.out.println("B的普通初始化塊");
}
public B() {
System.out.println("B的無參數構造器");
}
public B(String message) {
this();
//通過this()調用無參數的構造器（即重載的構造器）
System.out.println("B的帶參數構造器，傳入的信息為: " + message);
}
}
//定義一個子類C
class C extends B {
static {
System.out.println("C的靜態初始化塊");
}
{
System.out.println("C的普通初始化塊");
}
public C() {
//通過super調用父類中帶參數的構造器
super("codevald");
System.out.println("C的構造器");
}
}
上述代碼定義了A、B、C三個類，他們都提供了靜態初始化塊和普通初始化塊，並且在類B中使用this()調用了重載構造器，在C中使用super()顯式地調用了其父類指定的構造器，接着在main()函數調用了兩次new C(),創建兩個C對象。
那麼來猜下會輸出什麼結果
先思考五分鐘哦
現在來解釋一下，這裡定義了靜態初始化塊，那麼會在類地初始化階段執行靜態初始化塊，而不是創建對象的時候才執行，所以靜態初始化塊總是比普通初始化塊先執行，接着是構造器
但是系統在類初始化階段執行靜態初始化塊的時候，不僅會執行本類的靜態初始化塊，還會一直上溯到java.lang.Object類（所有對象的父類），如果它包含靜態初始化塊，先執行java.lang.Object類的靜態初始化塊，然後執行其父類的靜態初始化塊…執行完最後才執行該類的靜態初始化塊，經過上述過程才能完成該類的初始化過程。
第一次創建C對象的時候，會先運行靜態初始化塊的內容，但是會先上溯到頂級父類的靜態初始化塊，所以會先輸出A的靜態初始化塊，接着才是B的靜態初始化塊，最後是C的靜態初始化塊。
執行完靜態初始化塊，一樣先執行頂級父類的普通初始化塊，即輸出A的普通初始化塊，接着執行頂級父類的構造器代碼，即輸出A的無參數構造器。然後輸出父類的普通初始化塊，接着是構造器，所以輸出B的普通初始化塊,因為C的構造器調用的是帶參數的父類構造器，所以B中會調用帶參數的構造器B，所以會輸出B的無參數構造器，B的帶參數構造器，傳入的信息為: codevald，接着執行C的普通初始化塊的代碼，即輸出C的普通初始化塊，然後是構造器的代碼，即C的構造器
第二次創建實例C的時候，因為類C已經在虛擬機中存在，所以無需再初始化C類了，所以靜態初始化塊的代碼不再執行，而是重複地執行靜態後面的代碼。
final修飾符
final可以用來修飾類、變量和方法，通過final修飾以後，被修飾的類、方法和變量就表示不可改變的狀態。
修飾成員變量
成員變量是隨着類的初始化或者對象初始化而初始化的。當初始化的時候，就會為類的類屬性分配內存，並設置一個默認值；當創建對象時，就會為對象的實例屬性分配內存，並分配默認值。一般來說，都是在普通初始化塊、靜態初始化塊、構造器中區指定初始值的。
那麼，final修飾的屬性，在哪裡聲明初始值是有一定的規則的，具體如下：
-
修飾類屬性時：可在靜態靜態初始化塊中聲明該屬性的初始值
-
修飾實例屬性時： 可在普通初始化塊中或者構造器中指定初始值
修飾局部變量
在初始化局部變量的時候，局部變量必須由程序員顯式地去初始化。但是使用final修飾地局部變臉既可以指定默認值，也可以不指定默認值。假如在定義修飾的局部變量時沒有指定默認值，則可以在後面代碼中對該變量賦予一個指定的初始值。
那麼，現在就final和初始化塊結合起來，來看一段代碼
public class UseFinal {
//定義成員變量時指定默認值
final String author = "codevald";
final String str;
final int a;
final static double d;
//初始化塊，可對沒有指定默認值的實例屬性指定初始值
{
str = "Hello";
//由於定義author時已經制定了默認值，因此不能為author重新賦值，下列語句會導致編譯錯誤
//author = "CodeVald"
}
static {
//在靜態初始化塊中為類屬性指定初始值
d = 2.1;
}
public UseFinal() {
a = 21;
}
public void useFinal() {
//普通方法不能為fina修飾的成員變量指定初始化值
//d = 2.1;
}
public static void main(String[] args) {
UseFinal useFinal = new UseFinal();
System.out.println(useFinal.author);
System.out.println(useFinal.str);
System.out.println(useFinal.a);
System.out.println(useFinal.d);
}
}
運行結果也很容易就出來了，但是，這裡要注意一點的是，普通方法不能為final修飾的變量賦值，會出現編譯錯誤的問題。
來看下運行結果
總結一下，final成員變量（包括實例成員和類成員）必須由程序員顯式地初始化，系統不會對final成員進行隱式初始化。如果想在初始化塊、構造器中對final的成員變量進行初始化，那麼一定要在初始化之前就訪問該成員變量的值。
final方法
在Java中，經常用final修飾那些不希望被重寫的方法。所以，如果我們不希望子類重寫父類的某個方法，就可以使用final修飾該方法。我們有時候會希望獲取一個Object對象，所用的getClass()方法就是一個final方法，因為它的設計者不希望該方法被重寫，就用final將該方法密封起來。
final修飾的方法只是不能重寫，但是可以重載。
public class Incorrect {
public final void test() {
}
}
class Sub extends Incorrect {
//下面的寫法將導致編譯錯誤，不能重寫final修飾的方法
@Override
public void test() {
}
}
編譯程序，執行結果如下
在Java程序中，對於private修飾的方法來說，它只在當前類中可見，所以其子類無法訪問該方法。所以，如果在子類中定義了一個與父類private方法有相同方法名、形參列表和返回值類型的方法，這不是方法重寫，只是重新定義了一個新方法。不會出現編譯錯誤的問題
例如下面的代碼在子類中重寫父類的 private final方法
public class Invaild {
private final void test() {
}
}
class Sub extends Invaild {
public void test() {}
}
在匿名內部類中，很多時候也會用到final的地方，現在先來系統地談談內部類是啥東西。
內部類
內部類指的是在外部類的內部再定義一個類，內部類作為外部類的一個成員，是依附在外部類而存在的。內部類可以是靜態的，非靜態的，可以使用protected和private來修飾，而外部類只能使用public和默認的包訪問權限。Java中的內部類主要有成員內部類、靜態內部類、局部內部類和匿名內部類。
那麼內部類有什麼使用的價值呢？
Java是從JDK1.1開始引入了內部類，內部類的主要作用如下：
- 內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類
- 內部類的成員可以直接訪問外部類的私有數據，因為內部類被當成了外部類的成員，同一個類中的成員之間是可以互相訪問的。但外部類不能訪問內部類的實現細節，譬如屬性。
- 匿名內部類適用於那些創建僅使用一次的類
內部類是一個編譯時的概念，一旦編譯成功，外部類和內部類就成為完全不同的類，即生成兩個類的編譯文件，分別是outer.class和outer$inner.class(假如外部類是outer，內部類是inner)。
成員內部類
在大多數的情況下，內部類作為成員內部類來定義。成員內部類是一種與屬性、方法、構造器和初始化塊相似的類成員。局部內部類和匿名內部類都不是類成員。Java中的成員內部類分別是靜態內部類和非靜態內部類。使用static修飾的就是靜態內部類，沒有使用static修飾的成員內部類就是非靜態內部類.
非靜態內部類
來看一段代碼
public class FeiJingTai {
private String area;
//重載構造器
public FeiJingTai() {
}
public FeiJingTai(String area) {
this.area = area;
}
//定義內部類
private class FeiJingTaiInner {
//內部類的屬性
private String name;
private String wechat;
public FeiJingTaiInner(String name,String wechat) {
this.name = name;
this.wechat = wechat;
}
//內部方法
public void info() {
System.out.println("CodeVald的作者是 " + name + ",微信號是 " + wechat);
System.out.println("所屬地區是 " + area);
}
}
//外部類測試方法
public void test() {
FeiJingTaiInner a = new FeiJingTaiInner("codevald","valdcode");
a.info();
}
public static void main(String[] args) {
FeiJingTai a = new FeiJingTai("廣東廣州");
a.test();
}
}
在上面的代碼中，可以看到在非靜態內部類中可以直接訪問外部類的私有成員，所以其實就是在類FeiJingTaiInner的方法內直接訪問外部類的私有屬性。這是因為在類FeiJingTaiInner內部類對象中保存了一個它儲存的外部類對象的引用[當調用非靜態內部類的實例方法時，必須有一個非靜態內部類實例，而非靜態內部類實例必須寄居在外部類實例里]
編譯程序，將會看到在文件路徑下生成了兩個類文件一個是FeiJingTai.class，另一個是FeiJingTai$FeiJingTaiInner.class
執行後的結果
再來看一段代碼
class MemberInner {// 定義類 MemberInner，這是一個外部類
private String name = "codevald";
public void execute() {
// 在外部類中創建成員內部類
InnerClass innerClass = this.new InnerClass();
}
/** 成員內部類 */
public class InnerClass {
// 內部類可以創建與外部類同名的成員變量
private String name = "codevald";
public void execute() {
System.out.println(this.name);
// 在內部類中使用外部類成員變量的方法
System.out.println(MemberInner.this.name);
}
}
public static void main(String[] args) {
MemberInner.InnerClass innerClass = new MemberInner().new InnerClass();
innerClass.execute();
}
}
在上面的代碼中，使用了兩種方式創建內部類對象，一種是用外部引用的方式，另一種是調用方法創建，在execute()方法中,this代表的是創建在堆中的外部對象，而在內部類，使用this是分別引用內部類中的屬性和外部類中的屬性。
看下編譯運行結果
靜態內部類
如果不需要內部類對象與外部類對象之間有聯繫，則可以將內部類聲明為static。在非靜態內部類中，內部類對象通常會保存了一個指向外部類的引用，如果內部類是static時就不用了，非靜態內部類通常也稱為嵌套類。
嵌套類要注意以下兩點:
- 要創建嵌套類的對象，不需要外部類的對象
- 不能直接從嵌套類的對象中訪問非靜態的外部類對象
從一段具體的代碼來分析一下
public class JingTai {
private String name_1 = "codevald";
private static String name_2 = "codevald";
static class JingTaiInner {
private static String name;
public static void main(String[] args) {
//可以輸出外部類的靜態類成員變量
System.out.println(name_2);
//System.out.println(name_1);
//不可以直接輸出外部類的非靜態類成員變量
//得生成對象，再用對象引用去訪問
JingTai a = new JingTai();
System.out.println(a.name_1);
}
}
public static void main(String[] args) {
JingTai.JingTaiInner a = new JingTai.JingTaiInner();
}
}
運行結果
上面的代碼中，在內部類有輸出語句，然後再外部類創建內部類，但是在內部類中，只能直接訪問外部類的靜態屬性，要訪問外部類的非靜態屬性得生成對象，再用對象的引用去訪問。
所以，生成一個靜態內部類不需要外部類成員，這是靜態內部類和成員內部類的區別。靜態內部類可以直接[Outer.Inner inner = new Outer.Inner();],而不需要通過外部類來完成。這樣子實際上靜態內部類就是一個獨立的類。
局部內部類
在方法中定義的內部類就是局部內部類。與局部變量相似的是，局部內部類可以訪問當前代碼中的常量和外部類的所有成員。在Java中，和局部變量一樣，不能將局部內部類定義為public、private、protected、和static類型，並且在定義方法時，只能在方法中聲明final類型的變量。
看一段代碼
public class LocalInner {
public static void main(String[] args) {
class InnerClass {
String name;
}
class InnerSub extends InnerClass {
String des;
}
//創建局部內部類的對象
InnerSub is = new InnerSub();
is.name = "codevald";
is.des = "想起來了嗎？看完就想起來了";
System.out.println("author: " + is.name + "\n" + "subject: " + is.des);
}
}
編譯運行結果
匿名類
在實際的項目動手過程，經常會看到一個很奇怪的寫法，直接在代碼中隨機用new新節一個對象，然後在new；裏面直接簡單粗暴的加入要執行的代碼，這就是匿名類。好處就是代碼簡潔、緊湊，不會出現一大段繁雜的類定義代碼。
在Java程序中，因為匿名類沒有名字，所以它的創建方式初學的時候看起來會很懵逼，創建的格式如下:
new 類/接口名(參數列表) [實現接口()]{
//匿名內部類的類體部分
}
{…}中可以定義變量的名稱、方法，它跟普通的類一樣。
因為Java程序中的匿名類沒有名稱，所以不能在其他地方引用，也不能實例化，只能使用一次，而且裏面不能有構造器。
來看一段代碼
先定義一個抽象父類
public abstract class Author {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract int article();
}
編寫測試類進行測試，在類中,test()方法接收一個Author類型的參數，同時要先實現類才能new新的類實例，在方法中直接使用匿名內部類新建一個Author實例。
public class NiMing {
public void test(Author author) {
System.out.println("這是" + author.getName() + "的第" + author.article() + "篇原創作品.");
}
public static void main(String[] args) {
NiMing test = new NiMing();
test.test(new Author() {
//使用匿名內部類來創建一個Author實例
@Override
public int article() {
return 2;
}
@Override
public String getName() {
return "codevald";
}
});
}
}
編譯運行結果
終於講完了，現在要進入主題了，匿名內部類中什麼時候會用到final呢？
使用final形參
在Java中，當我們需要給匿名內部類傳遞參數的時候，並且如果在內部類中使用該形參的時候，這個形參則必須由final修飾的。即該匿名內部類所在方法的形參必須加上final修飾符。
編寫一段代碼
public class NiMing_Final {
public static void main(String[] args) {
NiMing_Final niming = new NiMing_Final();
Inner inner = niming.getInner("codevald",true);
System.out.println("這是" + inner.getName() + "的第" + inner.article() + "篇原創作品");
}
public Inner getInner(final String name,boolean isOriginal) {
return new Inner() {
private String nameStr = name;
private int article;
{
//實例初始化
if (isOriginal) {
article = 2;
} else {
article = 0;
}
}
@Override
public String getName() {
return nameStr;
}
@Override
public int article() {
return article;
}
};
}
}
interface Inner {
String getName();
int article();
}
這裡通過實例初始化實現類似構造器的功能
來看下運行結果
枚舉類
在枚舉類中，使用final的頻率是最頻繁的。什麼是枚舉類？在大多數情況下，我們要實例化的類對象是有限的而且固定的，例如季節，這種實力數量有限而且固定的類，在Java中被稱為枚舉類。
我們先來做個有意思的事情，自己模擬實現一個枚舉類，在實現枚舉類的時候，有以下幾個步驟:
- 通過private將構造器隱藏起來
- 把此類需要用到的所有實例都用public static final修飾的形式保存起來
- 提供一些靜態方法允許其他程序根據特定參數獲取與之匹配的實例
那麼可以定義一個Season類，在裏面分別為4個季節定義4個對象，這樣類Season就定義為了一個枚舉類。
public class Season {
//將Season定義成不可變得，將其屬性定義成final
private final String name;
private final String description;
public static final Season SPRING = new Season("春天","綠肥紅瘦");
public static final Season SUMMER = new Season("夏天","驕陽似火");
public static final Season FALL = new Season("秋天","天高雲淡");
public static final Season WINTER = new Season("冬天","惟余莽莽");
//構造器一定要定義為private屬性
private Season(String name,String description) {
this.name = name;
this.description = description;
}
//也可以通過getSeason()獲取枚舉常量
public static final Season getSeason(int seasonValue) {
switch(seasonValue) {
case 1:
return SPRING;
case 2:
return SUMMER;
case 3:
return FALL;
case 4:
return WINTER;
default:
return null;
}
}
public String getName() {
return this.name;
}
public String getDescription() {
return description;
}
}
類Season就成為了一個不可變的類，此類包含了4個static final常量的屬性，也就代表了該類所能創建的對象。其他程序需要用到Season對象時，可以用Season.SPRING方式或者getSeason()靜態方法獲得。
編寫測試類
public class TestSeason {
public TestSeason(Season s) {
System.out.println(s.getName() + "，是一個" + s.getDescription() + "的季節");
}
public static void main(String[] args) {
new TestSeason(Season.SPRING);
new TestSeason(Season.SUMMER);
new TestSeason(Season.FALL);
new TestSeason(Season.WINTER);
}
}
運行結果
自己模擬完枚舉類後，會發現枚舉類其實就是在類編譯的時候，就生成了相對應的靜態常量，並且構造器是對用戶透明的，它會自己進行初始化，我們只需要關心我們需要獲取什麼樣的枚舉對象就可以了。
枚舉類型是從JDK1.5開始引入的，Java引入了一個新的關鍵字enum來定義枚舉類。這個enum所定義的類實際上都是繼承自類庫中Enum(java.lang.Enum)的子類,它繼承了Enum中許多有用的方法。
來繼續看一段代碼
public enum Color {
RED(255,0,0),BLUE(0,0,255),BLACK(0,0,0),YELLOW(255,255,0),GREEN(0,255,0);
private Color(int redValue,int greenValue,int blueValue) {
this.redValue = redValue;
this.greenValue = greenValue;
this.blueValue = blueValue;
}
@Override
public String toString() {
//覆蓋了父類Enum的toString()方法
return super.toString() + "(" + redValue + "," + greenValue + "," + blueValue + ")";
}
//自定義數據域
private int redValue;
private int greenValue;
private int blueValue;
}
上面的Color枚舉類是一個不可繼承的final類。枚舉值（RED…）都是Color類型的靜態常量，因為枚舉類是class，所以在枚舉類型中也可以有構造器、方法和數據域，但是枚舉類的構造器是私有的，它會自己調用。
而且在上面的枚舉類中，重寫了枚舉類Enum的toString()方法，打印出更完整的信息。
來看下會有什麼輸出結果
在上面的代碼中，調用了Enum的ordinal()方法，它會返回枚舉值在枚舉類中的順序，這個順序是根據枚舉值在聲明的順序中定的，所以會輸出”0 1 2 3 4″。
然後調用了Enum的valueOf()方法，此方法是和toString()方法對應的，返回帶指定名稱的指定類型的枚舉常量，所以會輸出”BLUE(0,0,255)”。
最後，可能大家會疑惑，為什麼println輸出會調用重寫的toString()方法呢？
別急，讓我來一一分析一下。
直接看Java相關類的源代碼就可以分析出來了。
先來看下System.out.println和System.out.print的源代碼
public void println(Object x){
String s = String.valueOf(x);
synchronized (this)
{
print(s);
newLine();
}
public void print(Object obj) {
write(String.valueOf(obj));
}
可以看到，當要打印一個對象時，會自動調用String.valueOf()這個方法。
那麼我們再來看下valueof()這個方法的源代碼
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
這段代碼的意思就是，當傳入的對象為Null時，會返回一個null，當非null時，會返回這個obj的toString()方法，所以，非null時就會調用toString()方法，原因我們就知道了，這就是當我們調用 print 或者 println 打印一個對象時，它會打印出這個 對象的 toString()的最終根源。
所以，我覺得平時沒事可以多研究JDK的源代碼，站在巨人的肩膀上，看下怎麼寫出更簡潔優美的代碼。
今天的內容就到這裡了，相信看到這裡，你應該明白了final大概是怎麼用的，什麼時候需要用。「合抱之木,生於毫末。」只有站在設計者的角度，從根本上去理解為什麼這麼設計，吃透每個基本的知識點，並且深入研究源碼，才能讓內功更深厚，從而去解決一個又一個更高深的問題。
