夯實Java基礎系列7：一文讀懂Java 代碼塊和執行順序
目錄
本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到個人倉庫裏查看html
喜歡的話麻煩點下Star哈git
文章首發於個人我的博客：程序員
www.how2playlife.comgithub
本文是微信公衆號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部份內容來源於網絡，爲了把本文主題講得清晰透徹，也整合了不少我認爲不錯的技術博客內容，引用其中了一些比較好的博客文章，若有侵權，請聯繫做者。 該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接着瞭解每一個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，造成本身的知識框架。爲了更好地總結和檢驗你的學習成果，本系列文章也會提供每一個知識點對應的面試題以及參考答案。面試
若是對本系列文章有什麼建議，或者是有什麼疑問的話，也能夠關注公衆號【Java技術江湖】聯繫做者，歡迎你參與本系列博文的創做和修訂。算法
<!-- more -->後端
Java中的構造方法
構造方法簡介
構造方法是類的一種特殊方法，用來初始化類的一個新的對象。Java 中的每一個類都有一個默認的構造方法，它必須具備和類名相同的名稱，並且沒有返回類型。構造方法的默認返回類型就是對象類型自己，而且構造方法不能被 static、final、synchronized、abstract 和 native 修飾。微信
提示：構造方法用於初始化一個新對象，因此用 static 修飾沒有意義；構造方法不能被子類繼承，因此用 final 和 abstract 修飾沒有意義；多個線程不會同時建立內存地址相同的同一個對象，因此用 synchronized 修飾沒有必要。網絡
構造方法的語法格式以下：
<pre>class class_name { public class_name(){} //默認無參構造方法 public ciass_name([paramList]){} //定義構造方法 … //類主體 }</pre>
在一個類中，與類名相同的方法就是構造方法。每一個類能夠具備多個構造方法，但要求它們各自包含不一樣的方法參數。
構造方法實例
例 1
構造方法主要有無參構造方法和有參構造方法兩種，示例以下：
<pre>public class MyClass { private int m; //定義私有變量 MyClass() { //定義無參的構造方法 m=0; } MyCiass(int m) { //定義有參的構造方法 this.m=m; } }</pre>
該示例定義了兩個構造方法，分別是無參構造方法和有參構造方法。在一個類中定義多個具備不一樣參數的同名方法，這就是方法的重載。這兩個構造方法的名稱都與類名相同，均爲 MyClass。在實例化該類時能夠調用不一樣的構造方法進行初始化。
注意：類的構造方法不是要求必須定義的。若是在類中沒有定義任何一個構造方法，則 Java 會自動爲該類生成一個默認的構造方法。默認的構造方法不包含任何參數，而且方法體爲空。若是類中顯式地定義了一個或多個構造方法，則 Java 再也不提供默認構造方法。
例 2
要在不一樣的條件下使用不一樣的初始化行爲建立類的對象，這時候就須要在一個類中建立多個構造方法。下面經過一個示例來演示構造方法的使用。
(1) 首先在員工類 Worker 中定義兩個構造方法，代碼以下：
<pre>public class Worker { public String name; //姓名 private int age; //年齡 //定義帶有一個參數的構造方法 public Worker(String name) { this.name=name; } //定義帶有兩個參數的構造方法 public Worker(String name,int age) { this.name=name; this.age=age; } public String toString() { return"你們好！我是新來的員工，我叫"+name+"，今年"+age+"歲。"; } }</pre>
在 Worker 類中定義了兩個屬性，其中 name 屬性不可改變。分別定義了帶有一個參數和帶有兩個參數的構造方法，並對其屬性進行初始化。最後定義了該類的 toString() 方法，返回一條新進員工的介紹語句。
提示：Object 類具備一個 toString() 方法，該方法是個特殊的方法，建立的每一個類都會繼承該方法，它返回一個 String 類型的字符串。若是一個類中定義了該方法，則在調用該類對象時，將會自動調用該類對象的 toString() 方法返回一個字符串，而後使用「System.out.println(對象名)」就能夠將返回的字符串內容打印出來。
(2) 在 TestWorker 類中建立 main() 方法做爲程序的入口處，在 main() 方法中調用不一樣的構造方法實例化 Worker 對象，並對該對象中的屬性進行初始化，代碼以下：
<pre>public class TestWorker { public static void main(String[] args) { System.out.println("-----------帶有一個參數的構造方法-----------"); //調用帶有一個參數的構造方法，Staff類中的sex和age屬性值不變 Worker worker1=new Worker("張強"); System.out.println(worker1); System.out.println("-----------帶有兩個參數的構造方法------------"); //調用帶有兩個參數的構造方法，Staff類中的sex屬性值不變 Worker worker2=new Worker("李麗",25); System.out.println(worker2); } }</pre>
在上述代碼中，建立了兩個不一樣的 Worker 對象：一個是姓名爲張強的員工對象，一個是姓名爲李麗、年齡爲 25 的員工對象。對於第一個 Worker 對象 Worker1，並未指定 age 屬性值，所以程序會將其值採用默認值 0。對於第二個 Worker 對象 Worker2，分別對其指定了 name 屬性值和 age 屬性值，所以程序會將傳遞的參數值從新賦值給 Worker 類中的屬性值。
運行 TestWorker 類，輸出的結果以下：
<pre>-----------帶有一個參數的構造方法----------- 你們好！我是新來的員工，我叫張強，今年0歲。 -----------帶有兩個參數的構造方法------------ 你們好！我是新來的員工，我叫李麗，今年25歲。</pre>
經過調用帶參數的構造方法，在建立對象時，一併完成了對象成員的初始化工做，簡化了對象初始化的代碼。
Java中的幾種構造方法詳解
普通構造方法
方法名與類名相同
無返回類型
子類不能繼承父類的構造方法
不能被static、final、abstract修飾（有final和static修飾的是不能被子類繼承的，abstract修飾的是抽象類，抽象類是不能實例化的，也就是不能new）
能夠被private修飾，能夠在本類裏面實例化，可是外部不能實例化對象（注意！！！）
public class A{
int i=0;
public A(){
i=2;
}
public A(int i){
this.i=i;
}
}
默認構造方法
若是沒有任何的構造方法，編譯時系統會自動添加一個默認無參構造方法
隱含的默認構造方法
public A(){}
顯示的默認構造方法
public A(){
System.out.print("顯示的默認構造方法")
}
重載構造方法
好比本來的類裏的構造方法是一個參數的，如今新建的對象是有三個參數，此時就要重載構造方法
當一個類中有多個構造方法，有可能會出現重複性操做，這時能夠用this語句調用其餘的構造方法。
public class A{
private int age;
private String name;
public A(int age,String name){
this.age=age;
this.name=name;
}
public A(int age){
this(age,"無名氏");//調用 A(int age,String name)構造方法
}
public A(){
this(1);//調用 A(int age)構造方法
}
public void setName(String name) {this.name=name;}
public String getName() {return name;}
public void setAge(int age) {this.age=age;}
public int getAge() {return age;}
}
A a=new A(20,"週一");
A b=new A(20);
A c=new A();
String name = a.getName();
String name1 = b.getName();
int age = c.getAge();
System.out.println(name);
System.out.println(name1);
System.out.println(age);
java子類構造方法調用父類構造方法
首先父類構造方法是絕對不能被子類繼承的。
子類構造方法調用父類的構造方法重點是：子類構造方法不管如何都要調用父類的構造方法。
子類構造方法要麼調用父類無參構造方法（包括當父類沒有構造方法時。系統默認給的無參構造方法），要麼調用父類有參構造方法。當子類構造方法調用父類無參構造方法，通常都是默認不寫的，要寫的話就是super（），且要放在構造方法的第一句。當子類構造方法要調用父類有參數的構造方法，那麼子類的構造方法中必需要用super（參數）調用父類構造方法，且要放在構造方法的第一句。
當子類的構造方法是無參構造方法時，必須調用父類無參構造方法。由於系統會自動找父類有沒有無參構造方法，若是沒有的話系統會報錯：說父類沒有定義無參構造方法。
當子類構造方法是有參構造方法時，這時就會有兩種狀況。 第一種：子類構造方法沒有寫super，也就是說你默認調用父類無參構造方法，這樣的話就和子類是無參構造方法同樣。
第二種：子類構造方法有super（參數）時，就是調用父類有參構造方法，系統會找父類有沒有參數一致（參數數量，且類型順序要相同）的有參構造方法，若是沒有的話，一樣也會報錯。
可是這裏會遇到和重載構造方法this同樣問題，一個參數的構造方法能夠調用多個參數構造方法，沒有的參數給一個本身定義值也是能夠的。
Java中的代碼塊簡介
在java中用{}括起來的稱爲代碼塊，代碼塊可分爲如下四種：
一.簡介
1.普通代碼塊：
類中方法的方法體
2.構造代碼塊：
構造塊會在建立對象時被調用，每次建立時都會被調用，優先於類構造函數執行。
3.靜態代碼塊：
用static{}包裹起來的代碼片斷，只會執行一次。靜態代碼塊優先於構造塊執行。
4.同步代碼塊：
使用synchronized（）{}包裹起來的代碼塊，在多線程環境下，對共享數據的讀寫操做是須要互斥進行的，不然會致使數據的不一致性。同步代碼塊須要寫在方法中。
二.靜態代碼塊和構造代碼塊的異同點
相同點：都是JVM加載類後且在構造函數執行以前執行，在類中可定義多個，通常在代碼塊中對一些static變量進行賦值。
不一樣點：靜態代碼塊在非靜態代碼塊以前執行。靜態代碼塊只在第一次new時執行一次，以後不在執行。而非靜態代碼塊每new一次就執行一次。
Java代碼塊使用
局部代碼塊
位置：局部位置（方法內部）
做用：限定變量的生命週期，儘早釋放，節約內存
調用：調用其所在的方法時執行
public class 局部代碼塊 {
@Test
public void test (){
B b = new B();
b.go();
}
}
class B {
B(){}
public void go() {
//方法中的局部代碼塊，通常進行一次性地調用，調用完馬上釋放空間，避免在接下來的調用過程當中佔用棧空間
//由於棧空間內存是有限的，方法調用可能會會生成不少局部變量致使棧內存不足。
//使用局部代碼塊能夠避免這樣的狀況發生。
{
int i = 1;
ArrayList<Integer> list = new ArrayList<>();
while (i < 1000) {
list.add(i ++);
}
for (Integer j : list) {
System.out.println(j);
}
System.out.println("gogogo");
}
System.out.println("hello");
}
}
構造代碼塊
位置：類成員的位置，就是類中方法以外的位置
做用：把多個構造方法共同的部分提取出來，共用構造代碼塊
調用：每次調用構造方法時，都會優先於構造方法執行，也就是每次new一個對象時自動調用，對 對象的初始化
class A{
int i = 1;
int initValue;//成員變量的初始化交給代碼塊來完成
{
//代碼塊的做用體現於此：在調用構造方法以前，用某段代碼對成員變量進行初始化。
//而不是在構造方法調用時再進行。通常用於將構造方法的相同部分提取出來。
//
for (int i = 0;i < 100;i ++) {
initValue += i;
}
}
{
System.out.println(initValue);
System.out.println(i);//此時會打印1
int i = 2;//代碼塊裏的變量和成員變量不衝突，但會優先使用代碼塊的變量
System.out.println(i);//此時打印2
//System.out.println(j);//提示非法向後引用，由於此時j的的初始化還沒開始。
//
}
{
System.out.println("代碼塊運行");
}
int j = 2;
{
System.out.println(j);
System.out.println(i);//代碼塊中的變量運行後自動釋放，不會影響代碼塊以外的代碼
}
A(){
System.out.println("構造方法運行");
}
}
public class 構造代碼塊 {
@Test
public void test() {
A a = new A();
}
}
靜態代碼塊
位置：類成員位置，用static修飾的代碼塊
做用：對類進行一些初始化 只加載一次，當new多個對象時，只有第一次會調用靜態代碼塊，由於，靜態代碼塊 是屬於類的，全部對象共享一份
調用: new 一個對象時自動調用
public class 靜態代碼塊 {
@Test
public void test() {
C c1 = new C();
C c2 = new C();
//結果,靜態代碼塊只會調用一次，類的全部對象共享該代碼塊
//通常用於類的全局信息初始化
//靜態代碼塊調用
//代碼塊調用
//構造方法調用
//代碼塊調用
//構造方法調用
}
}
class C{
C(){
System.out.println("構造方法調用");
}
{
System.out.println("代碼塊調用");
}
static {
System.out.println("靜態代碼塊調用");
}
}
Java代碼塊、構造方法（包含繼承關係）的執行順序
這是一道常見的面試題，要回答這個問題，先看看這個實例吧。
一共3個類：A、B、C 其中A是B的父類，C無繼承僅做爲輸出
A類：
public class A {
static {
Log.i("HIDETAG", "A靜態代碼塊");
}
private static C c = new C("A靜態成員");
private C c1 = new C("A成員");
{
Log.i("HIDETAG", "A代碼塊");
}
static {
Log.i("HIDETAG", "A靜態代碼塊2");
}
public A() {
Log.i("HIDETAG", "A構造方法");
}
}
B類：
public class B extends A {
private static C c1 = new C("B靜態成員");
{
Log.i("HIDETAG", "B代碼塊");
}
private C c = new C("B成員");
static {
Log.i("HIDETAG", "B靜態代碼塊2");
}
static {
Log.i("HIDETAG", "B靜態代碼塊");
}
public B() {
Log.i("HIDETAG", "B構造方法");
}
}
C類：
public class C {
public C(String str) {
Log.i("HIDETAG", str + "構造方法");
}
}
執行語句：new B();
輸出結果以下：
I/HIDETAG: A靜態代碼塊 I/HIDETAG: A靜態成員構造方法 I/HIDETAG: A靜態代碼塊2 I/HIDETAG: B靜態成員構造方法 I/HIDETAG: B靜態代碼塊2 I/HIDETAG: B靜態代碼塊 I/HIDETAG: A成員構造方法 I/HIDETAG: A代碼塊 I/HIDETAG: A構造方法 I/HIDETAG: B代碼塊 I/HIDETAG: B成員構造方法 I/HIDETAG: B構造方法
得出結論：
執行順序依次爲： 父類的靜態成員和代碼塊 子類靜態成員和代碼塊 父類成員初始化和代碼快 父類構造方法 子類成員初始化和代碼塊 子類構造方法
注意：能夠發現，同一級別的代碼塊和成員初始化是按照代碼順序從上到下依次執行
看完上面這個demo，再來看看下面這道題，看看你搞得定嗎？
看下面一段代碼，求執行順序：
class A {
public A() {
System.out.println("1A類的構造方法");
}
{
System.out.println("2A類的構造快");
}
static {
System.out.println("3A類的靜態塊");
}
}
public class B extends A {
public B() {
System.out.println("4B類的構造方法");
}
{
System.out.println("5B類的構造快");
}
static {
System.out.println("6B類的靜態塊");
}
public static void main(String[] args) {
System.out.println("7");
new B();
new B();
System.out.println("8");
}
}
執行順序結果爲：367215421548
爲何呢？
首先咱們要知道下面這5點：
每次new都會執行構造方法以及構造塊。 構造塊的內容會在構造方法以前執行。 非主類的靜態塊會在類加載時，構造方法和構造塊以前執行，切只執行一次。 主類（public class）裏的靜態塊會先於main執行。 繼承中，子類實例化，會先執行父類的構造方法，產生父類對象，再調用子類構造方法。 因此題目裏，因爲主類B繼承A，因此會先加載A，因此第一個執行的是第3句。
從第4點咱們知道6會在7以前執行，因此前三句是367。
以後實例化了B兩次，每次都會先實例化他的父類A，而後再實例化B，而根據第一、二、5點，知道順序爲2154。
最後執行8
因此順序是367215421548
參考文章
https://blog.csdn.net/likunkun__/article/details/83066062 https://www.jianshu.com/p/6877aae403f7 https://www.jianshu.com/p/49e45af288ea https://blog.csdn.net/du_du1/article/details/91383128 http://c.biancheng.net/view/976.html http://www.javashuo.com/article/p-wtuzhuho-hw.html https://www.jb51.net/article/129990.htm
微信公衆號
Java技術江湖
若是你們想要實時關注我更新的文章以及分享的乾貨的話，能夠關注個人公衆號【Java技術江湖】一位阿里 Java 工程師的技術小站，做者黃小斜，專一 Java 相關技術：SSM、SpringBoot、MySQL、分佈式、中間件、集羣、Linux、網絡、多線程，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！
Java工程師必備學習資源: 一些Java工程師經常使用學習資源，關注公衆號後，後臺回覆關鍵字 「Java」 便可免費無套路獲取。
我的公衆號：黃小斜
做者是 985 碩士，螞蟻金服 JAVA 工程師，專一於 JAVA 後端技術棧：SpringBoot、MySQL、分佈式、中間件、微服務，同時也懂點投資理財，偶爾講點算法和計算機理論基礎，堅持學習和寫做，相信終身學習的力量！
程序員3T技術學習資源： 一些程序員學習技術的資源大禮包，關注公衆號後，後臺回覆關鍵字 「資料」 便可免費無套路獲取。
- 1. Java基礎系列5：Java代碼的執行順序
- 2. 夯實Java基礎系列22：一文讀懂Java序列化和反序列化
- 3. 夯實Java基礎（八）——代碼塊
- 4. java靜態代碼塊和代碼塊執行順序
- 5. java 代碼塊執行順序
- 6. 【JAVA】代碼塊執行順序
- 7. Java類中代碼塊執行順序
- 8. java代碼塊執行順序
- 9. Java的代碼塊執行順序
- 10. Java代碼塊的執行順序
- 更多相關文章...
- • SQLite - Java - SQLite教程
- • Eclipse 代碼模板 - Eclipse 教程
- • ☆基於Java Instrument的Agent實現
- • Java Agent入門實戰（一）-Instrumentation介紹與使用
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java基礎系列5：Java代碼的執行順序
- 2. 夯實Java基礎系列22：一文讀懂Java序列化和反序列化
- 3. 夯實Java基礎（八）——代碼塊
- 4. java靜態代碼塊和代碼塊執行順序
- 5. java 代碼塊執行順序
- 6. 【JAVA】代碼塊執行順序
- 7. Java類中代碼塊執行順序
- 8. java代碼塊執行順序
- 9. Java的代碼塊執行順序
- 10. Java代碼塊的執行順序