Java學期總結

時間 2020-08-08

標籤 java 學期總結欄目 Java 简体版

原文原文鏈接

一：java語法基礎：javascript

1，關鍵字：其實就是某種語言賦予了特殊含義的單詞。
保留字：其實就是尚未賦予特殊含義，可是準備往後要使用過的單詞。java

2，標示符：其實就是在程序中自定義的名詞。好比類名，變量名，函數名。包含 0-九、a-z、$、_ ；
注意：
1），數字不能夠開頭。
2），不可使用關鍵字。express

3，常量：是在程序中的不會變化的數據。設計模式

4，變量：其實就是內存中的一個存儲空間，用於存儲常量數據。
做用：方便於運算。由於有些數據不肯定。因此肯定該數據的名詞和存儲空間。
特色：變量空間能夠重複使用。數組

何時定義變量？只要是數據不肯定的時候，就定義變量。安全

變量空間的開闢須要什麼要素呢？
1，這個空間要存儲什麼數據？數據類型。
2，這個空間叫什麼名字啊？變量名稱。
3，這個空間的第一次的數據是什麼？變量的初始化值。jvm

變量的做用域和生存期:函數

變量的做用域：
做用域從變量定義的位置開始，到該變量所在的那對大括號結束；工具

生命週期：
變量從定義的位置開始就在內存中活了；
變量到達它所在的做用域的時候就在內存中消失了；佈局

數據類型：
1）：基本數據類型：byte、short、int、long、float、double、char、boolean
2）：引用數據類型: 數組、類、接口。

**級別從低到高爲：**byte,char,short(這三個平級)–>int–>float–>long–>double

自動類型轉換：從低級別到高級別，系統自動轉的；

強制類型轉換：什麼狀況下使用?把一個高級別的數賦給一個別該數的級別低的變量；

運算符號：
1）、算術運算符。
+ - * / % %:任何整數模2不是0就是1，因此只要改變被模數就能夠實現開關運算。
+:鏈接符。
++,–

2）、賦值運算符。
= += -= *= /= %=

3）、比較運算符。
特色：該運算符的特色是：運算完的結果，要麼是true，要麼是false。

4）、邏輯運算符。

& | ^ ! && ||

邏輯運算符除了 ! 外都是用於鏈接兩個boolean類型表達式。

&: 只有兩邊都爲true結果是true。不然就是false。

|:只要兩邊都爲false結果是false，不然就是true

^:異或：和或有點不同。
兩邊結果同樣，就爲false。
兩邊結果不同，就爲true.
& 和 &&區別： & ：不管左邊結果是什麼，右邊都參與運算。
&&：短路與，若是左邊爲false，那麼右邊不參數與運算。
| 和|| 區別：|：兩邊都運算。
||：短路或，若是左邊爲true，那麼右邊不參與運算。
5）、位運算符:用於操做二進制位的運算符。
& | ^
& << >> >>>(無符號右移)
練習：對兩個變量的數據進行互換。不須要第三方變量。

int a = 3,b = 5;-->b = 3,a = 5; a = a + b; a = 8; b = a - b; b = 3; a = a - b; a = 5; a = a ^ b;// b = a ^ b;//b = a ^ b ^ b = a a = a ^ b;//a = a ^ b ^ a = b; 練習：高效的算出 2*8 = 2<<3;

5，語句。

If switch do while while for
這些語句何時用？
1）、當判斷固定個數的值的時候，可使用if，也可使用switch。
可是建議使用switch，效率相對較高。

switch(變量){
case 值:要執行的語句;break;
…
default:要執行的語句;
}

工做原理：用小括號中的變量的值依次和case後面的值進行對比，和哪一個case後面的值相同了
就執行哪一個case後面的語句，若是沒有相同的則執行default後面的語句；

細節：a：break是能夠省略的，若是省略了就一直執行到遇到break爲止；
b：switch 後面的小括號中的變量應該是byte,char,short,int四種類型中的一種；
c：default能夠寫在switch結構中的任意位置；若是將default語句放在了第一行，則無論expression與case中的value是否匹配，程序會從default開始執行直到第一個break出現。
2）、當判斷數據範圍，獲取判斷運算結果boolean類型時，須要使用if。
3）、當某些語句須要執行不少次時，就用循環結構。 while和for能夠進行互換。
區別在於：若是須要定義變量控制循環次數。建議使用for。由於for循環完畢，變量在內存中釋放。

