一道面試題引發的思考:(1)

tommego 發布于2019-08-14 12:34 / 2377人閱讀

這是網易2015校招Java面試題,直接上題目。

題目

package com.mousycoder.staticTest;

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    {
        System.out.println("I’m B class");
    }
    static {
        
        System.out.println("static B");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}

class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }

    {
        System.out.println("I’m A class");
    }
    static {
        System.out.println("static A");
    }
}

答案

static A
static B
I’m A class
HelloA
I’m B class
HelloB()

考察點

static 相關知識

非靜態代碼塊相關知識

類加載順序

解析

存在父子關系，又有靜態代碼塊，先執行父類靜態代碼塊，再執行子類靜態代碼塊，故打印static A static B

存在父子關系，又有非靜態代碼塊，先執行父類非靜態代碼塊，父類構造器，再執行子類非靜態代碼塊，子類構造器故打印I"m A class HelloA I"m B class HelloB

結論

靜態代碼塊=>非靜態代碼塊=>構造方法

父子關系：父類靜態代碼塊=>子類靜態代碼塊=>父類非靜態代碼塊=>父類構造函數=>子類非靜態代碼塊=>子類構造函數

擴展知識 非靜態代碼塊

{ 
   System.out.println("I"m B class");
}

這個叫做非靜態代碼塊，也叫普通代碼塊，在每個類創建前(構造函數之前)調用，不創建對象的時候，不被調用，代碼塊中定義的變量都是局部變量，如果有父子關系的話，先執行父類的，再執行子類的。非靜態代碼塊屬于對象，靜態代碼塊屬于類。

package com.mousycoder.staticTest;

public class Child extends Father{
    
    static {
        System.out.println("child-->static");
    }
    
    private int n = 20;
    
    {
        System.out.println("Child Non-Static");
        n = 30;
    }
    
    public int x = 200;
    
    public Child() {
        this("The other constructor");
        System.out.println("child constructor body: " + n);
    }
    
    public Child(String s) {
        System.out.println(s);
    }
    
    public void age() {
        System.out.println("age=" + n);
    }
    
    public void printX() {
        System.out.println("x=" + x);
    }
    
    public static void main(String[] args) {
        new Child().printX();
    }
}

class Father {
    
    static {
        //System.out.println("n+"+n);
            //當n定義在下面時，會提示Cannot reference a field before it is defined，
            //所以必須把n定義移到上面才可以輸出
        System.out.println("super-->static");
    }
    
    public static int n = 10;
    public int x = 100;
    
    public Father() {
        System.out.println("super"s x=" + x);
        age();
    }
    
    {
        System.out.println("Father Non-Static");
    }
    
    public void age(){
        System.out.println("nothing");
    }
}

結果:

super-->static
child-->static
Father Non-Static
super"s x=100
age=0
Child Non-Static
The other constructor
child constructor body: 30
x=200

解析：

先執行靜態代碼塊，有父子關系，先執行父類靜態代碼塊，打印super-->static

執行子類靜態代碼塊，打印child-->static

實例化子類的時候，先實例化父類，在調用父類構造方法之前，先調用父類非靜態代碼塊，打印Father Non-Static

實例化父類，調用父類構造方法，執行第一句 System.out.println("super"s x=" + x); 在調用構造方法之前，成員變量x 已經被賦值為100，打印super"s x=100

執行age()方法，因為main方法中真正實例化的是子類，子類又重寫了父類的age方法，所以執行子類的age方法，此時子類還沒初始化，默認n=0 ,打印age=0

實例化子類，調用子類構方法之前，調用子類非靜態代碼塊，打印Child Non-Static

調用子類構造方法，執行this("The other constructor"),調用子類的Child（String s），打印The other constructor

執行System.out.println("child constructor body: " + n); 初始化之前成員變量初始值為20，執行完非靜態代碼塊后 n被修改成30 ，所以這里n =30 打印child constructor body: 30

執行printX()方法，打印x = 200

注意點：

子類重寫父類的方法

雖然非靜態代碼塊里是局部變量，但是可以改變類的成員變量的值

靜態代碼塊

static {
  System.out.println("static B");
}

屬于靜態代碼塊，使用場景：1.想用一個存儲區域來保存一個特定的數據，不想創建對象 2.創建一個特殊的方法，與這個類的對象沒有關聯，即使沒創建對象，也可以調用

靜態變量

靜態變量也叫做static變量，靜態變量和非靜態變量的區別在于靜態變量被所有的對象所共享，在內存中只有一個副本，它當且僅當類初次加載時會被初始化，而非靜態變量是對象所擁有的，在創建對象的時候被初始化，存在多個副本，各個對象擁有的副本互不影響 好處：1.可以用類名直接訪問(方便),也可以用對象訪問(不推薦) 2.只分配一次內存，節省空間

靜態方法

靜態方法就是不會被this和super的方法。特點：1.在static方法內部不能調用所屬類的實例變量和實例方法（非靜態方法），但是可以在沒有創建任何對象的前提下，僅僅通過類本身(類名)來調用static方法 2.main方法就是static 方法，因為執行main方法的時候，沒有創建任何對象，只能通過類名去訪問 3.沒有顯示聲明，類的構造器也是靜態方法,參考：實例構造器是不是靜態方法？
常見的錯誤Cannot make a static reference to the non-static field 就是靜態方法中引用了非靜態的的變量，靜態變量是不依賴對象而存在的，非靜態變量是依賴對象而存在的

示例：非靜態方法可以訪問靜態變量、方法，靜態方法是不可以訪問非靜態變量，方法

package com.mousycoder.staticTest;

public class Test {
    
    private static String str1 = "111";
    
    private String str2 = "ffffd";
    
    
    public Test() {
    }
    
    public  void print1() {
        System.out.println(str1);
        System.out.println(str2);
        print1();
    }
    
    
    public static void print2(){
        System.out.println(str1);
        System.out.println(str2);  //報錯  Cannot make a static reference to the non-static field
        print1(); //報錯
    }

}

靜態代碼塊

由static 關鍵字修飾的代碼塊叫做靜態代碼塊，特點：用于提高程序性能，類在初始化的時候，JVM會按照他們在類中出現的順序加載static 代碼塊，并且只會執行一遍

示例：只生成一個String s 對象和一個String m 對象

package com.mousycoder.staticTest;

import java.util.Date;
public class HelloStatic {
    
    public static String s ;
    
    public static String m ;
    
    static {
        s = new String("hell");
        m = new String("0");
    }
        String hello() {
            String s = "hell";
            String m = "o";
            return s + m;
        }
        
        public static void main(String[] args) {
            Date start = new Date();
            for (int i = 0; i < 1000000000 ; i++) {
                HelloStatic h = new HelloStatic();
                h.hello();
            }
            Date end = new Date();
            System.out.println(end.getTime() - start.getTime());
        }

}

耗時：12ms

示例：生成N個String s和String m對象

package com.mousycoder.staticTest;

import java.util.Date;

public class Hello {
        
        String hello() {
            String s = new String("hell");
            String m = new String("o");
            return s + m;
        }
        
        public static void main(String[] args) {
            Date start = new Date();
            for (int i = 0; i < 1000000000; i++) {
                Hello h = new Hello();
                h.hello();
            }
        
            Date end = new Date();
            System.out.println(end.getTime() - start.getTime());
        }
        
}

所用時間 9645ms

公共的變量應該放到static里初始化，有利于提高效率

靜態變量訪問權

static 變量是被所有對象共享的，只要該對象有權限，就可以訪問該變量

package com.mousycoder.staticTest;

public class Main {

    static int value = 33;
 
    public static void main(String[] args) throws Exception{
        new Main().printValue();
    }
 
    private void printValue(){
        int value = 3;
        System.out.println(this.value);
    }
}

該輸出為：33 ,new Main()創建了一個對象，通過this.value是訪問的該對象的value 而int value = 3 是局部變量，并不是和該對象相關聯的，因為static變量是共享的，所以該對象可以訪問到value 值為 33 ，把this 去掉則結果為 3

靜態變量相關面試題

package com.mousycoder.staticTest;

public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }
     
    public Test() {
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new MyClass();
    }
}
 
class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}
 
 
class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }
     
    public MyClass() {
        System.out.println("myclass constructor");
    }
}

