相關閱讀

每篇一句

上帝給每個人都安排了幸福的一生，我們的任務就是把它走完

1、概述

誠如各位所知，java的三大特性：封裝、繼承、多型。其中繼承，是java中最有學問的一點也是最相對來說最難理解的一些東西，本文針對於此，做一些例項分析，希望能夠幫助大家理解java中的繼承機制

2、栗子

情況一：當父類和子類有同名同類型的屬性時，使用時需要注意

public class Main {
    public static void main(String[] args) {
        Parent chidParent = new Child();
        System.out.
 
println("Parent:" + chidParent.getAge()); //40
        System.out.println("Parent:" + chidParent.age); //18 這個結果你能接受嗎？哈哈
        Child child = Child.class.cast(chidParent);
        System.out.println("Child:" + child.getAge()); //40
        System.out.println("Child:" + child.age); //40
    }
}

@Getter
@Setter
 

class Child extends Parent {
    Integer age = 40; //名稱和父類的同名
}

@Getter
@Setter
class Parent {
    Integer age = 18;
}

我們發現，那個18為什麼會輸出出來呢？父類和子類的變數是同時存在的，即使是同名。子類中看到的是子類的變數，父類中看到的是父類中的變數，它們互相隱藏，而同名的方法則是實實在在的覆蓋（重寫），屬性不存在重寫喲。有了這個解釋，就好理解了吧
情況二：當父類和子類有同名***不同型別***的屬性時，使用時需要注意

public class Main {
    public
 
 static void main(String[] args) {
        // 報錯Error:(20, 12) java: com.sayabc.boot2demo1.main.Child中的getAge()
        // 無法覆蓋com.sayabc.boot2demo1.main.Parent中的getAge()
        // 返回型別java.lang.String與java.lang.Integer不相容
        Parent chidParent = new Child();
    }
}

@Getter
class Child extends Parent {
    String age = "40"; //名稱和父類的同名

    public void setAge(String age) {
        this.age = age;
    }
}

@Getter
class Parent {
    Integer age = 18;

    public void setAge(Integer age) {
        this.age = age;
    }
}

我們高興的發現，如果型別不同，編譯器還發現不了，但是一執行，就報錯啦。這算編譯器的bug嗎？哈哈
情況三：繼承中最基本的類載入順序，不做過多解釋。靜態程式碼塊只執行一次，並且優先於mai方法先執行

public class Main {
    public static void main(String[] args) {
        Parent chidParent = new Child();
    }
}

@Getter
class Child extends Parent {

    static {
        System.out.println("Child的靜態塊");
    }

    {
        System.out.println("Child的構造塊");
    }

    Child() {
        System.out.println("Child的構造方法");
    }
}

@Getter
class Parent {
    Integer age = 18;

    static {
        System.out.println("Parent的靜態塊");
    }

    {
        System.out.println("Parent的構造塊");
    }

    Parent() {
        System.out.println("Parent的構造方法");
    }
}

結果如下：

Parent的靜態塊
Child的靜態塊
Parent的構造塊
Parent的構造方法
Child的構造塊
Child的構造方法

備註：此處需要注意，此處子類沒有顯示呼叫super()，但父類的構造還是執行了的。但是，但是，但是，如果構造快為有參構造，請記得顯示呼叫super方法，否則父類是不能被初始化的。如果子類的構造器沒有顯示地呼叫超類的構造器，則將自動呼叫超類預設（沒有引數） 的構造器。如果超類沒有不帶引數的構造器，並且在子類的構造器又沒有顯式地呼叫超類的其他構造器，則 java 編譯器將報告錯誤

情況四：子類和父類有同名同類型的靜態常量的時候

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        System.out.println(parent.name); //fangshixiangParent
        Child child = new Child();
        System.out.println(child.name); //fangshixiangChild
    }
}

@Getter
@Setter
class Child extends Parent {
    static String name = "fangshixiangChild";
}

@Getter
@Setter
class Parent {
    static String name = "fangshixiangParent";
}

有了前面的基礎，這個現象就很好解釋了。同理：當有同名不同型別的屬性時，直接獲取屬性還是會各自獲取到自己的，但get方法就不行，就會報錯了。
情況五：靜態程式碼塊屬於類的，並且優先於main方法執行

public class StaticDemo1 {                             

