java類的構成
Java 技術具有卓越的通用性、高效性、平臺移植性和安全性，廣泛應用于PC、數據中心、游戲控制臺、科學超級計算機、移動電話和互聯網，同時擁有全球最大的開發者專業社群。以下是小編為大家搜索整理的java類的基本構成，希望能給大家帶來幫助!
1：Java 類的定義形式
一個完整的 Java 類通常由下面六個部分組成：
包定義語句
import 語句
類定義{
成員變量
構造方法
成員方法
}
其中：只有類定義和“{}”是不可或缺的，其余部分都可以根據需要來定義。
下面分別來學習各個部分的基本規則，看看如何寫 Java 的類。
2： 包
2.1：包 是什么
在 Java 中，包是類、接口或其它包的集合，包主要用來將類組織起來成為組，從而對類進行管理。
2.2：包 能干什么
包對于下列工作非常有用：
(1)：包允許您將包含類代碼的文件組織起來，易于查找和使用適當的類。
(2)：包不止是包含類和接口，還能夠包含其它包。形成層次的包空間。
(3)：它有助于避免命名沖突。當您使用很多類時，確保類和方法名稱的唯一性是非常困難的。包能夠形成層次命名空間，縮小了名稱沖突的范圍，易于管理名稱。
為便于管理數目眾多的類，Java 語言中引入了“包”的概念，可以說是對定義的 Java類進行“分組” ，將多個功能相關的類定義到一個“包”中，以解決命名沖突、引用不方便、安全性等問題。
就好似當今的戶籍制度，每個公民除有自己的名字“張三” 、 “李四”外還被規定了他的戶籍地。假定有兩個人都叫張三，只稱呼名字就無法區分他們，但如果事先登記他們的戶籍分別在北京和上海，就可以很容易的用“北京的張三” 、 “上海的張三”將他們區分開來。如果北京市仍有多個張三，還可以細分為“北京市.海淀區的張三” 、 “北京市.西城區.平安大街的張三”等等，直到能惟一標識每個“張三”為止。
JDK 中定義的類就采用了“包”機制進行層次式管理，下圖顯示了其組織結構的一部分：
從圖中可以看出，一個名為 java 的包中又包含了兩個子包：io 包和 lang 包。lang 包中包含了 System, String, Object 三個類的定義。事實上，Java 包中既可以包含類的定義，也可以包含子包，或同時包含兩者。
簡而言之： 從 邏輯 上 講 ， 包 是一 組 相 關類 的集 合 ; 從 物 理 上 講 ， 同 包即 同 目 錄。
2.1：JDK 中常 用的 包
java.lang----包含一些 Java 語言的核心類，包含構成 Java 語言設計基礎的類。在此包中定義的最重要的一個類是“Object” ，代表類層次的根，Java 是一個單根系統，最終的根就是“Object” ，這個類會在后面講到。
Java 并不具有“自由”的方法，例如，不屬于任何類的方法，Java 中的所有方法必須始終屬于某個類。經常需要使用數據類型轉換方法。Java 在 Java.lang 包中定義了“包裝對象”類，使我們能夠實現數據類型轉換。如 Boolean、Character、Integer、Long、Float 和Double，這些在后面會講到。
此包中的其它類包括：
? Math——封裝最常用的數學方法，如正弦、余弦和平方根。
? String，StringBuffer——封裝最常用的字符串操作。
你不必顯示導入該包，該 Java 包通常已經導入。
java.awt----包含了構成抽象窗口工具集(abstract window toolkits)的多個類，這些類被用來構建和管理應用程序的圖形用戶界面(GUI)。
javax.swing----完全 Java 版的圖形用戶界面(GUI)解決方案，提供了很多完備的組件，可以應對復雜的桌面系統構建。
java.net----包含執行與網絡相關的操作的類，如 URL, Socket, ServerSocket 等。
java.io----包含能提供多種輸入/輸出功能的類。
java.util----包含一些實用工具類，如定義系統特性、使用與日期日歷相關的方法。還有重要的集合框架。
2.2：Java 中 如何 表達 包 ——package 語 句
Java 語言使用 package 語句來實現包的定義。package 語句必須作為 Java 源文件的第一條語句， 指明該文件中定義的類所在的包。 若缺省該語句， 則指定為無名包， 其語法格式為：
package pkg1[.pkg2[.pkg3…]]; //“[]”表示可選Java 編譯 器 把包對 應 于 文 件系 統 的目 錄管 理，因此包也可以嵌套使用，即一個包中可以含有類的定義也可以含有子包，其嵌套層數沒有限制。package 語句中，用‘.’來指明包的層次;
Java 語言要求包聲明的層次和實際保存類的字節碼文件的目錄結構存在對應關系， 以便將來使用該類時能通過包名(也就是目錄名)查找到所需要的類文件。簡單地說就是包的層次結構需要和文件夾的層次對應。
注意：每 個源文 件 只 有一 個 包 的 聲 明， 而 且包 名 應 該 全部 小 寫 。
具體來說，程序員要做以下工作：
2.3：編譯和 生 成 包
如果在程序 Test.java 中已定義了包 p1，就必須將編譯生成的字節碼文件 Test.class 保存在與包名同名的子目錄中，可以選用下述兩種方式之一：
采用下述命令編譯：
javac Test.java
則編譯器會在當前目錄下生成 Test.class 文件， 再在適合位置手動創建一個名為 p1 的子目錄，將 Test.class 復制到該 p1 目錄下。
采用簡化的編譯命令，就是可以帶包編譯
javac -d destpath Test.java
歸入該包的類的字節代碼文件應放在 java 的類庫所在路徑的 destpath 子目錄下。 現在包的相對位置已經決定了，但 java 類庫的路徑還是不定的。事實上，java 可以有多個存放類庫的目錄，其中的缺省路徑為 java 目錄下的 lib 子目錄，你可以通過使用-classpath 選項來確定你當前想選擇的類庫路徑。 除此之外， 你還可以在 CLASSPATH 環境變量中設置類庫路徑。 destpath 為目標路徑， 可以是本地的任何絕對或相對路徑。 則編譯器會自動在 destpath目錄下建立一個子目錄 p1，并將生成的.class 文件自動保存到 destpath/p1 下。例如：
javac -d . Test.java
javac -d C: est Test.java
2.4：帶包 運行
運行帶包的程序，需要使用類的全路徑，也就是帶包的路徑，比如上面的那個程序，就使用如下的代碼進行運行：
java p1.Test
3：import
為了能夠使用某一個包的成員，我們需要在 Java 程序中明確導入該包。使用“import”語句可完成此功能。在 java 源文件中 import 語句應位于 package 語句之后，所有類的定義之前，可以有 0~多條，其語法格式為：
import package1[.package2…].(classname|*);
java 運行時環境將到 CLASSPATH + package1.[package2…]路徑下尋找并載入相應的字節碼文件 classname.class。 “*”號為通配符，代表所有的類。也就是說 import 語句為編譯器指明了尋找類的途徑。
例，使用 import 語句引入類程序：TestPackage.java
java 編譯器默認為所有的 java 程序引入了 JDK 的 java.lang 包中所有的類(import java.lang.*;) ，其中定義了一些常用類：System、String、Object、Math 等。因此我們可以直接使用這些類而不必顯式引入。但使用其它非無名包中的類則必須先引入、后使用。
3.1：Java 類 搜尋方 式
程序中的 import 語句標明要引入 p1 包中的 Test 類， 假定環境變量 CLASSPATH 的值為
“.;C:jdk6lib;D:ex” ， java 運行環境將依次到下述可能的位置尋找并載入該字節碼
文件 Test.class：
.p1Test.class
C:jdk6libp1Test.class
D:exp1Test.class
其中， “.”代表當前路徑，如果在第一個路徑下就找到了所需的類文件，則停止搜索。
否則依次搜索后續路徑，如果在所有的路徑中都未找到所需的類文件，則編譯或運行出錯。
4： 訪問修飾 符
Java 語言允許對類中定義的各種屬性和方法進行訪問控制， 即規定不同的保護等級來限制對它們的使用。為什么要這樣做?Java 語言引入類似訪問控制機制的 目的 在 于實 現 信息的 封 裝 和 隱藏。 Java 語言為對類中的屬性和方法進行有效地訪問控制， 將它們分為四個等級：private, 無修飾符, protected, public，具體規則如下：
變量和方法可以處于四個訪問級別中的一個：公共，受保護，無修飾符或私有。類可以在公共或無修飾級別。
變量、方法或類有缺省(無修飾符)訪問性，如果它沒有顯式受保護修飾符作為它的聲明的一部分的話。這種訪問性意味著，訪問可以來自任何方法，當然這些方法只能在作為對象的同一個包中的成員類當中。
以修飾符 protected 標記的變量或方法實際上比以缺省訪問控制標記的更易訪問。 一個protected 方法或變量可以從同一個包中的類當中的任何方法進行訪問， 也可以是從任何子類中的任何方法進行訪問。 當它適合于一個類的子類但不是不相關的類時， 就可以使用這種受保護訪問來訪問成員。
5： 類定義
Java 程序的基本單位是類，你建立類之后，就可用它來建立許多你需要的對象。Java把每一個可執行的成分都變成類。
類的定義形式如下：
這里，類名要是合法的標識符。在類定義的開始與結束處必須使用花括號。你也許想建立一個矩形類，那么可以用如下代碼：
6：構 造方 法
6.1：什么是構造方法
類有一個特殊的成員方法叫作構造方法， 它的作用是創建對象并初始化成員變量。 在創建對象時，會自動調用類的構造方法。
6.2：構 造方 法定義規則
Java 中的構造方法必須與該類具有相同的名字，并且沒有方法的返回類型(包括沒有void) 。另外，構造方法一般都應用 public 類型來說明，這樣才能在程序任意的位置創建類的實例--對象。
6.3：示 例
下面是一個 Rectangle 類的構造方法，它帶有兩個參數，分別表示矩形的長和寬：
6.4：說明
每個類至少有一個構造方法。 如果不寫一個構造方法， Java 編程語言將提供一個默認的，該構造方法沒有參數，而且方法體為空。
注意：如果一個類 中 已經 定義 了 構 造方 法則 系 統 不 再 提 供 默認 的 構 造方
7：析構方法
析構方法 finalize 的功能是： 當對象被從內存中刪除時， 該成員方法將會被 自動調用。通常，在析構方法內，你可以填寫用來回收對象內部的動態空間的代碼。
特別注意：當我們去調用析構方法的時候，并不會引起該對象實例從內存中刪除，而是不會起到任何作用。
在 Java 編程里面，一般不需要我們去寫析構方法，這里只是了解一下就可以了。
8：屬性
8.1：屬性是什么
簡單點說，屬性就是對象所具有的靜態屬性。
8.2：定義規則
Java 類中屬性的聲明采用如下格式：
訪問修飾符 修飾符 類型 屬性名稱=初始值;
訪問修飾符：可以使用四種不同的訪問修飾符中的一種，包括 public(公共的)、protected(受保護的) ，無修飾符和 private(私有的) 。public 訪問修飾符表示屬性可以從任何其它代碼調用。private 表示屬性只可以由該類中的其它方法來調用。protected 將在以后的課程中討論。
修飾符：是對屬性特性的描述，例如后面會學習到的：static、final 等等。
類型：屬性的數據類型，可以是任意的類型。
屬性名稱：任何合法標識符
初始值：賦值給屬性的初始值。如果不設置，那么會自動進行初始化，基本類型使用缺省值，對象類型自動初始化為 null。
8.3：說明
屬性有時候也被稱為成員變量、實例變量、域，它們經常被互換使用。
9：方 法
9.1：方法是什么
方法就是對象所具有的動態功能。
9.2：定義規則
Java 類中方法的聲明采用以下格式：訪問修飾符 修飾符 返回值類型 方法名稱 (參數列表) throws 異常列表 {方法體}
訪問修飾符：可以使用四種不同的訪問修飾符中的一種，包括 public(公共的)、protected(受保護的) ，無修飾符和 private(私有的) 。public 訪問修飾符表示方法可以從任何其它代碼調用。private 表示方法只可以由該類中的其它方法來調用。protected 將在以后的課程中討論。
修飾符：是對方法特性的描述，例如后面會學習到的：static、final、abstract、synchronized 等等。
返回值類型：：表示方法返回值的類型。 如果方法不返回任何值， 它必須聲明為 void(空)。
Java 技術對返回值是很嚴格的，例如，如果聲明某方法返回一個 int 值，那么方法必須從所有可能的返回路徑中返回一個 int 值(只能在等待返回該 int 值的上下文中被調用。 )
方法名稱：可以是任何合法標識符，并帶有用已經使用的名稱為基礎的某些限制條件。
參數列表：允許將參數值傳遞到方法中。列舉的元素由逗號分開，而每一個元素包含一個類型和一個標識符。在下面的方法中只有一個形式參數，用 int 類型和標識符 days 來聲明：public void test(int days){}
throws 異常列表：子句導致一個運行時錯誤(異常)被報告到調用的方法中，以便以合適的方式處理它。異常在后面的課程中介紹。
花括號內是方法體，即方法的具體語句序列。
9.3：示例
比如現在有一個“車”的類——Car， “車”具有一些基本的屬性，比如四個輪子，一個方向盤，車的品牌等等。當然，車也具有自己的功能，也就是方法，比如車能夠“開動”——run。要想車子能夠開動，需要給車子添加汽油，也就是說，需要為 run 方法傳遞一些參數“油”進去。車子跑起來過后，我們需要知道當前車輛運行的速度，就需要 run 方法具有返回值“當前的速度” 。
9.4：形參和實參
形參：就是形式參數的意思。是在定義方法名的時候使用的參數，用來標識方法接收的參數類型，在調用該方法時傳入。
實參：就是實際參數的意思。是在調用方法時傳遞給該方法的實際參數。
比如：上面的例子中“int oil”就是個形式參數，這里只是表示需要加入汽油，這個方法才能正常運行，但具體加入多少，要到真正使用的時候，也就是調用這個方法的時候才具體確定，加入調用的時候傳入“80” ，這就是個實際參數。
形參和實參有如下基本規則：
(1)：形參和實參的類型必須要一致，或者要符合隱含轉換規則
(2)：形參類型不是引用類型時，在調用該方法時，是按值傳遞的。在該方法運行時，形參和實參是不同的變量，它們在內存中位于不同的位置，形參將實參的值復制一份，在該方法運行結束的時候形參被釋放，而實參內容不會改變。
(3)：形參類型是引用類型時，在調用該方法時，是按引用傳遞的。運行時，傳給方法的是實參的地址， 在方法體內部使用的也是實參的地址， 即使用的就是實參本身對應的內存空間。所以在函數體內部可以改變實參的值。
9.5：參數可變的方法
從 JDK5.0 開始，提供了參數可變的方法。
當不能確定一個方法的入口參數的個數時，5.0 以前版本的 Java 中，通常的做法是將多個參數放在一個數組或者對象集合中作為參數來傳遞，5.0 版本以前的寫法是：
int sum(Integer[] numbers){…}
//在別處調用該方法
sum(new Integer[] {12,13,20});
而在 5.0 版本中可以寫為：
int sum(Integer... numbers){//方法內的操作}
注意：方法定義中是三個點
//在別處調用該方法
sum(12,13,20);//正確
sum(10,11); //正確
也就是說，傳入參數的個數并不確定。但請注意：傳入參數的類型必須是一致的，究其本質，就是一個數組。
顯然，JDK5.0 版本的寫法更為簡易，也更為直觀，尤其是方法的調用語句，不僅簡化很多，而且更符合通常的思維方式，更易于理解。
Java類基本構成
1、包：(package)類名管理空間，由于Java編譯器為每個類生成字節碼文件，且文件名與類名相同，因此同名的類可能發生沖突，所以引入了包的概念。
A：包提供了一種命名機制和可見性限制機制；在java中將功能相似類用一個包來進行管理
B：定義一個包package定義，若要定義包，則類的第一行必須無空格，業務注釋；如：package+包名。包名通常都由小寫字母組成。
2、引入：(import)import語句在功能上與C/C++語言中的include語句相同
A：兩者之間的不同點：
a、Include是包含外部文件，import是輸入外部類，
b、import末尾必須以“；”結尾。
B：import語句必須放在package之后，若沒有package，則該語句放在類文件名的開頭；
C：若要引入某一個類，必須寫完整的包名和類名；如：importpackage.classname
3、類：(class)類是java程序的基本單位，類的實例是對象。
A：若在源程序中包含有公共類的定義，則該源文件名必須與公共類的名字完全一致，否則編譯時就會報錯。
B：在一個java源程序中至多只能有一個公共類的定義。
C：若在一個源程序中有多個類定義，則在編譯時將為每個類生成一個.class文件
4、變量：(variable)一個類中通常都包含數據和函數兩種類型的元素，一般把它們稱為變量和成員函數；也把成員函數成為方法。
將數據和代碼通過類結合在一起，就行成了封裝的概念。
變量也叫做域，它是用于定義屬性類的數據，這些數據是用來描述對象的狀態，方法就是對這個數據進行操作。
5、方法：(method)指引類進行具體的活動和操作
6、注釋：java注釋分為三種
A：單行注釋：用//表示
B：多行注釋：用/*.................................................*/表示
C：文檔注釋：用/**.................................................*/表示
java類文件內容介紹
一、什么是Java類文件
Java類文件是Java程序的二進制表示形式。每一個類文件代表一個類或者接口。不可能在一個類文件中放入多個類或者接口。這樣就使得無論類文件是在哪一種平臺上生成，都可以在任何主機上執行。
雖然類文件是Java體系結構的一部分，但是他并不是與Java語言不可分的。你可以將其他語言的程序編譯為類文件，也可以將Java程序文件編譯為其他二進制形式。
Java類文件是一個基于8-bit字節的二進制流。數據塊順序的、無分割符的、big-endian的形式存儲。
二、類文件的內容
Java的類文件中包含了所有Java虛擬機所需要的關于類和接口的信息。所有類文件中的信息都以以下的四種基本類型的存儲：
Table 6-1. Class file "primitive types"
u1 a single unsigned byte
u2 two unsigned bytes
u4 four unsigned bytes
u8 eight unsigned bytes
1、魔術編碼(magic)
每一個Java類文件的開頭四個字節都是魔術編碼(OxCAFEBABE)。通過魔術編碼可以很容易識別類文件。
2、副版本號和主版本號(minor version and major version)
剩下的四個字節是副版本號和主版本號。但Java技術在進化時，一些新的特性可能會被加入到類文件中。每一次類文件格式的變化，都會相應的改變版本號。虛 擬機通過版本號來識別自己能夠處理的類文件。Java虛擬機往往只能處理一個給定的主版本號和其下的一些副版本號。虛擬機必須拒絕那些不再處理范圍內的類 文件。
Java類和對象的概念
Java是一門面向對象的編程語言，理解Java，首先要理解類與對象這兩個概念。
Java中的類可以看做C語言中結構體的升級版。結構體是一種構造數據類型，可以包含不同的成員（變量），每個成員的數據類型可以不一樣；可以通過結構體來定義結構體變量，每個變量擁有相同的性質。例如：
#include
運行結果：
小明的年齡是 15，成績是 92.500000
Java中的類也是一種構造數據類型，但是進行了一些擴展，類的成員不但可以是變量，還可以是函數；通過類定義出來的變量也有特定的稱呼，叫做“對象”。例如：
public class Demo {public static void main(String[] args){// 定義類Studentclass Student{ // 通過class關鍵字類定義類// 類包含的變量String name;int age;float score;// 類包含的函數void say(){System.out.println( name + "的年齡是 " + age + "，成績是 " + score );}}// 通過類來定義變量，即創建對象Student stu1 = new Student(); // 必須使用new關鍵字// 操作類的成員stu1.name = "小明";stu1.age = 15;stu1.score = 92.5f;stu1.say();}}
運行結果：
小明的年齡是 15，成績是 92.5
在C語言中，通過結構體名稱就可以完成結構體變量的定義，并分配內存空間；但是在Java中，僅僅通過類來定義變量不會分配內存空間，必須使用new關鍵字來完成內存空間的分配。
可以將類比喻成圖紙，對象比喻成零件，圖紙說明了零件的參數及其承擔的任務；一張圖紙可以生產出具有相同性質的零件，不同圖紙可以生產不同類型的零件。
在Java中，使用new關鍵字，就可以通過類來創建對象，即將圖紙生產成零件，這個過程叫做類的實例化，因此也稱對象是類的一個實例。
注意：類只是一張圖紙，起到說明的作用，不占用內存空間；對象才是具體的零件，要有地方來存放，才會占用內存空間。
類所包含的變量和函數都有特定的稱呼，變量被稱為屬性（通常也稱成員變量），函數被稱為方法，屬性和方法統稱為類的成員。
面向對象編程(Object Oriented Programming, OOP)
類是一個通用的概念，Java、C++、C#、PHP等很多編程語言中都有類，都可以通過類創建對象。可以將類看做是結構體的升級版，C語言的晚輩們看到了C語言的不足，嘗試加以改善，繼承了結構體的思想，并進行了升級，讓程序員在開發或擴展大中型項目時更加容易。
因為Java、C++等語言都支持類和對象，所以使用這些語言編寫程序也被稱為面向對象編程，這些語言也被稱為面向對象的編程語言。C語言因為不支持類和對象的概念，被稱為面向過程的編程語言。
實際上，面向對象只是面向過程的升級。
在C語言中，可以將完成某個功能的重復使用的代碼塊定義為函數，將具有一類功能的函數聲明在一個頭文件中，不同類型的函數聲明在不同的頭文件，以便對函數進行更好的管理，方便編寫和調用。
在Java中，可以將完成某個功能的代碼塊定義為方法，將具有相似功能的方法定義在一個類中，也就是定義在一個源文件中（因為一個源文件只能包含一個公共的類），多個源文件可以位于一個文件夾，這個文件夾有特定的稱呼，叫做包。
圖1 C語言中項目的組織結構
圖2 Java中項目的組織結構
面向對象編程在軟件執行效率上絕對沒有任何優勢，它的主要目的是方便程序員組織和管理代碼，快速梳理編程思路，帶來編程思想上的革新。
Java類和對象的初始化順序
類裝載步驟
在Java中，類裝載器把一個類裝入Java虛擬機中，要經過三個步驟來完成：裝載、鏈接和初始化，其中鏈接又可以分成校驗、準備和解析三步，除了解析外，其它步驟是嚴格按照順序完成的，各個步驟的主要工作如下：
裝載：查找和導入類或接口的二進制數據;
鏈接：執行下面的校驗、準備和解析步驟，其中解析步驟是可以選擇的;
校驗：檢查導入類或接口的二進制數據的正確性;
準備：給類的靜態變量分配并初始化存儲空間;
解析：將符號引用轉成直接引用;
初始化：激活類的靜態變量的初始化Java代碼和靜態Java代碼塊。
其中 初始化(initialization)包含兩部分：
1.類的初始化(initialization class & interface)
2.對象的創建(creation of new class instances)。
因為類的初始化其實是類加載(loading of classes)的最后一步，所以很多書中把它歸結為“對象的創建”的第一步。其實只是看問題的角度不同而已。為了更清楚的理解，這里還是分開來。
順序：
因為類的加載肯定是第一步的，所以類的初始化在前。大體的初始化順序是：
類初始化 -> 子類構造函數 -> 父類構造函數 -> 實例化成員變量 -> 繼續執行子類構造函數的語句
下面結合例子，具體解釋一下。
1. 類的初始化(Initialization classes and interfaces)
其實很簡單，具體來說有：
(a)初始化類(initialization of class)，是指初始化static field 和執行static初始化塊。
public class Demo{ //初始化static field, //其中= "initialization static field"又叫做static field initializer private static String str = "initialization static field"; //初始化塊，又叫做static initializer，或 static initialization block static { System.out.println("This is static initializer"); } }
btw，有些書上提到static initializer 和 static field initializer 的概念，與之對應的還有 instance initializer 和 instance variable initializer。例子中的注釋已經解釋了其含義。
(b)初始化接口(initialization of interface)，是指初始化定義在該interface中的field。
*注意*
1. initialization classes 時，該class的superclass 將首先被初始化，但其實現的interface則不會。
initialization classes 時，該class的superclass，以及superlcass的superclass 會首先被遞歸地初始化，一直到java.lang.Object為止。但initialiazation interface的時候，卻不需如此，只會初始化該interface本身。
2. 對于由引用類變量(class field)所引發的初始化，只會初始化真正定義該field的class。
3. 如果一個static field是編譯時常量(compile-time constant)，則對它的引用不會引起定義它的類的初始化。
為了幫助理解最后兩點，請試試看下面的例子：
Initialization類
public class Initialization { static { System.out.println("Initialization Main class"); } public static void main(String[] args) { System.out.println(Sub.y); System.out.println(Sub.x); System.out.println(Sub.z); } }
Sub類
public class Sub extends Super { public static final int y = 2005; public static int z; static { System.out.println("Initialization Sub"); } }
Super類
public class Super { public static int x = 2006; static { System.out.println("Initialization Super"); } }
輸入結果
Initialization Main class
2005
Initialization Super
2006
Initialization Sub
從這個結果可以看到，
static塊在類中會先執行;(實際上是先加載static成員變量，然后是static代碼塊)
static 的final變量不會引起類的初始化;
子類Sub引用父類Super里面的變量，就會引起父類的初始化，但不會引起子類的初始化;
static的成員變量也有默認值。
2. 對象的創建(creation of new class instances)
看例子來說明：
InitializationOrder類
public class InitializationOrder { public static void main(String[] args) { SubClass sb = new SubClass(); } }
SuperClass類
public class SuperClass{ static { System.out.println("SuperClass static"); } SuperClass(String str){ System.out.println(str); } }
Interface類
interface Interface{ static SuperClass su = new SuperClass("Interface new SuperClass"); }
SubClass類
public class SubClass extends SuperClass implements Interface{ static { System.out.println("SubClass static"); } private SuperClass su = new SuperClass("initialization variable"); SubClass() { super("super"); new SuperClass("new SuperClass"); } }
輸出結果
SuperClass static
SubClass static
super
initialization variable
new SuperClass
解釋一下：
1) Java虛擬機要執行InitializationOrder類中的static 方法main()，這引起了類的初始化。開始初始化InitializationOrder類。具體的步驟略去不說。
2) InitializationOrder類初始化完畢后，開始執行main()方法。語句SubClass sb = new SubClass()將創建一個SubClass對象。加載類SubClass后對其進行類初始化，因為Subclass有一個父類SuperClass，所以先初始化SuperClass類。于是看到輸出“SuperClass static”。
3) SuperClass類初始化完畢后，開始初始化SubClass類，輸出“SubClass static”。
4) 至此，類的加載工作全部完成。開始進入創建SubClass的對象過程。先為SubClass類和其父類SuperClass類分配內存空間，這時Super su 被賦值為null。
5) 執行構造函數SubClass()，執行super(), 調用父類的構造函數，輸出“super”。
6) 初始化SubClass類的成員變量su，輸出“initialization variable”。
7) 繼續執行構造函數的剩余部分，執行new SuperClass("new SuperClass")，輸出“new SuperClass”，這時Super su 被賦值新建對象的引用。
8) 而SubClass雖然實現了接口Interface，但是初始化它的時候并不會引起接口的初始化，所以接口Interface中的static SuperClass su = new SuperClass("Interface new SuperClass")自始至終都沒有被執行到。
所以對象的創建，具體步驟如下：
(1) 所有的成員變量—包括該類，及它的父類中的成員變量--被分配內存空間，并賦予默認值。(這里是第一次初始化成員變量)
(2) 為所調用的構造函數初始化其參數變量。(如果有參數)
(3) 如果在構造函數中用this 調用了同類中的其他構造函數，則按照步驟(2)~(6)去處理被調用到的構造函數。
(4) 如果在構造函數中用super調用了其父類的構造函數，則按照步驟(2)~(6)去處理被調用到的父類構造函數。
(5) 按照書寫順序，執行instance initializer 和 instance variable initializer來初始化成員變量。(這里是第二次初始化成員變量)
(6) 按照書寫順序，執行構造函數的其余部分。
總結：
從類的初始化和對象的創建步驟，可以知道，一個類是先初始化static的變量和static句塊，然后在分配該類以及父類的成員變量的內存空間，賦予默認值，然后開始調用構造函數。而子類和父類之間，則先初始化和創建父類，然后在初始化和創建子類的。
java system類使用方法示例
常用的方法：
復制代碼 代碼如下:
long currentTimeMillis(); 獲取當前時間的毫秒值
void exit();終止當前正在運行的 Java 虛擬機。
復制代碼 代碼如下:
public static void Method(){
long l = System.currentTimeMillis();
System.out.println(l);
System.exit();
}
描述系統屬性信息：Properties System.getProperties();
該方法獲取的信息存儲在Properties集合中
因為Properties是Hashtable的子類，也就是Map集合的一個子類對象，要倒入util包
那么可以通過map的方法取出該集合中的元素
該集合中的鍵和值存儲的都是字符串，沒有泛型的定義
復制代碼 代碼如下:
public static void Method Properties(){
//獲取當前系統所有屬性信息
Properties prop = System.getProperties();
//遍歷prop中的屬性信息,也可以使用迭代器
for(Object obj : prop.keySet()){
String value = (String)prop.get(obj);
System.out.println(obj+"==="+value);
//通過鍵獲取對應的屬性信息
String value = System.getProperty("os.name");//如果沒有該鍵返回null
System.out.println(value);
}
}
在系統中自定義系統信息
復制代碼 代碼如下:
public static void SetProperties(){
System.setProperty("makey","myvalue");
System.out.println(System.getProperty("makey"));
}
out:標準輸出，默認是顯示器
in：標準輸入，默認是鍵盤
【java類的構成】相關文章：
Java類的基本構成12-04
Java類基本構成05-11
Java類的基本構成05-01
Java類的基本構成04-02
Java的類07-19
計算機二級入門教程：Java類的基本構成06-19
Java的類常識03-29