順序是：

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

執行順序

test static =>new MyClass() => myclass static => new MyClass() => person static => Person person = new Person("Test") => person Test => Person person = new Person("Test") => test constructro => Person person = new Person("Myclass") => person MyClass => Person person = new Person("MyClass") => myclass contructor

說明：

執行main方法，實例化MyClass

發現MyClass 有父類Test，首先實例化Test

加載Test類，這個時候會執行static方法，打印 test static ,

然后要實例化MyClass 類，加載MyClass類，執行static方法，打印myclass static

在所有類按照順序都加載完畢后，開始一個一個實例化類，先實例化父對象 Test類

在實例化之前，要先初始化成員變量，這個時候會執行Person p = new Person("Test"),這個時候發現Person類還沒有被加載過，因此先加載Person類

執行Person類的static方法，打印person static 接著實例化Person p = new Person("Test") 調用Person的構造方法，打印person Test

然后開始調用Test的構造方法,打印test constructor,Test類初始化完畢

開始實例化Myclass類，首先還是初始化MyClass的成員變量 ,因為Person已經加載過了,所以只執行一遍,只需根據類的模板執行其構造方法，來復制成另外一個副本,此時打印person MyClass

最后執行Myclass的構造方法，打印myclass constructor

總結：

非靜態代碼塊=>初始化成員變量=>非靜態代碼塊=>構造器方法

感謝您的耐心閱讀，如果您發現文章中有一些沒表述清楚的，或者是不對的地方，請給我留言，你的鼓勵是作者寫作最大的動力，
如果您認為本文質量不錯，讀后覺得收獲很大，不妨小額贊助我一下，讓我更有動力繼續寫出高質量的文章。

支付寶

微信

作者 : @mousycoder

原文出處 : http://mousycoder.com/2015/10/12/thinking-of-interview-question-1/

創作時間：2015-7-1

更新時間：2015-10-14

GPU云服務器云服務器 linux的面試題 js的基礎面試題面試題棧面試題

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/64566.html

一道面試題引發的思考 --- Event Loop

摘要：想必面試題刷的多的同學對下面這道題目不陌生，能夠立即回答出輸出個，可是你真的懂為什么嗎為什么是輸出為什么是輸出個這兩個問題在我腦邊縈繞。同步任務都好理解，一個執行完執行下一個。本文只是我對這道面試題的一點思考，有誤的地方望批評指正。想必面試題刷的多的同學對下面這道題目不陌生，能夠立即回答出輸出10個10，可是你真的懂為什么嗎？為什么是輸出10？為什么是輸出10個10？這兩個問題在我腦...

betacat 2019-08-23 14:13 評論0 收藏0
一道前端面試題引發的思考

摘要：直接開始題目是厲害了說句實話開發中誰寫成這樣保證會被打死。不過面試就是面試，有面試官的考量點。官方是這么說的。結果完美，不過小姐姐的意思是數組的方法會自動觸發數組的。直接開始題目是 if(a==1 && a==2 && a==3){ alert(厲害了) } 說句實話開發中誰寫成這樣保證會被打死。不過面試就是面試，有面試官的考量點。我理解的點有兩個 1、隱式類型轉換先說...

gaomysion 2019-08-23 18:29 評論0 收藏0
一道簡單的面試題引發的思考

摘要：另一個問題，就是我下面要提及的作用域問題，我當時思考的時間太久了這是回憶中的面試題實際略有差異，不糾結了說一下腳本的運行結果引用錯誤中給出的錯誤提示。版權聲明：此文首發于我的簡書賬號人生還有多少個二十年，轉載請注明出處。此處有幾百字嘮叨：　　當天，我早早起床，跨越上百公里，高德導航，路人指點，跌跌撞撞到達招聘會現場，當時已是中午十二點半，吃了午餐（半瓶白開水），開始準備投遞...

wpw 2019-08-22 10:49 評論0 收藏0
一道面試題引發的思考 --- 理解 new 運算符

摘要：首先，我先去上搜索了的定義運算符創建一個用戶定義的對象類型的實例或具有構造函數的內置對象的實例。今天看到一道面試題，如下，問: 實例化 Person 過程中，Person返回什么（或者 p 等于什么）？ function Person(name) { this.name = name return name; } let p = new Person(Tom); 說實...

shengguo 2019-08-23 14:11 評論0 收藏0
一道面試題引發的思考:(2)

摘要：由虛擬機生成并拋出，，屬于系統內部錯誤或者資源耗盡等嚴重情況，屬于需要擔負的責任，這一類異常事件是無法恢復或者不可能捕獲的，將導致應用程序中斷，但是自定義是可以捕獲的。題目 showImg(http://img-storage.qiniudn.com/15-9-22/50608386.jpg); 答案：D 分析 Java 異常的結構體系 showImg(http://img-stor...

stefan 2019-08-14 12:33 評論0 收藏0
一道面試題引發的思考

摘要：下面我們來使用面向對象類圖這里就不再畫了首先面試題中所提到的我們都可以看成類，比如停車場是一個類吧，它里面的車位是一個類吧，攝像頭，屏幕。。。以下是某場的一道面試題(大概): 1、一個停車場，車輛入場時，攝像頭記錄下車輛信息2、屏幕上顯示所接收的車輛的信息情況(車牌號)以及各層車位的車位余量3、停車場一共四層車位，其中的三層都為普通車位，還有一層為特殊車位(體現在停車計費價格上面的不...

Apollo 2019-08-30 11:04 評論0 收藏0