【因為每一章都篇幅比較長（10多頁，難免有的地方會寫錯字，如發現請指正，本人不勝感激）】

【今天看到我居然有一名粉絲，內心還是有點小激動的，之間我是一枚不是很喜歡技術的妹紙，但是從現在開始，我從被動學習開始轉為主動學習，因為我想給自己一個機會，也許它就會還我一個驚喜呢。好了廢話不多說了，如果有像我一樣不喜歡技術的妹紙希望我能給你鼓勵。↖(^ω^)↗】

【ps:因為時間有點緊，所以排版不好，后期我會調整一下】

上一章介紹了類與對象的基本用法，本章介紹如何控制類及其成員的訪問權限，包括：包的使用、類的訪問控制、成員的訪問控制以及final的變量以及static關鍵字

7.1 包的使用

在實際開發中，往往需要開發很多不同的類，能否方便高效的組織這些類對項目的開發和使用具有和重要的意義。
提示：標準的java類庫分布在多個包中，eg:java.lang,java.util等
使用包的目的：可以在同一個項目中使用相同名稱的類，本節從類的放置與導入兩個方面對包及使用進行介紹。包括：

聲明創建包

引入包內的資源

靜態引入

7.1.1 聲明創建包
要想將類放在指定的包中，就必須使用package語句，語法如下：
package<包名>;

• package語句必須放在源文件的最前面（有效代碼第一行）
• 每個源文件最多一句package,因為一個類不能屬于兩個包
• 包名用點“.”分隔，eg:java.lang,這就表示此源文件中的類在java包下的lang子包中。
• 在實際開發中，包可能分很多級，越復雜的系統，包越多，級也可能越多；eg:

package lixiaoxi.bupt; public class Test {public static void main(String[] args){System.out.println("運行成功，我在lixiaoxi.by包中！！");} }

編譯上面的代碼，并將編譯后的.class文件拷貝到相應的包(lixiaoxi.bupt)對應的文件夾中，即Test.class文件放到所在目錄下的lixiaoxi文件中的bupt文件下，文件放置完后，其目錄結構為：

從上圖可以看出，包實際上代表的是文件夾（目錄路徑）如果不將編譯后的class文件放在相應的文件夾中，則無法運行。
提示 在實際開發中會為每一個類制定具體的包。
運行結果：


使用命令行運行在具體包中的類時要使用全稱類名，即：包名與類名順次用“.”隔開，eg(java lixiaoxi.bupt.Test),若只是（java Test）則會報“java.lang.NoClassDefFoundError”異常
提示：在運行程序時，要將當前目錄設置為最外層的包文件夾所在的目錄（即本例的lixiaoxi文件夾所在目錄，而不是類文件所在目錄，否則在有些情況下運行可能報錯）

• 在開發中要注意不要把類文件隨意拷貝到別的目錄中，開發中想改變類所在的包，一定要修改源代碼重新編譯，只是拷貝、移動類文件是不對的
• 如果沒有在源文件中使用package語句，那么這個源文件中的類就被放置在一個匿名包中，匿名包是一個有名字的包，其代碼編譯后的類文件與源文件在同一個目錄中即可

• 注意：后面例子中有包的，不要忘記將編譯后的class文件放到相應的文件，否則程序不能正常執行
  7.1.2 引入包內的資源
  當一個類使用與自己處于同一個包中的類————-直接訪問；
  使用其他包中的類———————import語句；語法如下：
  import<包名>.*;//使用指定包中的所有類，但不包括子包中的類
  import<包名>.類名；//使用指定包中特定類

• 包名可以是一個由“.”分隔的序列，eg:”java.lang”、“java.util”

import java.util.*; import java.io.InputStream;

• import語句放在package語句之后，類聲明之前

• import語句只是在編譯的時候有作用，另外java.lang包中的類系統是自動引入的，相當于在每個源文件中系統在編譯時會自動加上“import.java.lang.*語句”
  -.”*”可以導入第一層的所有類，但是若要使用多個包中的同名類就不行；

• 兩個包中有同名類，但只用到其中一個及其他不同名的類。

• 兩個包中有同名類，且都要使用
  1、兩個包中有同名類，但只用到其中一個及其他不同名的類
  eg:java.util和java.sql包中都有名稱為Date的類，在程序中要同時使用這兩個包中的很多類，但只用到java.util包中的Date類：

package lixiaoxi.bupt; import java.util.*; import java.sql.*; public class Test {public static void main(String[] args){Date date=new Date();//其他使用別的類的代碼省略} }

運行結果：
The type Date is ambiguous(引起歧義)

系統報Date類匹配失敗，因為在源代碼中用import語句引入兩個包中的所有類，兩包都有Date類，系統不知道應該匹配哪一個，如果只用到java.util包中的Date類，可以將import util中修改為：

import java.util.*; import java.util.Date; import java.sql.*;

這樣就不會報錯了，因為系統會優先匹配import語句中明確給出類名的類；
這就是為什么 會在別人的方法中看到已經有了.*還要指定類名。
2、兩個包中有同名類，且都要使用
使用兩個不同包中的同名類只靠import就無法解決了，eg:將上面demo改為：

package lixiaoxi.bupt; import java.util.*; import java.util.Date; import java.sql.*; import java.sql.Date;//報錯：//Date is already defined in a single-type import public class Test {public static void main(String[] args){Date date=new Date();//使用java.util中的Date類Date d1=new Date(123);//使用java.sql中的Date類//其他使用別的類的代碼省略} }

系統報具體指定名稱的同類名只能引入一次的錯誤，真正的解決辦法是在使用同名類的地方使用全稱類名eg:

package lixiaoxi.bupt; import java.util.*; import java.sql.*;public class Test {public static void main(String[] args){java.util.Date date=new java.util.Date();//使用java.util中的Date類java.sql.Date d1=new java.sql.Date(123);//使用java.sql中的Date類,數字的含義不必理會//其他使用別的類的代碼省略} }

需要特別注意：不要使用星號（*）代替包，eg:下面的導入語句是非法的。
import java..;

7.1.3 靜態引入
導入語句不但可以導入類，還具有導入靜態方法和靜態成員變量的功能，不過要在關鍵字“import”和包名之間添加關鍵字“static”，具體語法如下：
import static <包名>.<類名>.;
import static <包名>.<類名>.<具體方法/成員變量名>；

“*”代表通配符，不過這里表示的是指定類下面所有的靜態方法或成員變量。

如果要明確指明要使用的方法或成員變量，用第二種

遇到不同類下同名靜態方法或成員變量，解決沖突方式與上一小節類似；

package lixiaoxi.bupt; import static java.lang.System.*;//引用System類下的所有靜態成員，包含方法和成員變量； import static java.lang.Math.sqrt;//y引用Math類下的sqrt方法（開平方）public class Test {public static void main(String[] args){out.println("簡單打印功能~~~~~");out.println("123.44的平方根為："+sqrt(123.44));} }

上面打印就不需要像以前一樣列出方法所在的類的類名了；
運行結果：

實際上，沒有很多開發人員使用靜態引入，因為這種代碼編寫形式容易降低代碼的可讀性，造成維護困難。但是以下兩個特別的地方有很實際的作用，可以簡化開發。

算數函數
- 如果對Math類使用靜態引入，就可以采用更加自然的方式在表達式中使用算數函數，eg:”pow(3,2)+sqrt(4)”比“Math.pow(3,2)+Math.sqrt(4)”看起來更清晰

靜態常量
- 如果需要使用大量的帶有繁瑣的名字的靜態常量，使用靜態引入代碼會清晰明了，eg:”MONAY”比“Calendar.MONDAY”看起來簡單很多

7.2 類的訪問控制 （public或默認不寫）

首先了解類訪問的含義：若一個類（類A）訪問另一個類（類B）時，其指類A具有以下三種操作：

在類A中創建類B的對象；

使用類B的某些方法和成員變量；

繼承類B
類訪問實際上是指：一個類對另一個類的可見性，eg:類A看不見類B,則類B中的方法和變量的訪問權限對A來說就為不可訪問，類的訪問權限有兩種：
公有級別訪問（public類型）
默認訪問級別（什么都不寫）
因此，聲明每個類時無論是否明確指定，其都將有一個訪問控制級別；
7.2.1 公有訪問級別
帶有“public”修飾的類，任何包中的任何類都可以訪問此訪問級別的類。需注意：盡管從訪問級別上其可以被任何包中的任何類訪問，但是編寫代碼時，如果訪問其他類與其不再同一個包，依然需要引入語句或全稱類名

package bupt; public class Test2 { } package lixiaoxi; import bupt.*;class Test {public static void main(String[] args){Test2 test=new Test2();System.out.println("Test2創建成功，可以訪問到Test2");} }

運行結果：

提示：javac命令一次可以編譯多個源文件，只要把編譯的多個源文件用空格符分開，逐一列出即可；
7.2.2 默認訪問級別
可以將默認訪問級別看做包訪問，因為默認訪問級別下的類只能被同一個包中的類看到，包外不可見
將類Test2的public去掉就看到兩處錯誤：分別是聲明引用于創建對象時都無法都無法訪問類Test2,因為Test2具有默認訪問級別，并與要訪問類位于不同包中，可以把兩個類放在同一個包中，或者將Test2設置為publlic的。
7.2.3 類與源代碼文件的搭配
一個源代碼文件中可以同時有多個類，類與源代碼文件搭配的規則：

每個源代碼文件中可以有任意多個類，但只能有一個public類【C#中可以多個public類】

該文件名必須與public的類名完全相同（注意區分大小寫），若沒有public類，則可以任意命名該文件；

如果類是包的一部分，包語句必須在有效代碼第一行，注釋和空行可以出現在任意位置；

如果有引入語句，其必須位于包語句之后，第一個類聲明之前，若沒有包語句，引入語句必須在文件中最前面；

導入語句和包語句應用于源代碼文件中的所有類；eg,下面是一個合法的源代碼文件：

package lixiaoxi.bupt; import java.util.Date;public class Test {public static void main(String[] args){Test2 test=new Test2();test.show();} } class Test2 {Date today=new Date();void show(){System.out.println(today.toString());} }

運行結果：

在實際開發中建議一個源代碼文件一個類，并且不管此類是不是public的，文件名與該類名相同，因為在實際開發中，可能會有成千上萬個類，若需要修改某一個類，那么該類的源代碼文件會很容易找到

7.3 成員的訪問控制（public，默認不寫，protected,private，）

成員包括（方法和成員變量【java中的成員除方法和變量外還有語句塊，內部類】）
成員訪問指的是什么？指以下兩種不同的操作：

一個類中的方法代碼是否能夠調用另一個類中的成員；

一個類是否能繼承其父類的成員；
注意：成員的訪問權限基于類的訪問權限，即若類A有權訪問類B時，類B中成員的訪問權限對類A才起作用（即類A能調類B，才會考慮到成員變量訪問權限問題）
7.3.1 公共類型
用public:所有其他類，無論該類屬于哪個包，均能訪問該成員：eg:

package bupt; public class Test2 {Date today=new Date();public void show(){System.out.println("成功調用了public 修飾的show方法");} } package lixiaoxi import bupt.*; class Test {public static void main(String[] args){Test2 test=new Test2();test.show();} }

運行結果：

對于繼承而言，規則為：如果父類的成員聲明為public，那么無論這兩個類是否在同一個包中該子類都能繼承其父類的該成員
7.3.2 私有類型（private）
不能被該成員所在類之外的任何類中代碼訪問eg:

package bupt; public class Test2 {Date today=new Date();private void show(){System.out.println("成功調用了public 修飾的show方法");} }class Test {public static void main(String[] args){Test2 test=new Test2();test.show();//error message:The method show() from the type Test2 is not visible} }

雖然兩個類在同一個包中，方法show()卻不能被調用，因為被設置為private，自己類以外的任何代碼都是不可見的
7.3.3 默認類型（啥也不寫）
只對與此成員所屬類在同一個包中的類可見，對于同一個包中的類：默認類型相當于public，而對包外的類則相當于private

package bupt; public class Test2 {void show(){System.out.println("成功調用了默認修飾符（不寫） 修飾的show方法");} } package lixiaoxi; import bupt;class Test {public static void main(String[] args){Test2 test=new Test2();test.show();//The method show() from the type Test2 is not visible} }

從繼承角度若父類的成員聲明為默認類型，則包內的子類可以繼承而包外的則不可以
7.3.4 保護類型（protected）
其規則與默認類型一樣：對于同一個包中的類：默認類型相當于public，而對包外的類不是不能訪問而是只有通過繼承才能訪問該成員

成員訪問修飾符
提示：訪問修飾符不能用來修飾局部變量，否則將編譯報錯，而且局部變量作用域為局部，也沒有這個必要
7.3.5 java中封裝的實現

封裝的含義；

封裝的使用及優點；

封裝的含義：
把東西包起來，換言之：成員變量和方法的定義都包裝于類定義之中，類定義可以看成是將構成類的成員變量和方法封裝起來
通過限定類成員的可見性，可以使得類成員中的某些屬性和方法能夠不被程序的其他部分訪問，被隱藏起來，只能在所定義的類中使用，這就是面對對象中實現封裝的方式；

封裝的使用及優點：
盡管技術上可以把成員變量標識為public，但是在實際中最好把所有的成員變量都保持為private，如果需要修改、設置或讀取該成員變量，應該使用公共的訪問器方法，因此任何其他類中的代碼必須通過調用方法來訪問該成員變量，而不是直接使用；
這樣有助于提高程序的靈活性，便于做代碼修改和維護eg:

public class Test {public static void main(String[] args){People test=new People();test.size=-5;//訪問成員變量size} } class People {public int size;//身高 }

代碼中給size（身高）賦值為-5顯然是錯誤的，但由于size是public的，這就很難避免這種錯誤，解決辦法是為size變量編寫訪問器方法用private訪問限制修飾符保護size變量，修改后demo為：

public class Test {public static void main(String[] args){People test=new People();test.setSize(-5);//訪問成員變量size} } class People {private int size;//身高public void setSize(int newsize)//set成員變量的set方法{if(newsize>0){size=newsize;}else{System.out.println("身高必須大于0，請重新輸入");}}public int getSize()//size成員變量的get訪問器{return size;} }

運行結果：

上面的demo對size成員變量做了封裝，必須通過訪問器方法設置size的值而在訪問器set方法中編寫了驗證之正確性的規則
提示：學會這種思想，對成員變量進行封裝，在訪問方法中編寫值正確性的驗證規則
eg 由于某種原因需要將size的類型修改為String，如果沒有使用封裝，那么所有用到size的地方都將不能使用，很可怕；而封裝以后，只需要對訪問器進行一定修改，可以使外面的調用者感覺不到變化，eg:

public class Test {public static void main(String[] args){People test=new People();test.setSize(185);//訪問成員變量sizeSystem.out.println("設置的身高為："+test.getSize()+"厘米");} } class People {private String size;//身高public void setSize(int newsize)//set成員變量的set方法{if(newsize>0){size=newsize+"厘米";}else{System.out.println("身高必須大于0，請重新輸入");}}public int getSize()//size成員變量的get訪問器{return Integer.parseInt(size.substring(0,size.indexOf("厘米")));//從字符串中提取出身高信息轉換為整數返回} }

運行結果：

java封裝所需要遵循的規則：

用訪問限制符保護成員變量，通常是private；

建立公有訪問器方法，強制調用代碼通過這些方法訪問成員變量

關于訪問器方法，嚴格使用JavaBean命名規則set<成員變量>和get<成員變量>

7.4 final的變量

final能修飾很多類型的元素，而且功能含義各不相同；分幾部分介紹，本節介紹final變量
用final修飾的變量含義：該變量一旦被顯示初始化之后，其值就不能再被修改。要特別注意的是：對原始類型和引用類型的變量值不能修改的含義不完全一樣；

對于原始類型：一旦賦值以后，該值就不能修改；eg:final int x=10;則x的值永遠保持為10；

對于引用類型，一旦賦值以后，將不能重新用來引用（指向）另一個對象，然而可以修改其引用對象的成員變量，也就是說，可以修改final的引用的引用對象，但是不能修改final引用指向別的對象；簡言之，沒有最終的對象，只有最終的引用。
7.4.1 final的成員變量
一般情況下，不對成員變量賦初值，系統會給其默認初始值。但是對于final的成員變量，系統不會為其賦默認初始值，而是要求在構造器完成之前必須顯式初始化，當然一旦初始化就不能修改。
提示：上面的成員變量指非靜態的成員變量 eg:

class Test2//errormessage:The blank final field x may not have been initialized {final int x;//聲明final成員變量public void showfinal()//set成員變量的set方法{System.out.println("final x="+x);} }

final變量初始化的時間只要在構造器完成之前即可；其可選時機有如下三種：

• 聲明的同時進行初始化
• 在非靜態語句塊中進行初始化
• 在構造器中進行初始化 eg:

public class Test {final int x1=100;//聲明同時完成初始化final int x2;final int x3;{x2=88;//非晶態語句塊中進行初始化}public Test(){x3=66;//構造器中初始化}public void showFinalX(){System.out.println("final x1的值為："+x1+",final x2的值為："+x2+",final x3的值為："+x3);}public static void main(String[] args){Test test=new Test();test.showFinalX();} }

運行結果為：

通過下面的demo來說明final引用的問題：

public class Test {final Student stu=new Student();public void setAge(){System.out.println("修改年齡以前的年齡為："+stu.age);stu.age=18;System.out.println("修改年齡以后的年齡為："+stu.age);}public static void main(String[] args){Test test=new Test();test.setAge();} } class Student {int age=21; }

運行結果：

從上面的程序中可以看到，final引用所指向的對象的成員變量是可以修改的。當然要修改的成員變量本身不能為final的，在第九行和第十行之間插入stu=new Student()就會報錯：

因為stu是final的，其值（對象的地址）不能被修改即指向哪一個對象是不能修改的（eg:房東就是房子對象的引用，房子里可以住不同的人（搬來搬走）但是房東與這個房子的關系不能修改）
說明：在java中可能有多個修飾符同時修飾一個元素這多個修飾符之間可以任意交換次序：eg:下面的代碼是等價的：

public final int a=10; final public int b=6;

int是變量類型，不是修飾符其位置不能改變
7.4.2 final的局部變量
被修飾final的局部變量與成員變量非常相似，不同之處是，局部final變量可以只聲明不初始化，一旦初始化了值不能改變，初始化時間只要在其使用之前就行，下面demo說明局部final變量：

public static void main(String[] args){final int x;System.out.println("沒有為final的局部變量初始化，并已成功運行！");}

運行結果：

這說明局部變量在使用之前不初始化是沒問題的，在19行和21行加上兩個初始化：

提示：關于局部引用的問題，與基本數據類型一致，可以不初始化，一旦初始化不可更改即指向哪個對象是不能改變的，但其所引用對象的成員是可以修改的。

7.5 static關鍵字

被static修飾過的成員與普通成員有很大的不同，Static關鍵字只能修飾成員，只要身份是成員都可以修飾eg:變量、方法、語句塊、內部類

• 靜態的成員的基本使用
• 靜態成員的訪問

• 靜態最終成員變量
  提示：訪問限制修飾符對靜態成員變量同樣有作用，規則與前面講的非靜態的相同

  7.5.1 靜態的成員
  為什么要引入靜態的概念？原因主要有以下兩個：

• 假定有一個實用的工具類，其中的一個方法總是以相同的方式運行，其行為與結果不依賴于對象的狀態，eg:Math中的求絕對值的abs方法；因此當方法執行與對象完全無關時，就不需要創建對象，完全可以要求類自身來運行這個方法。

• 另一種特殊情況，若想記錄某個類的所有對象的個數等關于這個類的所有對象的信息，這時必須需要一個依賴于類的而不是依賴于對象的變量來記錄此信息，否則將不能解決此問題；eg:依賴于對象的成員是不可能解決此問題的，因為每次創建對象時都會為其執行相同的初始化工作
  上述以相同方式運行的實用方法以及記錄同一個類所有對象的信息這兩種特殊情況，都是使用static來解決的。因此，用static關鍵字修飾的成員將屬于類，而不屬于任何特定的對象。也就是說，可以在根本沒有該類任何對象的時候使用被static修飾的成員
  但若存在對象，靜態成員將被該類的所有對象共享，只有一份拷貝，而不像非靜態成員每個對象自己擁有一份拷貝eg:

public class Test {static int count=0;int selfCount=0;public Test(){count++;selfCount++;}public static void main(String[] args){Test t1=new Test();Test t2=new Test();Test t3=new Test();System.out.println("靜態成員變量count的值分別t1: "+t1.count+",t2: "+t2.count+",t3： "+t3.count);System.out.println("非靜態成員變量count的值分別t1: "+t1.selfCount+",t2: "+t2.selfCount+",t3 "+t3.selfCount);} }

運行結果：

對于非靜態成員變量selfCount，每個對象都有自己的拷貝，其屬于各個對象都從0加了一次1，所以打印1；
對于靜態成員變量count屬于類，類的所有對象共享一份拷貝所以三次，運行結果都為3；
7.5.2. 靜態成員的訪問
靜態成員屬于類，所以訪問的不需要創建對象 eg:

public class Test {static int staticvar=66;public static void main(String[] args){Test.staticvar=88;//使用類名點變量名調用System.out.println("靜態成員變量staticvar的值為："+staticvar+".");//與靜態成員在同一個類中可以直接使用靜態成員變量名，在其他類中使用時需要用類名點變量名調用} }

同一個類中可以不用類名點靜態變量名調用，但是在其他方法中就必須使用類名點靜態變量名，或者是相應的對象引用，受到訪問限制級別的約束。
提示：實際開發中，提倡用類名來訪問靜態成員。
運行結果：

從下面兩個方面介紹同一個類中的靜態成員變量與非靜態成員變量成員之間的訪問。

靜態成員訪問非靜態成員

非靜態成員訪問靜態成員

靜態成員訪問非靜態成員：eg:

“無法從靜態上下文中引用非靜態變量staticVar”的錯，這是因為main()方法是static的，而staticVar是非靜態成員，如下圖，因為靜態成員不依賴于該類的任何對象，所以當其所在的類加載成功后，就可以訪問其了，此時對象不一定存在，非靜態成員自然也不一定存在，靜態成員的生命周期比非靜態的長：

即使訪問時存在非靜態成員，靜態方法也不知道訪問的是哪一個對象的成員，因為靜態方法屬于類，非靜態成員屬于對象，所以靜態方法將不知道關于其所屬類對象的信息
提示：main()方法被定義為靜態的也是如此，其只是程序開始執行的入口，不需要依賴任何對象，若要在靜態方法中訪問非靜態成員主要使用指向特定對象的引用即可：

public class Test {int var=66;//聲明非靜態變量public static void main(String[] args){Test t2=new Test();System.out.println("成員變量var的值為："+t2.var+".");} }

運行結果：


而靜態方法訪問靜態成員時，自然是任何時候都沒問題，靜態成員屬于類只要類存在，靜態成員都將存在。
同理，靜態方法中不能使用this預定義對象引用的，即使后邊所操作的也是靜態成員也不行，因為this代表指向自己對象的引用，而靜態方法屬于類不屬于對象，其成功加載以后，對象還不一定存在，即使存在，也在不知道this指的是哪一個對象eg:

系統報“無法從靜態上下文中引用非靜態變量this”
2. 非靜態成員訪問靜態成員：
非靜態訪問靜態成員的時候，規則很簡單，非靜態成員的生命周期被靜態成員生命周期包含，因此，當非靜態成員存在的時候，靜態成員絕對存在，故非靜態方法可以隨時訪問靜態成員。eg:

public class Test {static int staticvar=66;//聲明非靜態變量public void showStaticVar(){System.out.println("非靜態方法調用靜態成員變量staticvar,值為："+staticvar);}public static void main(String[] args){Test test=new Test();test.showStaticVar();} }

運行結果：

7.5.3. 靜態最終成員變量

• 靜態最終變量的具體應用
• 靜態最終成員變量的初始化
  1、靜態最終變量的具體應用：
  沒有介紹java中如何實現常量，其實java中沒有一個直接的修飾符來實現常量，而是通過靜態最終成員變量的方式來實現的eg:

//聲明常量xyzpublic static final int x=10;static public final int y=25;final static public int z=88;

*1】static 屬于類，不必創建對象就能使用，因為常量不依賴于任何對象，final表示值不能改變；
2】一般用做常量的靜態最終變量訪問限制符都設置為public，因為常量允許所有類或對象訪問*
其實前面的Math類中的PI與E常量就是Math類的最終成員變量
提示：雖然java中有const關鍵字，但不是用來聲明常量的，與C和C++不同，在java中const只是一個關鍵字，沒有任何意義，也不能出現在源代碼中
2、靜態最終成員變量的初始化【必須初始化】
前面的非靜態最終成員變量時講過，系統不會為其分配默認值，必須在構造器完成之前對其初始化，對于靜態最終成員變量，系統也不會為其分配默認值，也必須初始化，但是其屬于類，是不能等到構造器運行再初始化的因為類加載完之后其值必須可以使用
java中靜態最終成員變量的初始化要求在靜態語句塊結束之前必須完成，即java中靜態初始化有兩個時機：

在聲明的同時進行初始化

在靜態語句塊中進行初始化
eg:

public class Test {public static final int const1=789;//聲明是完成初始化public static final int const2;static {const2=57;//初始化常量2}public static void main(String[] args){System.out.println("兩個常量的值分別為,const1="+const1+"，const2="+const2);} }

static
{
const2=57;//初始化常量2
}這一塊稱為靜態語句塊，也是靜態成員的一種
提示：靜態語句塊在類加載的時執行一次，可以將對類進行初始化的代碼寫在其中。
運行結果：

若將static語句塊中的賦值語句注釋掉就會報“尚未初始化變量const2”的錯誤，再次給const2賦值也會提示“無法為final變量const2指定值“的錯誤。

必須在靜態語句塊完成之前對靜態最終變量進行初始化。
第七章完~~~

【偉大的物理學家，一個有趣的人—-霍金在今天（2018年3月14號去世了），一顆偉大的恒心消失在天際。他幾乎陪著我們從小學開始到整個學習生涯的結束，他的對生活的態度，對科學的執著，對人類的偉大貢獻使他將永遠活在我們的心中，愿他在天堂可以奔跑。】

總結

以上是生活随笔為你收集整理的java第七章学习笔记:访问控制---java世界的卫兵的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。