程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> JAVA編程入門知識 >> Java中一些基礎概念的使用詳解

Java中一些基礎概念的使用詳解

編輯:JAVA編程入門知識

  類的初始化順序
  在Java中,類裡面可能包含:靜態變量,靜態初始化塊,成員變量,初始化塊,構造函數。在類之間可能存在著繼承關系,那麼當我們實例化一個對象時,上述各部分的加載順序是怎樣的?

  首先來看代碼:
代碼如下:

class Parent
 {
     public static StaticVarible staticVarible= new StaticVarible("父類-靜態變量1");   
     public StaticVarible instVarible= new StaticVarible("父類-成員變量1");

     static
     {
         System.out.println("父類-靜態塊");
     }

     {
         System.out.println("父類-初始化塊");
     }

     public static StaticVarible staticVarible2= new StaticVarible("父類-靜態變量2");   
     public StaticVarible instVarible2= new StaticVarible("父類-成員變量2");

     public Parent()
     {
         System.out.println("父類-實例構造函數");
     }
 }

 class Child extends Parent
 {
     public static StaticVarible staticVarible= new StaticVarible("子類-靜態變量1");   
     public StaticVarible instVarible= new StaticVarible("子類-成員變量1");

     static
     {
         System.out.println("子類-靜態塊");
     }

     public Child()
     {
         System.out.println("子類-實例構造函數");
     }

     {
         System.out.println("子類-初始化塊");
     }

     public static StaticVarible staticVarible2= new StaticVarible("子類-靜態變量2");   
     public StaticVarible instVarible2= new StaticVarible("子類-成員變量2");

    
 }

 class StaticVarible
 {
     public StaticVarible(String info)
     {
         System.out.println(info);
     }
 }

  然後執行下面的語句:
代碼如下:

Child child = new Child();

輸出結果如下:
代碼如下:

父類-靜態變量1
父類-靜態塊
父類-靜態變量2
子類-靜態變量1
子類-靜態塊
子類-靜態變量2
父類-成員變量1
父類-初始化塊
父類-成員變量2
父類-實例構造函數
子類-成員變量1
子類-初始化塊
子類-成員變量2
子類-實例構造函數

  結論  
  從上述結果可以看出,在實例化一個對象時,各部分的加載順序如下:

  父類靜態成員/父類靜態初始化塊 -> 子類靜態成員/子類初始化塊 -> 父類成員變量/父類初始化塊 -> 父類構造函數 -> 子類成員變量/子類初始化塊 -> 子類構造函數

  和String相關的一些事兒
  首先,我們聊一聊Java中堆和棧的事兒。

•棧:存放基本類型,包括char/byte/short/int/long/float/double/boolean
•堆:存放引用類型,同時一般會在棧中保留一個指向它的指針,垃圾回收判斷一個對象是否可以回收,就是判斷棧中是否有指針指向堆中的對象。
  String作為一種特殊的數據類型,它不完全等同於基本類型,也不是全部的引用類型,許多面試題都有它的身影。

  String類型變量的存儲結構
  String的存儲結構分為兩部分,我們以String a = "abc";為例,描述String類型的存儲方式:

  1)在棧中創建一個char數組,值分為是'a','b','c'。

  2)在堆中創建一個String對象。

  Java中的字符串池
  為了節省空間和資源,JVM會維護一個字符串池,或者說會緩存一部分曾經出現過的字符串。

  例如下面的代碼:
代碼如下:

String v1 = "ab";
String v2 = "ab";

  實際上,v1==v2,因為JVM在v1聲明後,已經對“ab”進行了緩存。

  那麼JVM對字符串進行緩存的依據是什麼?我們來看下面的代碼,非常有意思:
代碼如下:

public class StringTest {
     public static final String constValue = "ab";
     public static final String staticValue;

     static
     {
         staticValue="ab";
     }

     public static void main(String[] args)
     {
         String v1 = "ab";
         String v2 = "ab";
         System.out.println("v1 == v2 : " + (v1 == v2));
         String v3 = new String("ab");
         System.out.println("v1 == v3 : " + (v1 == v3));
         String v4 = "abcd";
         String v5 = "ab" + "cd";
         System.out.println("v4 == v5 : " + (v4 == v5));
         String v6 = v1 + "cd";
         System.out.println("v4 == v6 : " + (v4 == v6));
         String v7 = constValue + "cd";
         System.out.println("v4 == v7 : " + (v4 == v7));
         String v8 = staticValue + "cd";
         System.out.println("v4 == v8 : " + (v4 == v8));
         String v9 = v4.intern();
         System.out.println("v4 == v9 :" + (v4 == v9));
         String v10 = new String(new char[]{'a','b','c','d'});
         String v11 = v10.intern();
         System.out.println("v4 == v11 :" + (v4 == v11));
         System.out.println("v10 == v11 :" + (v10 == v11));
     }
 }

  請注意它的輸出結果:
代碼如下:

v1 == v2 : true
v1 == v3 : false
v4 == v5 : true
v4 == v6 : false
v4 == v7 : true
v4 == v8 : false
v4 == v9 :true
v4 == v11 :true
v10 == v11 :false

  我們會發現,並不是所有的判斷都返回true,這似乎和我們上面的說法有矛盾了。其實不然,因為

  結論
  1. JVM只能緩存那些在編譯時可以確定的常量,而非運行時常量。

    上述代碼中的constValue屬於編譯時常量,而staticValue則屬於運行時常量。

  2. 通過使用 new方式創建出來的字符串,JVM緩存的方式是不一樣的。

    所以上述代碼中,v1不等同於v3。

  String的這種設計屬於享元模式嗎?
  這個話題比較有意思,大部分講設計模式的文章,在談到享元時,一般就會拿String來做例子,但它屬於享元模式嗎?

  字符串與享元的關系,大家可以參考下面的文章:深入C#字符串和享元(Flyweight)模式的使用分析
  字符串的反轉輸出
  這種情況下,一般會將字符串看做是字符數組,然後利用反轉數組的方式來反轉字符串。

  眼花缭亂的方法調用
  有繼承關系結構中的方法調用
  繼承是面向對象設計中的常見方式,它可以有效的實現”代碼復用“,同時子類也有重寫父類方法的自由,這就對到底是調用父類方法還是子類方法帶來了麻煩。

  來看下面的代碼:
代碼如下:

public class PropertyTest {

     public static void main(String[] args)
     {
         ParentDef v1 = new ParentDef();
         ParentDef v2 = new ChildDef();
         ChildDef v3 = new ChildDef();
         System.out.println("=====v1=====");
         System.out.println("staticValue:" + v1.staticValue);
         System.out.println("value:" + v1.value);
         System.out.println("=====v2=====");
         System.out.println("staticValue:" + v2.staticValue);
         System.out.println("value:" + v2.value);
         System.out.println("=====v3=====");
         System.out.println("staticValue:" + v3.staticValue);
         System.out.println("value:" + v3.value);
     }
 }

 class ParentDef
 {
     public static final String staticValue = "父類靜態變量";
     public String value = "父類實例變量";
 }

 class ChildDef extends ParentDef
 {
     public static final String staticValue = "子類靜態變量";
     public String value = "子類實例變量";
 }

  輸出結果如下:
代碼如下:

=====v1=====
staticValue:父類靜態變量
value:父類實例變量
=====v2=====
staticValue:父類靜態變量
value:父類實例變量
=====v3=====
staticValue:子類靜態變量
value:子類實例變量

  結論
  對於調用父類方法還是子類方法,只與變量的聲明類型有關系,與實例化的類型沒有關系。

  到底是值傳遞還是引用傳遞
  對於這個話題,我的觀點是值傳遞,因為傳遞的都是存儲在棧中的內容,無論是基本類型的值,還是指向堆中對象的指針,都是值而非引用。並且在值傳遞的過程中,JVM會將值復制一份,然後將復制後的值傳遞給調用方法。

  按照這種方式,我們來看下面的代碼:
代碼如下:

public class ParamTest {

     public void change(int value)
     {
         value = 10;
     }

     public void change(Value value)
     {
         Value temp = new Value();
         temp.value = 10;
         value = temp;
     }

     public void add(int value)
     {
         value += 10;
     }

     public void add(Value value)
     {
         value.value += 10;
     }

     public static void main(String[] args)
     {
         ParamTest test = new ParamTest();
         Value value = new Value();
         int v = 0;
         System.out.println("v:" + v);
         System.out.println("value.value:" + value.value);
         System.out.println("=====change=====");
         test.change(v);
         test.change(value);
         System.out.println("v:" + v);
         System.out.println("value.value:" + value.value);
         value = new Value();
         v = 0;
         System.out.println("=====add=====");
         test.add(v);
         test.add(value);
         System.out.println("v:" + v);
         System.out.println("value.value:" + value.value);
     }
 }

 class Value
 {
     public int value;
 }

  它的輸出結果:
