Java筆記 —— 初始化

来源:https://www.cnblogs.com/huangzenglie/archive/2018/04/13/8813008.html
-Advertisement-
Play Games

閱讀目錄 屬性初始化和構造器調用 初始化的順序 靜態塊和非靜態塊 初始化的方式 數組初始化 閱讀目錄 閱讀目錄 屬性初始化和構造器調用 初始化的順序 靜態塊和非靜態塊 初始化的方式 數組初始化 屬性初始化和構造器調用 初始化的順序 靜態塊和非靜態塊 初始化的方式 數組初始化 一、屬性初始化和構造器調 ...


閱讀目錄

一、屬性初始化和構造器調用

1）編譯器會為屬性指定一個預設的初始值，例如：int i; 預設初始值為 0，  double d; 預設初始值為0.0

2）局部變數使用前必須由程式員指定初始值

3）在構造器被調用之前，屬性就被初始化了

例1：


package com.example;

public class Values{
	private boolean bt;
	private char c;
	private byte b;
	private short s;
	private int i;
	private float f;
	private double d;
	private Values v;
	
	public void show(){
		System.out.println("屬性的預設初始化值：");
		System.out.println("boolean: " + bt);
		System.out.println("char: " + c);
		System.out.println("byte: " + b);
		System.out.println("short: " + s);
		System.out.println("int: " + i);
		System.out.println("float: " + f);
		System.out.println("double: " + d);
		System.out.println("Values: " + v);
	}
}



package com.example;

public class Test{
	public static void main(String[] args){
		Values val = new Values();
		val.show();
	}
}


	
運行結果為：

屬性的預設初始化值：
boolean: false
char: 
byte: 0
short: 0
int: 0
float: 0.0
double: 0.0
Values: null
  • 編譯器為所有的屬性都指定了一個預設初始值
  • 編譯器為對象的引用指定的預設初始值是 null，例如：例子中的 private Values v;
  • 編譯器為 char 類型指定的初始值是0（ASCII 中的 NUL），是空字元，這裡以空白表示

例2：

	
package com.example;

public class Man{
	public void speak(){
		int i;
		System.out.println("i = " + i); //  error，i 是局部變數，局部變數使用之前必須要初始化
	}
}

例3：


package com.example;

public class Man{
	public Man(int i){
		System.out.println("Man" + "(" + i + ")");
	}
}



package com.example;

public class Woman{
	public Man m1 = new Man(1);
	public Man m2 = new Man(2);
	
	public Woman(){
		System.out.println("Woman()");
	}
	
	public  Man m3 = new Man(3);
}



package com.example;

public class Test{
	public static void main(String[] args){
		new Woman();
	}
}



運行結果為：

Man(1)
Man(2)
Man(3)
Woman()
  • 這個例子不是使用系統的預設值對屬性進行初始化，而是通過我指定的值對屬性進行初始化
  • Woman 類中有三個屬性 m1，m2，m3 和一個 構造器 Woman()，從運行結果可以看出：屬性先被初始化，然後構造器才被調用
  • 屬性先被初始化這一特性與屬性的位置無關，例如：Woman 類中 m3 就位於構造器的後面，但 m3 也在構造器被調用之前就已經被初始化了

[ 返回頂部 ]


二、初始化的順序

1）屬性分為靜態屬性和非靜態屬性，且靜態屬性比非靜態屬性先初始化，即初始化順序為：靜態屬性 -> 非靜態屬性 -> 構造器調用

2）靜態屬性只會在創建對象或者被直接調用的時候初始化（在主類中靜態屬性也會被初始化），非靜態屬性只會在創建對象的時候初始化

3）無論創建多少個對象，靜態屬性只占用一塊存儲空間，所以靜態屬性只會初始化一次，而非靜態屬性在每次創建對象時都會初始化

4）含有繼承關係的初始化：當創建一個子類對象時，該對象會包含一個父類的對象，那麼保證父類對象初始化的方法是：在子類構造器中調用父類構造器

例1：


package com.example;

public class Pear{
	public Pear(int i){
		System.out.println("Pear" + "(" + i + ")");
	}
}


	
package com.example;

public class Apple{
	public Pear p1 = new Pear(1);
	public static Pear p2 = new Pear(2);
	
	public Apple(){
		System.out.println("Apple()");
	}
	