break:做用於switch ，和循環語句，用於跳出，或者稱爲結束。

break語句單獨存在時，下面不要定義其餘語句，由於執行不到，編譯會失敗。當循環嵌套時，break只跳出當前所在循環。要跳出嵌套中的外部循環，只要給循環起名字便可，這個名字稱之爲標號。

continue:只做用於循環結構，繼續循環用的。

做用：結束本次循環，繼續下次循環。該語句單獨存在時，下面不能夠定義語句，執行不到。

6，函數：爲了提升代碼的複用性，能夠將其定義成一個單獨的功能，該功能的體現就是java中的函數。函數就是體現之一。

java中的函數的定義格式：
修飾符返回值類型函數名(參數類型形式參數1，參數類型形式參數1，…){
執行語句；
return 返回值；
}沒有具體的返回值時，返回的返回值類型用void關鍵字表示。

若是函數的返回值類型是void時，return語句能夠省略不寫的，系統會幫你自動加上。

return的做用：結束函數。結束功能。

如何定義一個函數？

函數其實就是一個功能，定義函數就是實現功能，經過兩個明確來完成：

1）、明確該功能的運算完的結果，實際上是在明確這個函數的返回值類型。

2）、在實現該功能的過程當中是否有未知內容參與了運算，其實就是在明確這個函數的參數列表(參數類型&參數個數)。

函數的做用：

1）、用於定義功能。

2）、用於封裝代碼提升代碼的複用性。

注意：函數中只能調用函數，不能定義函數。

主函數：

1）、保證該類的獨立運行。

2）、由於它是程序的入口。

3）、由於它在被jvm調用。

函數定義名稱是爲何呢？

答：1）、爲了對該功能進行標示，方便於調用。

2）、爲了經過名稱就能夠明確函數的功能，爲了增長代碼的閱讀性。

重載的定義是：在一個類中，若是出現了兩個或者兩個以上的同名函數，只要它們的參數的個數，或者參數的類型不一樣，便可稱之爲該函數重載了。

如何區分重載：當函數同名時，只看參數列表。和返回值類型不要緊。

7，數組：用於存儲同一類型數據的一個容器。好處：能夠對該容器中的數據進行編號，從0開始。數組用於封裝數據，就是一個具體的實體。

如何在java中表現一個數組呢？兩種表現形式。

1）、元素類型[] 變量名 = new 元素類型[元素的個數]；

2）、元素類型[] 變量名 = {元素1，元素2…}；

元素類型[] 變量名 = new 元素類型[]{元素1，元素2…}；

//二分查找法。必須有前提：數組中的元素要有序。

public static int halfSeach_2(int[] arr,int key){ int min,max,mid; min = 0; max = arr.length-1; mid = (max+min)>>1; //(max+min)/2; while(arr[mid]!=key){ if(key>arr[mid]){ min = mid + 1; } else if(key<arr[mid]) max = mid - 1; if(max<min) return -1; mid = (max+min)>>1; } return mid; } ------------------------------------------

java分了5片內存。

1：寄存器。2：本地方法區。3：方法區。4：棧。5：堆。

棧：存儲的都是局部變量 ( 函數中定義的變量，函數上的參數，語句中的變量 )；

只要數據運算完成所在的區域結束，該數據就會被釋放。

堆：用於存儲數組和對象，也就是實體。啥是實體啊？就是用於封裝多個數據的。

1：每個實體都有內存首地址值。

2：堆內存中的變量都有默認初始化值。由於數據類型不一樣，值也不同。

3：垃圾回收機制。

三：面向對象：★★★★★

特色：1：將複雜的事情簡單化。

2：面向對象將之前的過程當中的執行者，變成了指揮者。

3：面向對象這種思想是符合如今人們思考習慣的一種思想。

過程和對象在咱們的程序中是如何體現的呢？過程其實就是函數；對象是將函數等一些內容進行了封裝。

匿名對象使用場景：

1：當對方法只進行一次調用的時候，可使用匿名對象。

2：當對象對成員進行屢次調用時，不能使用匿名對象。必須給對象起名字。

在類中定義其實都稱之爲成員。成員有兩種：

1：成員變量：其實對應的就是事物的屬性。

2：成員函數：其實對應的就是事物的行爲。

因此，其實定義類，就是在定義成員變量和成員函數。可是在定義前，必須先要對事物進行屬性和行爲的分析，才能夠用代碼來體現。

private int age;//私有的訪問權限最低，只有在本類中的訪問有效。

注意：私有僅僅是封裝的一種體現形式而已。
私有的成員：其餘類不能直接建立對象訪問，因此只有經過本類對外提供具體的訪問方式來完成對私有的訪問，能夠經過對外提供函數的形式對其進行訪問。

好處：能夠在函數中加入邏輯判斷等操做，對數據進行判斷等操做。

總結：開發時，記住，屬性是用於存儲數據的，直接被訪問，容易出現安全隱患，因此，類中的屬性一般被私有化，並對外提供公共的訪問方法。

這個方法通常有兩個，規範寫法：對於屬性 xxx，可使用setXXX(),getXXX()對其進行操做。

類中怎麼沒有定義主函數呢？

注意：主函數的存在，僅爲該類是否須要獨立運行，若是不須要，主函數是不用定義的。

主函數的解釋：保證所在類的獨立運行，是程序的入口，被jvm調用。

成員變量和局部變量的區別：

1：成員變量直接定義在類中。

局部變量定義在方法中，參數上，語句中。

2：成員變量在這個類中有效。

局部變量只在本身所屬的大括號內有效，大括號結束，局部變量失去做用域。

3：成員變量存在於堆內存中，隨着對象的產生而存在，消失而消失。

局部變量存在於棧內存中，隨着所屬區域的運行而存在，結束而釋放。

構造函數：用於給對象進行初始化，是給與之對應的對象進行初始化，它具備針對性，函數中的一種。

特色：

1：該函數的名稱和所在類的名稱相同。

2：不須要定義返回值類型。

3：該函數沒有具體的返回值。

記住：全部對象建立時，都須要初始化纔可使用。

注意事項：一個類在定義時，若是沒有定義過構造函數，那麼該類中會自動生成一個空參數的構造函數，爲了方便該類建立對象，完成初始化。若是在類中自定義了構造函數，那麼默認的構造函數就沒有了。

一個類中，能夠有多個構造函數，由於它們的函數名稱都相同，因此只能經過參數列表來區分。因此，一個類中若是出現多個構造函數。它們的存在是以重載體現的。

構造函數和通常函數有什麼區別呢？

1：兩個函數定義格式不一樣。

2：構造函數是在對象建立時，就被調用，用於初始化，並且初始化動做只執行一次。

通常函數，是對象建立後，須要調用才執行，能夠被調用屢次。

何時使用構造函數呢？

分析事物時，發現具體事物一出現，就具有了一些特徵，那就將這些特徵定義到構造函數內。

構造代碼塊和構造函數有什麼區別？

構造代碼塊：是給全部的對象進行初始化，也就是說，全部的對象都會調用一個代碼塊，只要對象一創建，就會調用這個代碼塊。

構造函數：是給與之對應的對象進行初始化，它具備針對性。

「Person p = new Person();」

建立一個對象都在內存中作了什麼事情？

1：先將硬盤上指定位置的Person.class文件加載進內存。

2：執行main方法時，在棧內存中開闢了main方法的空間(壓棧-進棧)，而後在main方法的棧區分配了一個變量p。

3：在堆內存中開闢一個實體空間，分配了一個內存首地址值。new

4：在該實體空間中進行屬性的空間分配，並進行了默認初始化。

5：對空間中的屬性進行顯示初始化。

6：進行實體的構造代碼塊初始化。

7：調用該實體對應的構造函數，進行構造函數初始化。（）

8：將首地址賦值給p ，p變量就引用了該實體。(指向了該對象)

封裝（面向對象特徵之一）：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。

好處：將變化隔離；便於使用；提升重用性；安全性

封裝原則：將不須要對外提供的內容都隱藏起來，把屬性都隱藏，提供公共方法對其訪問。

This：表明對象，就是所在函數所屬對象的引用。

this到底表明什麼呢？哪一個對象調用了this所在的函數，this就表明哪一個對象，就是哪一個對象的引用。

開發時，何時使用this呢？

在定義功能時，若是該功能內部使用到了調用該功能的對象，這時就用this來表示這個對象。

this 還能夠用於構造函數間的調用。

調用格式：this(實際參數)；

this對象後面跟上 . 調用的是成員屬性和成員方法(通常方法)；

this對象後面跟上 () 調用的是本類中的對應參數的構造函數。

注意：用this調用構造函數，必須定義在構造函數的第一行。由於構造函數是用於初始化的，因此初始化動做必定要執行。不然編譯失敗。

static：★★★ 關鍵字，是一個修飾符，用於修飾成員(成員變量和成員函數)。

特色：

1，想要實現對象中的共性數據的對象共享，能夠將這個數據進行靜態修飾。

2，被靜態修飾的成員，能夠直接被類名所調用。也就是說，靜態的成員多了一種調用方式。類名.靜態方式。

3，靜態隨着類的加載而加載，並且優先於對象存在。

弊端：

1，有些數據是對象特有的數據，是不能夠被靜態修飾的。由於那樣的話，特有數據會變成對象的共享數據。這樣對事物的描述就出了問題。因此，在定義靜態時，必需要明確，這個數據是不是被對象所共享的。

2，靜態方法只能訪問靜態成員，不能夠訪問非靜態成員。

由於靜態方法加載時，優先於對象存在，因此沒有辦法訪問對象中的成員。

3，靜態方法中不能使用this，super關鍵字。

由於this表明對象，而靜態在時，有可能沒有對象，因此this沒法使用。

4，主函數是靜態的。

何時定義靜態成員呢？或者說：定義成員時，到底需不須要被靜態修飾呢？

成員分兩種：

1，成員變量。（數據共享時靜態化）

該成員變量的數據是不是全部對象都同樣：

若是是，那麼該變量須要被靜態修飾，由於是共享的數據。

若是不是，那麼就說這是對象的特有數據，要存儲到對象中。

2，成員函數。（方法中沒有調用特有數據時就定義成靜態）

若是判斷成員函數是否須要被靜態修飾呢？

只要參考，該函數內是否訪問了對象中的特有數據：

若是有訪問特有數據，那方法不能被靜態修飾。

若是沒有訪問過特有數據，那麼這個方法須要被靜態修飾。

成員變量和靜態變量的區別：

1，成員變量所屬於對象，因此也稱爲實例變量。

靜態變量所屬於類，因此也稱爲類變量。

2，成員變量存在於堆內存中。

靜態變量存在於方法區中。

3，成員變量隨着對象建立而存在，隨着對象被回收而消失。

靜態變量隨着類的加載而存在，隨着類的消失而消失。

4，成員變量只能被對象所調用。

靜態變量能夠被對象調用，也能夠被類名調用。

因此，成員變量能夠稱爲對象的特有數據，靜態變量稱爲對象的共享數據。

靜態的注意：靜態的生命週期很長。

靜態代碼塊：就是一個有靜態關鍵字標示的一個代碼塊區域，定義在類中。

做用：能夠完成類的初始化，靜態代碼塊隨着類的加載而執行，並且只執行一次（new 多個對象就只執行一次）。若是和主函數在同一類中，優先於主函數執行。

Public：訪問權限最大。

static：不須要對象，直接類名便可。

void：主函數沒有返回值。

Main：主函數特定的名稱。

(String[] args)：主函數的參數，是一個字符串數組類型的參數，jvm調用main方法時，傳遞的實際參數是 new String[0]。

jvm默認傳遞的是長度爲0的字符串數組，咱們在運行該類時，也能夠指定具體的參數進行傳遞。能夠在控制檯，運行該類時，在後面加入參數。參數之間經過空格隔開。jvm會自動將這些字符串參數做爲args數組中的元素，進行存儲。

靜態代碼塊、構造代碼塊、構造函數同時存在時的執行順序：靜態代碼塊 —>構造代碼塊 –> 構造函數；

生成Java幫助文檔：命令格式：javadoc –d 文件夾名 –auther –version *.java

/** //格式

*類描述

*@author 做者名

*@version 版本號

/**

*方法描述

*@param 參數描述

*@return 返回值描述

設計模式：解決問題最行之有效的思想。是一套被反覆使用、多數人知曉的、通過分類編目的、代碼設計經驗的總結。使用設計模式是爲了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。

java中有23種設計模式：

單例設計模式：★★★★★

解決的問題：保證一個類在內存中的對象惟一性。

好比：多程序讀取一個配置文件時，建議配置文件封裝成對象。會方便操做其中數據，又要保證多個程序讀到的是同一個配置文件對象，就須要該配置文件對象在內存中是惟一的。

Runtime()方法就是單例設計模式進行設計的。

如何保證對象惟一性呢？

思想：

1，不讓其餘程序建立該類對象。

2，在本類中建立一個本類對象。

3，對外提供方法，讓其餘程序獲取這個對象。

步驟：

1，由於建立對象都須要構造函數初始化，只要將本類中的構造函數私有化，其餘程序就沒法再建立該類對象；

2，就在類中建立一個本類的對象；

3，定義一個方法，返回該對象，讓其餘程序能夠經過方法就獲得本類對象。（做用：可控）

代碼體現：

1，私有化構造函數；

2，建立私有並靜態的本類對象；

3，定義公有並靜態的方法，返回該對象。

---------------------------------------------

//餓漢式 class Single{ private Single(){} //私有化構造函數。 private static Single s = new Single(); //建立私有並靜態的本類對象。 public static Single getInstance(){ //定義公有並靜態的方法，返回該對象。 return s; } }

//懶漢式:延遲加載方式。 class Single2{ private Single2(){} private static Single2 s = null; public static Single2 getInstance(){ if(s==null) s = new Single2(); return s; } } -------------------------------------------------------------------------------------------------

繼承（面向對象特徵之一）

好處：

1：提升了代碼的複用性。

2：讓類與類之間產生了關係，提供了另外一個特徵多態的前提。

父類的由來：實際上是由多個類不斷向上抽取共性內容而來的。

java中對於繼承，java只支持單繼承。java雖然不直接支持多繼承，可是保留了這種多繼承機制，進行改良。

單繼承：一個類只能有一個父類。

多繼承：一個類能夠有多個父類。

爲何不支持多繼承呢？

由於當一個類同時繼承兩個父類時，兩個父類中有相同的功能，那麼子類對象調用該功能時，運行哪個呢？由於父類中的方法中存在方法體。

可是java支持多重繼承。A繼承B B繼承C C繼承D。

多重繼承的出現，就有了繼承體系。體系中的頂層父類是經過不斷向上抽取而來的。它裏面定義的該體系最基本最共性內容的功能。

因此，一個體系要想被使用，直接查閱該系統中的父類的功能便可知道該體系的基本用法。那麼想要使用一個體系時，須要創建對象。建議創建最子類對象，由於最子類不只可使用父類中的功能。還可使用子類特有的一些功能。

簡單說：對於一個繼承體系的使用，查閱頂層父類中的內容，建立最底層子類的對象。

子父類出現後，類中的成員都有了哪些特色：

1：成員變量。

當子父類中出現同樣的屬性時，子類類型的對象，調用該屬性，值是子類的屬性值。

若是想要調用父類中的屬性值，須要使用一個關鍵字：super

This：表明是本類類型的對象引用。

Super ：表明是子類所屬的父類中的內存空間引用。

注意：子父類中一般是不會出現同名成員變量的，由於父類中只要定義了，子類就不用在定義了，直接繼承過來用就能夠了。

2：成員函數。

當子父類中出現瞭如出一轍的方法時，創建子類對象會運行子類中的方法。好像父類中的方法被覆蓋掉同樣。因此這種狀況，是函數的另外一個特性：覆蓋(複寫，重寫)

何時使用覆蓋呢？當一個類的功能內容須要修改時，能夠經過覆蓋來實現。

3：構造函數。

發現子類構造函數運行時，先運行了父類的構造函數。爲何呢?

緣由：子類的全部構造函數中的第一行，其實都有一條隱身的語句super();

super(): 表示父類的構造函數，並會調用於參數相對應的父類中的構造函數。而super():是在調用父類中空參數的構造函數。

爲何子類對象初始化時，都須要調用父類中的函數？(爲何要在子類構造函數的第一行加入這個super()?)

由於子類繼承父類，會繼承到父類中的數據，因此必需要看父類是如何對本身的數據進行初始化的。因此子類在進行對象初始化時，先調用父類的構造函數，這就是子類的實例化過程。

注意：子類中全部的構造函數都會默認訪問父類中的空參數的構造函數，由於每個子類構造內第一行都有默認的語句super();

若是父類中沒有空參數的構造函數，那麼子類的構造函數內，必須經過super語句指定要訪問的父類中的構造函數。

若是子類構造函數中用this來指定調用子類本身的構造函數，那麼被調用的構造函數也同樣會訪問父類中的構造函數。

問題：super()和this()是否能夠同時出現的構造函數中。

兩個語句只能有一個定義在第一行，因此只能出現其中一個。

super()或者this():爲何必定要定義在第一行？

由於super()或者this()都是調用構造函數，構造函數用於初始化，因此初始化的動做要先完成。

繼承的細節：

何時使用繼承呢？

當類與類之間存在着所屬關係時，才具有了繼承的前提。a是b中的一種。a繼承b。狼是犬科中的一種。

英文書中，所屬關係：」 is a 「

注意：不要僅僅爲了獲取其餘類中的已有成員進行繼承。

因此判斷所屬關係，能夠簡單看，若是繼承後，被繼承的類中的功能，均可以被該子類所具有，那麼繼承成立。若是不是，不能夠繼承。

細節二：

在方法覆蓋時，注意兩點：

1：子類覆蓋父類時，必需要保證，子類方法的權限必須大於等於父類方法權限能夠實現繼承。不然，編譯失敗。

2：覆蓋時，要麼都靜態，要麼都不靜態。 (靜態只能覆蓋靜態，或者被靜態覆蓋)

繼承的一個弊端：打破了封裝性。對於一些類，或者類中功能，是須要被繼承，或者複寫的。

這時如何解決問題呢？介紹一個關鍵字，final:最終。

final特色：

1：這個關鍵字是一個修飾符，能夠修飾類，方法，變量。

2：被final修飾的類是一個最終類，不能夠被繼承。

3：被final修飾的方法是一個最終方法，不能夠被覆蓋。

4：被final修飾的變量是一個常量，只能賦值一次。

其實這樣的緣由的就是給一些固定的數據起個閱讀性較強的名稱。
不加final修飾不是也可使用嗎？那麼這個值是一個變量，是能夠更改的。加了final，程序更爲嚴謹。常量名稱定義時，有規範，全部字母都大寫，若是由多個單詞組成，中間用 _ 鏈接。

抽象類: abstract

抽象：不具體，看不明白。抽象類表象體現。

在不斷抽取過程當中，將共性內容中的方法聲明抽取，可是方法不同，沒有抽取，這時抽取到的方法，並不具體，須要被指定關鍵字abstract所標示，聲明爲抽象方法。

抽象方法所在類必定要標示爲抽象類，也就是說該類須要被abstract關鍵字所修飾。

抽象類的特色：

1：抽象方法只能定義在抽象類中，抽象類和抽象方法必須由abstract關鍵字修飾（能夠描述類和方法，不能夠描述變量）。

2：抽象方法只定義方法聲明，並不定義方法實現。

3：抽象類不能夠被建立對象(實例化)。

4：只有經過子類繼承抽象類並覆蓋了抽象類中的全部抽象方法後，該子類才能夠實例化。不然，該子類仍是一個抽象類。

抽象類的細節：

1：抽象類中是否有構造函數？有，用於給子類對象進行初始化。

2：抽象類中是否能夠定義非抽象方法？

能夠。其實，抽象類和通常類沒有太大的區別，都是在描述事物，只不過抽象類在描述事物時，有些功能不具體。
因此抽象類和通常類在定義上，都是須要定義屬性和行爲的。
只不過，比通常類多了一個抽象函數。並且比通常類少了一個建立對象的部分。

3：抽象關鍵字abstract和哪些不能夠共存？final , private , static

4：抽象類中可不能夠不定義抽象方法？能夠。抽象方法目的僅僅爲了避免讓該類建立對象。

模板方法設計模式：

解決的問題：當功能內部一部分實現時肯定，一部分實現是不肯定的。這時能夠把不肯定的部分暴露出去，讓子類去實現。

abstract class GetTime{ public final void getTime(){ //此功能若是不須要複寫，可加final限定 long start = System.currentTimeMillis(); code(); //不肯定的功能部分，提取出來，經過抽象方法實現 long end = System.currentTimeMillis(); System.out.println("毫秒是："+(end-start)); } public abstract void code(); //抽象不肯定的功能，讓子類複寫實現 } class SubDemo extends GetTime{ public void code(){ <font color=red >//子類複寫功能方法</font> for(int y=0; y<1000; y++){ System.out.println("y"); } } }

AWT和Swing是兩種工具包，包中所提供的工具類主要分爲三種：組件、容器、佈局管理器。

組件：全部的組件類都是從component和menu component中擴展而來的，在圖形界面中用戶常常會看到一個個的按鈕、標籤、菜單等等都是組件。

容器:能夠放容器和組件，如Frame、panel等等

佈局管理器：能夠是容器裏的組件按照指定位置進行擺放。

對於AWT與swing咱們重點學習的是swing輕量級組件。

JFrame基本容器（也就是窗口的意思)-

必定要熟悉jframe的經常使用操做方法，下圖我是從網上截圖下來的

都已熟悉以上操做！

除了jframe容器，還有JPanel等等，我一一解釋

JPanel(面板)容器：

倆個構造方法： public JPanel （）；建立一個默認的JPanel對象，使用流佈局管理

public JPanel （JayoutManager layout） ;建立一個指定佈局管理器的JPanel對象

對此就是在窗口容器裏添加多個JPanel容器，同時利用佈局管理器進行組件之間的管理，更加方便管理組件。

JSplitPane(分隔板)容器：分割面板，能夠將窗體分爲子窗口。

以上就是我用JSplitPane的簡單例題；

還要熟悉它的經常使用方法詳細見p664

JTabbedPane容器：設置多個選項卡

以上也是例子

一樣的也是要熟悉該容器的經常使用方法！

JScrollPane容器：爲顯示的內容加入水平滾動條。（咱們日常所見的滾動條）

以後還學習了倆個相關組件，標籤組件JLabel和按鈕組件JButton，這個比較簡單，我就不說了。上面也應用過。下面介紹的是佈局管理器

一共有五個佈局管理器。詳解見書p657-661

本週主要學習的是選擇框、單選框和單選按鈕。這些都是選擇組件，選擇組件有兩種狀態，一種是選中(on)，另外一種是未選中(off)。接下來仔細總結一下。

選擇框(JCheckBox) 又稱爲複選框，它的選中與否開狀是一個小方框，被選中則在框中打勾。當在一個容器中有多個選擇框，同時能夠有多個選擇框被選中，這樣的選擇框，稱複選框。與選擇框相關的接口是ItemListener，事件類是ItemEvent。

JCheckBox類經常使用的構造方法有如下3個：

JCheckBox()：用空標題構造選擇框。

JCheckBox(String s)：用給定的標題s構造選擇框。

JCheckBox(String s, boolean b)：用給定的標題s構造選擇框，參數b設置選中與否的初始狀態。

單選框：當在一個容器中放入多個選擇框，且沒有ButtonGroup對象將它們分組，則能夠同時選中多個選擇框。若是使用ButtonGroup對象將選擇框分組，同一時刻組內的多個

選擇框只容許有一個被選中，稱同一組內的選擇框爲單選框。單選框分組的方法是先建立ButtonGroup對象，而後將但願爲同組的選擇框添加到同一個ButtonGroup對象中

單選按鈕(JRadioButton)的功能與單選框類似。使用單選按鈕的方法是將一些單選按鈕用ButtonGroup對象分組，使同一組的單選按鈕只容許有一個被選中。單選按鈕與單選

框的差別是顯示的樣式不一樣，單選按鈕是一個圓形的按鈕，單選框是一個小方框。

JRadioButton類的經常使用構造方法有如下幾個：

JRadioButton()：用空標題構造單選按鈕。

JRadioButton(String s)：用給定的標題s構造單選按鈕。

JRadioButton(String s,boolean b)：用給定的標題s構造單選按鈕,參數b設置選中與否的初始狀態。

單選按鈕使用時須要使用ButtonGroup將單選按鈕分組，單選按鈕的分組方法是先建立對象，而後將同組的單選按鈕添加到同一個ButtonGroup對象中。

列表框（JList）：它能夠同時將多個選項信息以列表的方式展示給顧客。它的經常使用構造方法以下：

public JList(ListModel dateModel)：根據ListModel構造JList。

public JList(Object[] listDate)：根據對象數組構造JList。

package demo;

import javax.swing.*;
 
public class Calculator {
 
    public static void main(String[] args)
    {
        javax.swing.SwingUtilities.invokeLater(new Runnable()
        {
            public void run()
            {
                createGUI();
            }
        });
    }
    protected static void createGUI()
    {
        myFrame frame = new myFrame("Swing Demo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(600,400);
        frame.setVisible(true);
        
    }
 
}

 
         package  
         demo; 
        
         import  
         java.awt.*; 
        
         import  
         java.awt.event.ActionEvent; 
        
         import  
         java.awt.event.ActionListener; 
        
         import  
         javax.swing.*; 
        
         public  
         class  
         myFrame  
         extends  
         JFrame{ 
        
         JCheckBox checkbox =  
         new  
         JCheckBox( 
         "請輸入郵箱地址" 
         ); 
        
         JTextField email =  
         new  
         JTextField( 
         16 
         ); 
        
         public  
         myFrame(String title) 
        
         { 
        
         super 
         (title); 
        
         Container contentPane = getContentPane(); 
        
         contentPane.setLayout( 
         new  
         FlowLayout()); 
        
         contentPane.add(checkbox); 
        
         contentPane.add(email); 
        
         checkbox.setSelected( 
         true 
         ); 
        
         email.setToolTipText( 
         "請輸入郵箱地址" 
         ); 
        
         checkbox.addActionListener( 
         new  
         ActionListener() { 
        
         public  
         void  
         actionPerformed(ActionEvent arg0) 
        
         { 
        
         email.setEnabled(checkbox.isSelected()); 
        
         } 
        
         }); 
        
         } 
        
         }

　　運行截圖：

1 package demo;
 2 
 3 import javax.swing.*;   
 4 
 5 public class Calculator
 6 {
 7     public static void main(String[] args) 
 8     {    
 9         JFrame j1 = new JFrame("Box");   
10         j1.setSize(200, 200);          
11         JPanel j2 = new JPanel();     
12         JRadioButton c1 = new JRadioButton("see you again",true);
13         JRadioButton c2 = new JRadioButton("Rolling in the deep");
14         JRadioButton c3 = new JRadioButton("all falls down");
15         JRadioButton c4 = new JRadioButton("apoligize");
16         
17         ButtonGroup group = new ButtonGroup();
18         group.add(c1);
19         group.add(c2);
20         group.add(c3);
21         group.add(c4);
22     
23         JLabel l1 = new JLabel("你更喜歡哪首歌:");
24         j2.add(l1);
25         j2.add(c1);
26         j2.add(c2);
27         j2.add(c3);
28         j2.add(c4);
29         
30         j1.add(j2);    
31         j1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
32         j1.setVisible(true);
33     }
34 }

運行截圖

package demo;

import java.awt.*;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
 
public class Calculator extends JFrame{
       public Calculator(){
           this.setTitle("列表框使用");
           this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
           this.setBounds(100, 100, 250, 130);
           JPanel contentPane=new JPanel();
           contentPane.setBorder(new EmptyBorder(5,5,5,5));
           this.setContentPane(contentPane);
           contentPane.setLayout(new FlowLayout(FlowLayout.CENTER,5,5));
           JLabel label=new JLabel("證件類型:");
           contentPane.add(label);
           JList list=new JList(new String[]{"身份證","駕駛證","軍官證"});
           contentPane.add(list);
           this.setVisible(true);
       }
       public static void main(String[]args){
           Calculator example=new Calculator();
       }
}

運行截圖