代碼如下:

v:0
value.value:0
=====change=====
v:0
value.value:0
=====add=====
v:0
value.value:10

  我們看到,在調用change方法時,即使我們傳遞進去的是指向對象的指針,但最終對象的屬性也沒有變,這是因為在change方法體內,我們新建了一個對象,然後將”復制過的指向原對象的指針“指向了“新對象”,並且對新對象的屬性進行了調整。但是“復制前的指向原對象的指針”依然是指向“原對象”,並且屬性沒有任何變化。

  final/finally/finalize的區別
  final可以修飾類、成員變量、方法以及方法參數。使用final修飾的類是不可以被繼承的,使用final修飾的方法是不可以被重寫的,使用final修飾的變量,只能被賦值一次。

  使用final聲明變量的賦值時機:

  1)定義聲明時賦值

  2)初始化塊或靜態初始化塊中

  3)構造函數

  來看下面的代碼:
代碼如下:

class FinalTest
 {
     public static final String staticValue1 = "靜態變量1";
     public static final String staticValue2;

     static
     {
         staticValue2 = "靜態變量2";
     }

     public final String value1 = "實例變量1";
     public final String value2;
     public final String value3;

     {
         value2 = "實例變量2";
     }

     public FinalTest()
     {
         value3 = "實例變量3";
     }
 }

  finally一般是和try...catch放在一起使用,主要用來釋放一些資源。

  我們來看下面的代碼:
代碼如下:

public class FinallyTest {

     public static void main(String[] args)
     {
         finallyTest1();
         finallyTest2();
         finallyTest3();
     }

     private static String finallyTest1()
     {
         try
         {
             throw new RuntimeException();
         }
         catch(Exception ex)
         {
             ex.printStackTrace();
         }
         finally
         {
             System.out.println("Finally語句被執行");
         }
         try
         {
             System.out.println("Hello World");
             return "Hello World";
         }
         catch(Exception ex)
         {
             ex.printStackTrace();
         }
         finally
         {
             System.out.println("Finally語句被執行");
         }
         return null;
     }

     private static void finallyTest2()
     {
         int i = 0;
         for (i = 0; i < 3; i++)
         {
             try
             {
                 if (i == 2) break;
                 System.out.println(i);
             }
             finally
             {
                 System.out.println("Finally語句被執行");
             }
         }
     }

     private static Test finallyTest3()
     {
         try
         {
             return new Test();
         }
         finally
         {
             System.out.println("Finally語句被執行");
         }
     }
 }

  執行結果如下:
代碼如下:

java.lang.RuntimeException
    at sample.interview.FinallyTest.finallyTest1(FinallyTest.java:16)
    at sample.interview.FinallyTest.main(FinallyTest.java:7)
Finally語句被執行
Hello World
Finally語句被執行

Finally語句被執行

Finally語句被執行
Finally語句被執行
Test實例被創建
Finally語句被執行

  注意在循環的過程中,對於某一次循環,即使調用了break或者continue,finally也會執行。

  finalize則主要用於釋放資源,在調用GC方法時,該方法就會被調用。

  來看下面的示例:
代碼如下:

class FinalizeTest
 {
     protected void finalize()
     {
         System.out.println("finalize方法被調用");
     }

     public static void main(String[] args)
     {
         FinalizeTest test = new FinalizeTest();
         test = null;
         Runtime.getRuntime().gc();
     }
 }

  執行結果如下:
代碼如下:

finalize方法被調用

  關於基本類型的一些事兒
  基本類型供分為9種,包括byte/short/int/long/float/double/boolean/void,每種基本類型都對應一個“包裝類”,其他一些基本信息如下:
代碼如下:

. 基本類型:byte 二進制位數:8
. 包裝類:java.lang.Byte
. 最小值:Byte.MIN_VALUE=-128
. 最大值:Byte.MAX_VALUE=127
. 基本類型:short 二進制位數:16
. 包裝類:java.lang.Short
. 最小值:Short.MIN_VALUE=-32768
. 最大值:Short.MAX_VALUE=32767
. 基本類型:int 二進制位數:32
. 包裝類:java.lang.Integer
. 最小值:Integer.MIN_VALUE=-2147483648
. 最大值:Integer.MAX_VALUE=2147483647
. 基本類型:long 二進制位數:64
. 包裝類:java.lang.Long
. 最小值:Long.MIN_VALUE=-9223372036854775808
. 最大值:Long.MAX_VALUE=9223372036854775807
. 基本類型:float 二進制位數:32
. 包裝類:java.lang.Float
. 最小值:Float.MIN_VALUE=1.4E-45
. 最大值:Float.MAX_VALUE=3.4028235E38
. 基本類型:double 二進制位數:64
. 包裝類:java.lang.Double
. 最小值:Double.MIN_VALUE=4.9E-324
. 最大值:Double.MAX_VALUE=1.7976931348623157E308
. 基本類型:char 二進制位數:16
. 包裝類:java.lang.Character
. 最小值:Character.MIN_VALUE=0
. 最大值:Character.MAX_VALUE=65535

  關於基本類型的一些結論(來自《Java面試解惑》)