    public static void main(String[] args) {
        StaticDemo1 t1=new StaticDemo1();    //第2步，初始化建構函式，i=9
        System.out.println(t1.i);            //第3步，按順序執行,9
        speak();                            //第4步，按順序執行，呼叫靜態函式
        
    }    
    static int i=1;                            //靜態變數存到靜態區域。    
    static void speak()                        //靜態函式存到靜態區域。呼叫時執行。
    {
        System.out.println("a");;
    }
    static {                                //第1步，靜態程式碼塊隨著類的載入,優先執行且只執行一次。i=3，i+3列印結果是4。
        i=i+3;
        System.out.println(i);
    }
    
    public StaticDemo1(){                    //構造方法，初始化時執行。
        i=i+5;                                //i=9
        System.out.println(i);    
    }
}

但是，但是，但是。如果StaticDemo1沒有new或者靜態方法沒有呼叫，靜態程式碼塊是不會被執行的哦，只有載入了才會執行，並且只執行一次
static塊真正的執行時機。如果瞭解JVM原理，我們知道，一個類的執行分為以下步驟：static程式碼塊真正執行時機
下面我們看看執行static塊的幾種情況：
1、第一次new A()的過程會列印""；因為這個過程包括了初始化
2、第一次Class.forName(“A”)的過程會列印""；因為這個過程相當於Class.forName(“A”,true,this.getClass().getClassLoader());
3、第一次Class.forName(“A”,false,this.getClass().getClassLoader())的過程則不會列印""。因為false指明瞭裝載類的過程中，不進行初始化。不初始化則不會執行static塊。

最後，附上兩張圖，大家可以明顯發發現一些端倪，希望對大家能有記憶作用哈：

圖一：構造程式碼塊是在初始化物件屬性（成員變數）之前執行的

圖二：@PostConstruct是物件的屬性都初始化ok了才去執行的。

特別的，這裡我介紹一下各種註解影響的執行順序，如下程式碼：

@Component  
public class InitBeanTest implements InitializingBean,ApplicationListener<ContextRefreshedEvent> {  
  
    @Resource  
    DemoService demoService;  
      
    public InitBeanTest() {     
           System.err.println("----> InitSequenceBean: constructor: "+demoService);     
        }  
  
    @PostConstruct  
    public void postConstruct() {  
        System.err.println("----> InitSequenceBean: postConstruct: "+demoService);  
    }  
  
    @Override  
    public void afterPropertiesSet() throws Exception {  
        System.err.println("----> InitSequenceBean: afterPropertiesSet: "+demoService);  
    }  
  
    @Override  
    public void onApplicationEvent(ContextRefreshedEvent arg0) {  
        System.err.println("----> InitSequenceBean: onApplicationEvent");  
    }  
  
}  

執行結果：

----> InitSequenceBean: constructor: null
----> InitSequenceBean: postConstruct: com.yiniu.kdp.service.impl.DemoServiceImpl@40fe544
----> InitSequenceBean: afterPropertiesSet: com.yiniu.kdp.service.impl.DemoServiceImpl@40fe544
----> InitSequenceBean: onApplicationEvent
----> InitSequenceBean: onApplicationEvent

根據執行結果，我們很容易的總結出來執行的順序。至於是什麼原因呢，下面給出一個簡單分析：

建構函式是每個類最先執行的，這個時候，bean屬性還沒有被注入。
postConstruct優先於afterPropertiesSet執行，這時屬性竟然也被注入了，這個時候需要記住啦
spring很多組建的初始化都放在afterPropertiesSet做。我們在做一些中介軟體想和spring一起啟動，可以放在這裡啟動。比如獲取到ApplicationContext上下文
onApplicationEvent屬於應用層的事件，最後被執行，很容易理解。注意，它出現了兩次，為什麼？因為bean注入了DemoService，spring容器會被重新整理。這個很容易被當作高階面試題的喲。換言之onApplicationEvent會被頻繁執行，需要使用它監聽，需要考慮效能問題以及重複執行的問題。很顯然，這是觀察者模式的經典應用。至於spring中觀察者模式的使用，我在後續文章中會重點分享，請持續關注

3、使用場景

各種設計模式，都會以此為依託，才能有更好的設計

4、最後

java的三大特性都非常的重要，如果不理解虛擬機器對類的一些處理，有時候會犯迷糊，影響邏輯的設計，所以此文用簡單用例希望能幫助大家理解。日後也許會持續更新

知識交流

若群二維碼失效，請加微訊號（或者掃描下方二維碼）：fsx641385712。
並且備註：“java入群” 字樣，會手動邀請入群