	public static Pear p3 = new Pear(3);
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		new Apple();
	}
}
	

	
運行結果：

Pear(2)
Pear(3)
Pear(1)
Apple()
  • 該例子中用 new 創建了 Apple 對象，所以 Apple 類中的靜態屬性和非靜態屬性都會初始化
  • 初始化順序：靜態屬性 -> 非靜態屬性 -> 構造器調用，例如：例子中先輸出 Pear(2) 和 Pear(3)，然後輸出 Pear(1)，最後調用 Apple() 構造器，所以是先初始化靜態屬性 p2 和 p3，然後初始化非靜態屬性 p1，最後調用構造器 Apple()

例2：

	
package com.example;

public class Pear{
	public Pear(int i){
		System.out.println("Pear" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Apple{
	public static String color = "red";
	public static int number = 10;
	public String size = "big";
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		System.out.println("Hello World !");
		System.out.println("color: " + Apple.color);
	}
	static Pear p1 = new Pear(1);
	static Pear p2 = new Pear(2);
	Pear p3 = new Pear(3);
}
	

	
運行結果：
	
Pear(1)
Pear(2)
Hello World !
color: red
  • Test 類是主類，所以靜態屬性 p1 和 p2 都會初始化。非靜態屬性 p3 不會初始化，是因為我們沒有創建 Test 對象
  • Apple 類中有兩個靜態屬性和一個非靜態屬性，該例子中調用了 Apple.color ，靜態屬性 color 在調用的時候會初始化為 red，而靜態屬性 number 和非靜態屬性 size 沒有被調用，也沒有創建對象，所以此時它們不會初始化

例3：

	
package com.example;

public class Cat{
	public Cat(int i){
		System.out.println("Cat" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Dog{
	public Cat c1 = new Cat(1);
	public static Cat c2 = new Cat(2);
	
	public Dog(){
		System.out.println("Dog()");
	}
	
	public static Cat c3 = new Cat(3);
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		System.out.println("第一次創建對象");
		Dog d1 = new Dog();
		System.out.println("第二次創建對象");
		Dog d2 = new Dog();
	}
}
	

	
運行結果：

第一次創建對象
Cat(2)
Cat(3)
Cat(1)
Dog()
第二次創建對象
Cat(1)
Dog()
  • 第一次創建對象的時候，靜態屬性和非靜態屬性都初始化了，但是第二次創建對象的時候，只有非靜態屬性會再次初始化，靜態屬性只初始化一次

例4：

父類不含構造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父類
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
}
	

	
package com.example;

public class Man extends Person{ // 子類
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){
		System.out.println("Man()");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		new Man();							
	}
}
	

	
運行結果：

T(4)
T(6)
T(1)
T(3)
T(5)
T(2)
Man()
  • 某個類不含構造器時，編譯器會為這個類生成一個預設構造器，該生成的預設構造器是一個無參構造器。這些操作是在編譯時完成的，所以我們看不見
  • 當父類含有預設構造器時，編譯器會自動在子類的構造器中調用父類的構造器來對父類進行初始化。這個過程也是在編譯時完成的，所以我們看不見
  • 初始化的順序：父類靜態屬性 -> 子類靜態屬性 -> 父類非靜態屬性 -> 子類非靜態屬性 -> 調用子類構造器

父類含有無參構造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父類
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
	
	public Person(){ // 無參構造器
		System.out.println("Person()");
	}
}
	

	
package com.example;

public class Man extends Person{ // 子類
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){
		System.out.println("Man()");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		new Man();							
	}
}
	

	
運行結果：

T(4)
T(6)
T(1)
T(3)
T(5)
Person()
T(2)
Man()
  • 父類含有無參構造器時和父類含有預設構造器時差不多，編譯器會自動在子類的構造器中調用父類的構造器來對父類進行初始化
  • 不同的是，當我們創建了構造器之後，編譯器就不會再為類創建一個預設構造器了
  • 初始化順序：父類靜態屬性 -> 子類靜態屬性 -> 父類非靜態屬性 -> 父類構造器調用 -> 子類非靜態屬性 -> 子類構造器調用

父類只含有有參構造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父類
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
	
	public Person(int i){
	System.out.println("Person" + "(" + i + ")"); // 有參構造器
	}
}
	

	
package com.example;

public class Man extends Person{ // 子類
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){
		super(1); // super 關鍵字表示調用父類構造器，且必須位於子類構造器的第一行，每個子類的構造器只能調用父類構造器一次
		System.out.println("Man()");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		new Man();							
	}
}
	

	
運行結果：

T(4)
T(6)
T(1)
T(3)
T(5)
Person(1)
T(2)
Man()
  • 當父類只有有參構造器時，子類構造器中必須使用 super 關鍵字調用父類構造器，否則會報錯。
  • 當子類有多個構造器時，子類中的每個構造器都必須要調用父類構造器（如果父類有多個構造器，那麼子類構造器只需挑父類構造器的其中一個來調用即可，不過一定要保證子類的每個構造器都有調用父類構造器）

父類既含有無參構造器，也含有有參構造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父類
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
	
	public Person(){ // 無參構造器
		System.out.println("Person()");
	}
	public Person(int i){
	System.out.println("Person" + "(" + i + ")"); // 有參構造器
	}
}
	

	
package com.example;

public class Man extends Person{ // 子類
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){ // 子類無參構造器
		System.out.println("Man()");
	}
	public Man(int i){ // 子類有參構造器
		System.out.println("Man" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		System.out.println("調用子類的無參構造器");
		new Man();
		System.out.println("調用子類的有參構造器");
		new Man(1);
	}
}
	

	
運行結果：

調用子類的無參構造器
T(4)
T(6)
T(1)
T(3)
T(5)
Person()
T(2)
Man()
調用子類的有參構造器
T(5)
Person()
T(2)
Man(1)
  • 當父類含有無參構造器時，即使子類有多個構造器，這些構造器也無需顯式地通過 super 關鍵字調用父類構造器，因為編譯器會自動為每個子類的構造器都調用父類的無參構造器，例如：例子中運行結果列印了兩次 Person()，這是兩次創建子類對象時，編譯器自動調用父類中無參構造器的結果

總結：如果要建立繼承關係時，最好給父類創建一個無參構造器或者不給父類創建任何構造器


[ 返回頂部 ]


三、靜態塊和非靜態塊

1）靜態塊會使所有靜態屬性都被初始化，即使靜態屬性不在靜態塊內

例如：

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class S{
	public static T t1;
	public static T t2;
	public static T t3;
	public T t4;
	public T t5;
	public T t6;
	public T t7 = new T(7); // t7 不在靜態塊內
	
	static{ // 靜態塊
		t1 = new T(1);
		t2 = new T(2);
		t3 = new T(3);
	}
	
	{ // 非靜態塊
		t4 = new T(4);
		t5 = new T(5);
		t6 = new T(6);
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		System.out.println(S.t1);
	}
}
	

	
運行結果：

T(7)
T(1)
T(2)
T(3)
com.example.T@15db9742
  • 可以看到，該例子中只是調用了 S.t1 ，靜態屬性 t2, t3, t7 也跟著被初始化了

[ 返回頂部 ]


四、初始化的方式

1）在定義處初始化

2）在構造器內初始化

3）在靜態塊或非靜態塊內初始化

4）等到要用的時候再初始化


[ 返回頂部 ]


五、數組初始化

數組有三種初始化的方式

第一種初始化的方式


package com.example;
import java.util.Arrays;

public class Test{
	public static void main(String[] args){
		int[] a = {1,2,3,4,5};
		
		/* error, 只能寫在同一行

		 int[] a;
		 a = {1,2,3,4,5}
		 
		*/
		
		// System.out.println(a); 這種方式無法列印數組的值
		
		System.out.println(Arrays.toString(a)); // 列印數組的值
	}
}


	
運行結果：

[1, 2, 3, 4, 5]

第二種初始化的方式

	
package com.example;
import java.util.Arrays;

public class Test{
	public static void main(String[] args){
		int[] a;
		a = new int[5];
		for(int i=0; i<5; i++){
			a[i] = i;
		}
		System.out.println(Arrays.toString(a));
	}
}
	

	
運行結果：

[0, 1, 2, 3, 4]

第三種初始化的方式

例1：

	
package com.example;
import java.util.Arrays;

public class Test{
	public static void main(String[] args){
		int[] a;
		a = new int[]{1,2,3,4,5};
		System.out.println(Arrays.toString(a));
	}
}
	

	
運行結果：

[1, 2, 3, 4, 5]

例2（這種方式的用途）：

	
package com.example;
import java.util.Arrays;

public class T{
	public void show(Integer[] i){ //必須為 Integer 類型，不能是 int 這些基本類型
		System.out.println(Arrays.toString(i));
	}
	public void show(String[] str){
		System.out.println(Arrays.toString(str));
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		T t1 = new T();
		t1.show(new Integer[]{5,4,3,2,1}); // 必須為 Integer 類型，不能是 int 這些基本類型
		t1.show(new String[]{"張三", "李四", "王五"});
	}
}
	

	
運行結果：

[5, 4, 3, 2, 1]
[張三, 李四, 王五]
  • 很明顯這種方式的優點是無需額外定義一個數組變數 int[] a

[ 返回頂部 ]


參考資料：

《Java 編程思想》第4版


End~


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • H5 仿ios select滾動選擇器。框架。
    官網上描述的很詳細，並且開源，輕量。 有興趣的可以去嘗試官網上的demo寫的也很好，並且每個參數也解釋的很詳細。 http://zhoushengfe.com/iosselect/website/index.html#user-content-demos 效果圖： ...
  • React--組件
    註意 /`會報錯 React的props React中的每一個組件，都包含有一個屬性（props），在組件內部，我們可以通過this.props獲取屬性對象。 組件如下： 屬性使用方法： 1.直接調key/value 2.延展屬性 用{...props}方法 3.調用組件的setProps函數來指定 ...
  • Java 微服務框架選型（Dubbo 和 Spring Cloud？）
    微服務（Microservices）是一種架構風格，一個大型複雜軟體應用由一個或多個微服務組成。系統中的各個微服務可被獨立部署，各個微服務之間是松耦合的。每個微服務僅關註於完成一件任務並很好地完成該任務。在所有情況下，每個任務代表著一個小的業務能力。 以往我們開發應用程式都是單體型（可以看作是一個怪 ...
  • 設計模式之備忘錄模式（Memento ）
    當我們在實際應用中需要提供撤銷機制，當一個對象可能需要再後續操作中恢復其內部狀態時，就需要使用備忘錄模式。其本質就是對象的序列化和反序列化的過程，支持回滾操作。 作用 在不破壞封裝性的前提下，捕獲一個對象的內部狀態，併在該對象之外保存這個狀態，這樣以後就可以將該對象恢復到原先的狀態。 類視圖 實現 ...
  • C#設計模式——簡單工廠模式、工廠模式和抽象工廠模式
    一：簡單工廠模式 1：描述：簡單工廠模式是由一個工廠對象根據接收到的消息決定要創建哪一個類的對象事例。 2：優點：工廠類中有相關邏輯判斷，可以根據需要動態創建相關的對象事例，而客戶端只需要告訴工廠類創建什麼對象事例，而不關心怎麼創建，當需要引入新產品就不需要修改客戶端的代碼，只需要添加相應的產品類並 ...
  • 關於hibernate的核心配置
    一、hibernate中的核心配置文件：hibernate.rfg.xml 對於hibernate的核心配置文件有兩種：1.hibernate.rfg.xml，2.hibernate.properties。開發中我們最常用的是hibernate.rfg.xml的配置文件，因為它的配置能力強，易於修改 ...
  • 初學Java Web(8)——過濾器和監聽器
    什麼是過濾器 過濾器就是 Servlet 的高級特性之一， 就是一個具有 攔截/過濾 功能的一個東西，在生活中過濾器可以是香煙濾嘴，濾紙，凈水器，空氣凈化器等，在 Web 中僅僅是一個 實現了 Filter 介面的 Java 類 而已。 特點：雙向，攔截請求，攔截響應 作用： 過濾器可以對 所有的請 ...
  • 利用for迴圈如何判定是水仙花數
    水仙花數業內的大家可能聽說過，但是對於初學者來講，對於水仙花數還是比較陌生的。 首先要知道的是水仙花數的計算公式：153=1**3+5**3+3**3： 如何去判定這個數是否為水仙花數，最好的辦法就是用for內嵌迴圈了，因為涉及到了公式所以很多數學邏輯不是很好的兄臺，就尷尬了，其實有一個比較簡單的數 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類