•未帶有字符後綴標識的整數默認為int類型;未帶有字符後綴標識的浮點數默認為double類型。
•如果一個整數的值超出了int類型能夠表示的范圍,則必須增加後綴“L”(不區分大小寫,建議用大寫,因為小寫的L與阿拉伯數字1很容易混淆),表示為long型。
•帶有“F”(不區分大小寫)後綴的整數和浮點數都是float類型的;帶有“D”(不區分大小寫)後綴的整數和浮點數都是double類型的。
•編譯器會在編譯期對byte、short、int、long、float、double、char型變量的值進行檢查,如果超出了它們的取值范圍就會報錯。
•int型值可以賦給所有數值類型的變量;long型值可以賦給long、float、double類型的變量;float型值可以賦給float、double類型的變量;double型值只能賦給double類型變量。
  關於基本類型之間的轉換
  下面的轉換是無損精度的轉換:

•byte->short
•short->int
•char->int
•int->long
•float->double
  下面的轉換是會損失精度的:

•int->float
•long->float
•long->double
  除此之外的轉換,是非法的。

  和日期相關的一些事兒
  Java中,有兩個類和日期相關,一個是Date,一個是Calendar。我們來看下面的示例:
代碼如下:

public class DateTest {

     public static void main(String[] args) throws ParseException
     {
         test1();
         test2();
         test3();
     }

     private static void test1() throws ParseException
     {
         Date date = new Date();
         System.out.println(date);
         DateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
         System.out.println(sf.format(date));
         String formatString = "2013-05-12";
         System.out.println(sf.parse(formatString));
     }

     private static void test2()
     {
         Date date = new Date();
         System.out.println("Year:" + date.getYear());
         System.out.println("Month:" + date.getMonth());
         System.out.println("Day:" + date.getDate());
         System.out.println("Hour:" + date.getHours());
         System.out.println("Minute:" + date.getMinutes());
         System.out.println("Second:" + date.getSeconds());
         System.out.println("DayOfWeek:" + date.getDay());
     }

     private static void test3()
     {
         Calendar c = Calendar.getInstance();
         System.out.println(c.getTime());
         System.out.println(c.getTimeZone());
         System.out.println("Year:" + c.get(Calendar.YEAR));
         System.out.println("Month:" + c.get(Calendar.MONTH));
         System.out.println("Day:" + c.get(Calendar.DATE));
         System.out.println("Hour:" + c.get(Calendar.HOUR));
         System.out.println("HourOfDay:" + c.get(Calendar.HOUR_OF_DAY));
         System.out.println("Minute:" + c.get(Calendar.MINUTE));
         System.out.println("Second:" + c.get(Calendar.SECOND));
         System.out.println("DayOfWeek:" + c.get(Calendar.DAY_OF_WEEK));
         System.out.println("DayOfMonth:" + c.get(Calendar.DAY_OF_MONTH));
         System.out.println("DayOfYear:" + c.get(Calendar.DAY_OF_YEAR));
     }
 }

  輸出結果如下:
代碼如下:

Sat May 11 13:44:34 CST 2013
-05-11
Sun May 12 00:00:00 CST 2013
Year:113
Month:4
Day:11
Hour:13
Minute:44
Second:35
DayOfWeek:6
Sat May 11 13:44:35 CST 2013
sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null]
Year:2013
Month:4
Day:11
Hour:1
HourOfDay:13
Minute:44
Second:35
DayOfWeek:7
DayOfMonth:11
DayOfYear:131

  需要注意的是,Date中的getxxx方法已經變成deprecated了,因此我們盡量使用calendar.get方法來獲取日期的細節信息。
  另外,注意DateFormat,它不僅可以對日期的輸出進行格式化,而且可以逆向操作,將符合Format的字符串轉換為日期類型。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved