1、Eclipse開發(fā)工具
1.1 Eclipse歷史
Eclipse中文翻譯為日蝕，指的是吞沒一切的光芒，那么這個(gè)及其具備挑釁一位的名字實(shí)際上是針對(duì)于SU年公司。在2000年之后一直處于互聯(lián)網(wǎng)低潮，而SUN公司從這一低潮之后就再也沒有起來過，而后SUN公司最為尷尬的是，他在硬件上沒有過多的收益，而且軟件的編程語言Java也不是SUN的賺錢工具，它只是變成了一個(gè)出賣版權(quán)的公司了。
對(duì)于Java的IDE（集成開發(fā)環(huán)境）本身也是經(jīng)過了一些歷史的調(diào)整。
? 1995年的時(shí)候，Java誕生，但是SUN公司卻高調(diào)宣布，我們自己不生成IDE，給其他第三方公司生產(chǎn)；
? 在Java產(chǎn)生之后，Borland公司來時(shí)入手Java的IDE生產(chǎn)，所以后來的JBuilder就成為了Java開發(fā)的唯一選擇（不選擇JBuilder都使用記事本，IDEA,JCREATOR,EDIPLUS….），后倆一直到了JBuilderX之后才正常；
? 2003年之后有了Eclipse，在2004年之后有了SUN自己的開發(fā)工具———NetBeans
而從整個(gè)國(guó)內(nèi)的Java開發(fā)模式上也一直在發(fā)生著改變；
? 豪華級(jí)架構(gòu)：操作系統(tǒng)+數(shù)據(jù)庫(kù)+中間件+開發(fā)工具+編程語言；
? IBM體系：AIX+IBM DB2+WwbsphereApplicationServer+WSAD；
? 超級(jí)雜牌軍體系：UNIX+Oracle+Weblogic+JBuilder；
免費(fèi)架構(gòu)：Linux+MySQL+Tomcat/JBoss+Eclipse；
而對(duì)于開發(fā)工具最早的霸主就是JBuilder，但是遺憾的是，2006年的時(shí)候Borland倒閉了，倒閉的原因是因?yàn)闆]有干聲多為的開源風(fēng)潮，因?yàn)橛性S多的學(xué)習(xí)者，它可能并不需要如此專業(yè)的工具，所以當(dāng)時(shí)Borland公司的市場(chǎng)就出現(xiàn)了問題，于是倒閉就成為了必然，最后Borland技術(shù)部單獨(dú)成立了一家技術(shù)公司，繼續(xù)從事JBuilder的研究，但是今天的JBuilder已經(jīng)基本上無法去問津了，完全被Eclipse取代了。
Eclipse是由IBM開發(fā)的，之后將其轉(zhuǎn)送給了今天的Eclipse組織，進(jìn)行開源項(xiàng)目的推廣，而Eclipse的前身是IBM VisualAge，而后IBM根據(jù)Eclipse的1.0模型，產(chǎn)生后來的WSAD來發(fā)工具。Eclipse本身是免費(fèi)的，但是其是靠插件收費(fèi)（中國(guó)連插件都不需要收費(fèi)），其本身有一下幾個(gè)基本組成：JDT,JUNIT測(cè)試工具,CVS客戶端，插件開發(fā)，用戶可以直接登陸www.eclipse.org下載Eclipse的最新版本，JUNO（朱諾，小行星的名字）版，而且Eclipse現(xiàn)在可以直接解壓縮后使用，不用單獨(dú)的安裝，是純粹的綠色版。
當(dāng)我們Java項(xiàng)目簡(jiǎn)歷完成值周，可以在項(xiàng)目的目錄小發(fā)現(xiàn)兩個(gè)文件夾：
? Src:是保存所有的*.java程序，都是按照包名稱進(jìn)行保存的；
? Bin：保存所有生成的*.class文件，按照包名稱進(jìn)行保存的。
下面簡(jiǎn)歷一個(gè)新的類：TestDemo.java
使用Eclipse本身最大的好處在于方便的進(jìn)行隨筆提示，并且在每一次*.java程序保存的時(shí)候，會(huì)由Eclipse自動(dòng)的將其編譯為*.class文件。
另外在Eclipse之中還可以存在一些代碼生成工具，例如：現(xiàn)在有如下簡(jiǎn)單類
|
1
2
3
4
5
6
|
package com.sxau;public class Person { private String name; private int age;} |
這個(gè)類肯定是作為簡(jiǎn)單Java類出現(xiàn)，那么現(xiàn)在很明顯簡(jiǎn)單Java類的開發(fā)原則：
所有屬性封裝，已經(jīng)封裝；生成setter，getter方法；構(gòu)造方法，必須要有無參構(gòu)造覆寫Object中的一些方法
1.2 快捷鍵
除了以上的生成方式還可以通過快捷鍵生成
ALT+/：代碼自動(dòng)補(bǔ)充提示；CTRL+1：進(jìn)行錯(cuò)誤代碼矯正提示；CTRL+D：刪除當(dāng)前行代碼；CTRL+SHIFT+O：自動(dòng)導(dǎo)入包；CTRL+SHIFT+F：格式化代碼顯示；CTRL+/：注釋/取消注釋；CTRL+shift+l：快捷鍵列表CTRL+H：搜索
項(xiàng)目也可以進(jìn)行刪除操作，但是在刪除項(xiàng)目的時(shí)候有兩種方式：
? 方式一：是從項(xiàng)目的工作區(qū)之中刪除，以后可以恢復(fù)；
? 方式二：徹底從硬盤上刪除項(xiàng)目。
如果想導(dǎo)入項(xiàng)目則可以使用導(dǎo)入的方式。
? 以上是利用導(dǎo)入的方式完成了項(xiàng)目的導(dǎo)入，而現(xiàn)在也可以通過導(dǎo)出的方式，將一個(gè)項(xiàng)目之中的所有*.class文件自動(dòng)生成*.jar文件。
1.3 Debug調(diào)試
在Eclipse之中，為了方便永華的開發(fā)，還提供了DEBUG功能，可以利用此功能進(jìn)行項(xiàng)目的調(diào)試操作，而如果要想進(jìn)行調(diào)試，首先需要設(shè)置斷點(diǎn)。斷點(diǎn)指的是程序執(zhí)行到此處的時(shí)候，自動(dòng)停止，而后交給人工控制執(zhí)行。
**范例：**設(shè)置斷點(diǎn)
|
1
2
3
4
5
6
7
8
9
10
|
package com.util;public class MyMath { private MyMath(){} public static int add(int x, int y){ int temp = 0; temp = x + y; return temp; }} |
測(cè)試類
|
1
2
3
4
5
6
7
8
9
10
11
|
package com.test;import com.util.MyMath;public class TestMath { public static void main(String[] args) { int result = MyMath.add(2, 3);//將此處設(shè)置為斷電 System.out.println("加法結(jié)果" + result); } } |
進(jìn)入調(diào)試試圖之后可以通過以下方式進(jìn)行代碼調(diào)試：
- 單步跳入（F5）：進(jìn)入到代碼之中觀察代碼的執(zhí)行；
- 單步跳過（F6）：不關(guān)心代碼之中的執(zhí)行，只關(guān)心最終的結(jié)果；
- 單步返回（F7）：返回到單步跳過的狀態(tài)
- 恢復(fù)執(zhí)行（F8）：不再調(diào)試直接將程序運(yùn)行完成。
1.4 JUNIT測(cè)試工具
軟件測(cè)試行業(yè)：2003年——2006年之后，各個(gè)公司一直都在招聘軟件測(cè)試人員，而且都是外包到IBM或微軟的公司進(jìn)行測(cè)試。但是，今天的軟件測(cè)試來講，這個(gè)行業(yè)已經(jīng)很難了。
軟件測(cè)試是一個(gè)黃金職位，對(duì)于軟件測(cè)試是需要有一套完整測(cè)試?yán)碚摵蛿?shù)據(jù)設(shè)計(jì)的，而如果學(xué)習(xí)過軟件工程應(yīng)該知道軟件測(cè)試分為兩類：
? 1 黑盒測(cè)試：主要是測(cè)試功能，例如一些xx版，是不接觸代碼的，但是公司會(huì)提供工具；
? 2 白盒測(cè)試：指的是性能測(cè)試，或者是算法調(diào)整。
而這幾年隨著行業(yè)的發(fā)展，實(shí)際上又給出了一種新的測(cè)試職位——Use Case(用測(cè))測(cè)試工程師，對(duì)于這種職位而言，國(guó)內(nèi)的平均待遇是程序員的3-5倍，如果按照正常的一個(gè)程序員的工資是8000來算，那么這種人的平均工資就是2-5萬，但是人很難難找，一般而言此類人員在行業(yè)中需要8-10年的項(xiàng)目經(jīng)驗(yàn)，并且精通業(yè)務(wù)。
JUNIT是一個(gè)比較常用的測(cè)試工具，準(zhǔn)們可以進(jìn)行Use Case測(cè)試的，在日后所開發(fā)的程序里都要寫大量的JUNIT測(cè)試程序。
**范例：**定義要測(cè)試的程序
|
1
2
3
4
5
6
7
8
9
10
|
package com.util;public class MyMath { private MyMath(){} public static int add(int x, int y){ int temp = 0; temp = x + y; return temp; }} |
測(cè)試類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package com.test;import static org.junit.Assert.*;import org.junit.Test;import com.util.MyMath;import junit.framework.TestCase;public class MyMathTest { @Test public void testAdd() { TestCase.assertEquals(MyMath.add(2, 3), 5); }} |
建立JUNIT測(cè)試的時(shí)候有兩種形式：
? 1.JUNIT Test Case：表示一個(gè)測(cè)試用例，主要完成一個(gè)業(yè)務(wù)的測(cè)試；
? 2.JUNIT Test Case：表示一組測(cè)試用例，包含多個(gè)Test Case。
對(duì)于JUNIT的測(cè)試結(jié)果來說，一共分為兩種：
? 1.GREEM BAR：測(cè)試通過；
? 2.RED BAR：測(cè)試失敗。
2、Java基礎(chǔ)新特性
Java的發(fā)展從1995年開始經(jīng)歷了許多的過程，但是有三個(gè)最具有代表性的JDK版本；
JDK1.0：標(biāo)志著java的誕生；
JDK1.2：加入了javax.swing組件，這是主要新特性；
JDK1.5：標(biāo)記為tiger，出現(xiàn)了許多一直沿用至今的特性；
JDK1.8：Lambda表達(dá)式、接口的定義加強(qiáng)
已經(jīng)接觸過了一些新特性，例如：自動(dòng)裝箱與拆箱、switch對(duì)String的判斷支持。
2.1 可變參數(shù)
在講解可變參數(shù)之前，首先思考一個(gè)問題：如果說現(xiàn)在要實(shí)現(xiàn)若干個(gè)整型變量的相加操作，問，此方法該如何設(shè)計(jì)？使用數(shù)組接收，因?yàn)閰?shù)個(gè)數(shù)不確定，按照之前所學(xué)，只能使用數(shù)組完成。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package com.demo;/** * @author 張晟睿 * */public class TestDemo { public static void main(String[] args) { System.out.println(add(new int[]{1})); System.out.println(add(new int[]{1,2,3})); System.out.println(add(new int[]{1,2,3,4,5,6,7})); } /** * 實(shí)現(xiàn)任意個(gè)數(shù)的數(shù)據(jù)相加操作處理 * @param data相加操作數(shù)據(jù) * @return 返回多個(gè)數(shù)據(jù)的相加結(jié)果 */public static int add(int [] data){ int sum = 0; for (int i = 0; i < data.length; i++) { sum += data[i]; } return sum; }} |
以上的確是實(shí)現(xiàn)了技術(shù)要求，但是現(xiàn)在有一個(gè)新的問題產(chǎn)生了：如果按照題目要求，應(yīng)該是可以任意的傳遞多個(gè)數(shù)據(jù)，但是以上實(shí)際上傳的是一個(gè)數(shù)據(jù)，只不過一個(gè)數(shù)據(jù)使用數(shù)組的形式封裝。那么為了更好的解決這個(gè)問題，可以使用JDK1.5的可變參數(shù)的方式來解決此問題
|
1
2
3
|
Public [static] [final] 返回值類型 方法名稱（參數(shù)類型…變量）{ //雖然方式改變了 [return [返回值];]} |
發(fā)現(xiàn)現(xiàn)在進(jìn)行方法參數(shù)的定義的時(shí)候有了一些變化，而這個(gè)時(shí)候的參數(shù)可以說是數(shù)組形式。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package com.demo;/** * @author 張晟睿 * */public class TestDemo { public static void main(String[] args) { System.out.println(add(1)); System.out.println(add(1,2,3)); System.out.println(add(1,2,3,4,5,6,7)); } /** * 實(shí)現(xiàn)任意個(gè)數(shù)的數(shù)據(jù)相加操作處理 * @param data相加操作數(shù)據(jù) * @return 返回多個(gè)數(shù)據(jù)的相加結(jié)果 */public static int add(int ... data){ int sum = 0; for (int i = 0; i < data.length; i++) { sum += data[i]; } return sum; }} |
有了可變參數(shù)在日后進(jìn)行方法調(diào)用的過程之中，就可以比較直觀的傳遞任意多個(gè)參數(shù)，但是異常的操作在開發(fā)之中不建議使用，最好別用。
2.2 foreach輸出
首先需要解釋的是：foreach并不是新的概念，最早是在NET中提出來的，多為foreach可以理解為增強(qiáng)型的for循環(huán)，下面來回顧一下最早的for循環(huán)：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
package com.demo;/** * @author 張晟睿 * */public class TestDemo { public static void main(String[] args) { System.out.println(add(1)); System.out.println(add(1,2,3)); System.out.println(add(1,2,3,4,5,6,7)); } /** * 實(shí)現(xiàn)任意個(gè)數(shù)的數(shù)據(jù)相加操作處理 * @param data相加操作數(shù)據(jù) * @return 返回多個(gè)數(shù)據(jù)的相加結(jié)果 */public static int add(int ... data){//接收原始數(shù)組 int sum = 0; for (int i : data) { //將數(shù)組中的每一個(gè)元素設(shè)置給x sum += i;//這種循環(huán)避免了腳標(biāo)的問題 } return sum; }} |
但是有了foreach之后，那么對(duì)于數(shù)組或者是集合的輸出就有了新的支持，語法如下：
|
1
2
3
|
for(數(shù)據(jù)類型 變量 ：數(shù)組|集合){ //操作代碼} |
對(duì)于這種for循環(huán)避免了數(shù)組越界的問題，但依然只是要求會(huì)使用，能看懂就行，不過個(gè)人建議：最好別用。
2.3 靜態(tài)導(dǎo)入
如果說想在想要導(dǎo)入一個(gè)不同包的類的方法，那么肯定使用import完成，即：如下是之前所采用的格式。
定義一個(gè)MyMath類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package com.util;public class MyMath { private MyMath(){} public static int add(int x, int y){ int temp = 0; temp = x + y; return temp; } public static int sub(int x,int y){ return x-y; } public static int mul(int x,int y){ return x*y; } public static int div(int x,int y){ return x/y; }} |
在JDK1.5值周，如果一個(gè)雷之中的全部方法都是static型的，則可以使用如下的語法進(jìn)行導(dǎo)入：
|
1
|
import static 包.類.*； |
表示的是將這個(gè)指定類之中的全部方法導(dǎo)入進(jìn)來，最后就好像這些方法全部都是在主類之中定義的一樣。
|
1
2
3
4
5
6
7
8
9
10
|
package com.test;import static com.util.MyMath.*;//靜態(tài)導(dǎo)入public class TestMath { public static void main(String[] args) { System.out.println(add(10,20)); System.out.println(sub(30,10)); }} |
這種比較難受的方法，也只是出現(xiàn)在講課之中，本人是絕對(duì)不會(huì)使用的，你們也可以忘記它。
3、 JDK三大主要特性——泛型
泛型可以幫助我們解決參數(shù)轉(zhuǎn)換的問題
3.1 泛型的引出
下面首先通過一個(gè)簡(jiǎn)單分析來研究一下泛型出現(xiàn)的主要目的是什么？例如現(xiàn)在要求定義一個(gè)表示坐標(biāo)的操作類（Point）這個(gè)類可以表示三種類型的坐標(biāo)：
? 整數(shù)坐標(biāo)：x=10、y=20；
? 小數(shù)坐標(biāo)：x=10.1、y=20.3；
? 字符串?dāng)?shù)據(jù)：x=“東經(jīng)10度”、y=“西經(jīng)20度”。
類之中如果想要表示以上的數(shù)據(jù)，一定需要定義x和y兩個(gè)屬性，而且每一個(gè)屬性可以接收三種數(shù)據(jù)類型，那么只能使用Object類來定義會(huì)比較合適，這樣會(huì)發(fā)生如下的幾種轉(zhuǎn)換關(guān)系：
整數(shù)：int→自動(dòng)裝箱為Integer→向上轉(zhuǎn)型為Object；
小數(shù)：double→自動(dòng)裝箱為Double→向上轉(zhuǎn)型為Obejct;
字符串：字符串→向上轉(zhuǎn)型為Obejct；
設(shè)置整形
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package com.demo;class Point { private Object x; private Object y; public Object getX() { return x; } public void setX(Object x) { this.x = x; } public Object getY() { return y; } public void setY(Object y) { this.y = y; }}public class PointDemo { public static void main(String[] args) { //第一步：設(shè)置數(shù)據(jù) Point p = new Point(); p.setX(10); p.setY(20); //第二步：取出數(shù)據(jù) int x = (Integer)p.getX(); int y = (Integer)p.getY(); System.out.println("x = " + x + ",y = " + y); }} |
設(shè)置小數(shù)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package com.demo;class Point { private Object x; private Object y; public Object getX() { return x; } public void setX(Object x) { this.x = x; } public Object getY() { return y; } public void setY(Object y) { this.y = y; }}public class PointDemo { public static void main(String[] args) { //第一步：設(shè)置數(shù)據(jù) Point p = new Point(); p.setX(10.1); p.setY(20.2); //第二步：取出數(shù)據(jù) double x = (Double)p.getX(); double y = (Double)p.getY(); System.out.println("x = " + x + ",y = " + y); }} |
設(shè)置字符串
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package com.demo;class Point { private Object x; private Object y; public Object getX() { return x; } public void setX(Object x) { this.x = x; } public Object getY() { return y; } public void setY(Object y) { this.y = y; }}public class PointDemo { public static void main(String[] args) { //第一步：設(shè)置數(shù)據(jù) Point p = new Point(); p.setX("東經(jīng)10"); p.setY("西經(jīng)20"); //第二步：取出數(shù)據(jù) String x = (String)p.getX(); String y = (String)p.getY(); System.out.println("x = " + x + ",y = " + y); }} |
看起來所有功能都實(shí)現(xiàn)了，并根據(jù)之前所學(xué)的內(nèi)容，也只能做到這些了，但是本程序還有一系列問題。
本程序解決問題的關(guān)鍵就在Object類，所有的類型都可以想Obejct轉(zhuǎn)換，但是成也是它敗也是它。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class PointDemo { public static void main(String[] args) { Point point = new Point(); //設(shè)置參數(shù) point.setX(10); point.setY("北緯"); //取出參數(shù) String x = (String) point.getX(); String y = (String) point.getY(); System.out.println("x的坐標(biāo)是："+x+"y的坐標(biāo)是："+y); }} |
這個(gè)時(shí)候程序并沒有任何的語法錯(cuò)誤，因?yàn)閿?shù)字10 被包裝成了Integer，可以使用Obejct接收，從技術(shù)上而言，本操作沒有問題，但是從實(shí)際來講，因?yàn)闆]有統(tǒng)一，多以在取得數(shù)據(jù)并且執(zhí)行向下轉(zhuǎn)型的過程中就會(huì)出現(xiàn)如下的錯(cuò)誤提示信息：
|
1
2
|
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at cn.mldn.demo.TestDemo.main(PointDemo.java:30) |
所以，就可以得出一個(gè)結(jié)論，以上的程序存在安全隱患，但是并沒有在程序的編譯過程中檢查出來，而現(xiàn)在就可以利用泛型來解決這種問題。
3.2 泛型實(shí)現(xiàn)
泛型：類之中操作的屬性或方法的參數(shù)類型不在定義的時(shí)候聲明，而是在使用的時(shí)候動(dòng)態(tài)設(shè)置。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package com.demo;//在定義Point不知道是什么類型，由使用者來進(jìn)行定義使用class Point<T> {//T表示參數(shù)，一個(gè)占位標(biāo)記 private T x; private T y; public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() { return y; } public void setY(T y) { this.y = y; }}public class PointDemo { public static void main(String[] args) { //第一步：設(shè)置數(shù)據(jù) Point<String> p = new Point<String>(); p.setX("東經(jīng)10"); p.setY("西經(jīng)20"); //第二步：取出數(shù)據(jù) String x = p.getX();//避免了向下轉(zhuǎn)型 String y = p.getY(); System.out.println("x = " + x + ",y = " + y); }} |
測(cè)試沒有了向下轉(zhuǎn)型的操作關(guān)系，那么程序就避免了安全性的問題，而且如果設(shè)置的類型不統(tǒng)一，在程序編譯的過程之中也是可以很好的解決了，直接會(huì)報(bào)出語法錯(cuò)誤。
而且當(dāng)用戶在使用Point類聲明對(duì)象的時(shí)候沒有設(shè)置泛型，程序在編譯的過程之中，會(huì)提示警告信息，而且為了保證程序不出現(xiàn)錯(cuò)誤，所有的類型都將使用Obejct進(jìn)行處理。使用泛型可以很好的解決數(shù)據(jù)類型的統(tǒng)一問題。
但是在此處需要提醒的是，JDK1.5和JDK1.7在定義泛型的時(shí)候是稍微有些區(qū)別的。
JDK1.5的時(shí)候聲明泛型的操作
|
1
|
Point<String> p= new Point<String>(); |
以上是JDK1.5的語法，在聲明對(duì)象和實(shí)例化對(duì)象的時(shí)候都必須設(shè)置好泛型類型。
JDK1.7的時(shí)候簡(jiǎn)化了
|
1
|
Point<String> p= new Point< >(); |
? 這個(gè)時(shí)候?qū)嵗瘜?duì)象時(shí)泛型的泛型類型就通過聲明時(shí)泛型類型來定義了。
3.3 通配符
泛型的而出現(xiàn)的確是可以解決了數(shù)據(jù)的統(tǒng)一問題以及避免了向下轉(zhuǎn)型操作，但同事也會(huì)帶來新的問題，下面通過一段程序，來觀察一下會(huì)產(chǎn)生什么問題？
為了簡(jiǎn)化定義一個(gè)簡(jiǎn)單的泛型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package com.demo;class Message<T>{ private T info; public T getInfo() { return info; } public void setInfo(T info) { this.info = info; }} |
以上的類對(duì)象進(jìn)行引用傳遞
|
1
2
3
4
5
6
7
8
9
10
|
public class MessageDemo { public static void main(String[] args) { Message<String> msg = new Message<>(); msg.setInfo("hello,world!"); print(msg);//以上的類對(duì)象進(jìn)行引用傳遞 } public static void print(Message<String> s){ System.out.println(s.getInfo()); }} |
但是如果現(xiàn)在定義的泛型類型不是String呢？例如：換成了int（不能是基本數(shù)據(jù)類型，只能是包裝類）
|
1
2
3
4
5
6
7
8
9
10
|
public class MessageDemo { public static void main(String[] args) { Message<Integer> msg = new Message<>(); msg.setInfo(100); print(msg);//無法進(jìn)行引用傳遞 } public static void print(Message<String> s){ System.out.println(s.getInfo()); }} |
發(fā)現(xiàn)這個(gè)時(shí)候的print()方法無法再接收Message對(duì)象的引用，因?yàn)檫@個(gè)方法只能夠接收Message對(duì)象的引用，那么可以將print()方法重載換成Message
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class MessageDemo { public static void main(String[] args) { // TODO 自動(dòng)生成的方法存根 Message<Integer> msg = new Message<>(); msg.setInfo(100); print(msg); } public static void print(Message<String> msg){ System.out.println(msg.getInfo()); } public static void print(Message<Integer> msg){ System.out.println(msg.getInfo()); }} |
這個(gè)時(shí)候發(fā)現(xiàn)按照之前的方式根本就無法進(jìn)行方法的重載，方法的重載沒有說為一個(gè)類而定義的，因?yàn)榉椒ㄖ剌d的時(shí)候觀察的不是泛型類型，而是類的名稱，或者說是數(shù)據(jù)類型的，所以現(xiàn)在就可以發(fā)現(xiàn)，這個(gè)給出了泛型類之后，就相當(dāng)于將一個(gè)類又劃分成了幾個(gè)小類。
那么現(xiàn)在的問題：方法接收的參數(shù)問題又嚴(yán)重了，而且比之前使用對(duì)象多態(tài)性解決問題時(shí)出現(xiàn)的麻煩更大了，至少那個(gè)時(shí)候可以利用重載來接收一個(gè)類的所有子類對(duì)象，而現(xiàn)在連重載都使用不了。
? 這個(gè)時(shí)候，有人提出了，干脆在定義方法的時(shí)候就別寫泛型類型了。
定義方法的時(shí)候不定義泛型類型
|
1
2
3
4
5
6
7
8
9
10
11
|
public class MessageDemo { public static void main(String[] args) { // TODO 自動(dòng)生成的方法存根 Message<Integer> msg = new Message<>(); msg.setInfo(100); print(msg); } public static void print(Message msg){ System.out.println(msg.getInfo()); }} |
雖然現(xiàn)在print()方法的參數(shù)上出現(xiàn)了警告，但是現(xiàn)在的程序可算是正常了，但是新的問題又來了。問題就在于方法操作中，沒有類型限制了。
|
1
2
3
4
|
public static void print(Message msg){ msg.setInfo(100); System.out.println(msg.getInfo());} |
發(fā)現(xiàn)此時(shí)在print()方法之中操作的時(shí)候，由于沒有設(shè)置泛型類型，那么所有類型都統(tǒng)一變?yōu)榱薕bject，也就可以修改了。而通過本程序也就發(fā)現(xiàn)了，必須找到一種方法，：此方法可以接收任意的泛型類型的設(shè)置，并且不能修改，只能輸出，為了解決這樣的問題，可以使用通配符“？”表示。
|
1
2
3
|
public static void print(Message<?> msg){ System.out.println(msg.getInfo());} |
由于“？”出現(xiàn)的情況較多，尤其在學(xué)習(xí)一些類庫(kù)的時(shí)候，所以對(duì)于“？”就記住一點(diǎn)，表示任意類型，如果有參數(shù)返回的時(shí)候也是這個(gè)“？”，當(dāng)成Object進(jìn)行理解。
既然現(xiàn)在談到了Obejct，那么現(xiàn)在實(shí)際上又有了另外一個(gè)問題：對(duì)于所有的子類，都是Object子類，那么如果對(duì)于之前的程序都使用Object能不能接收？
|
1
2
|
Message<String> msg = new Message<>();Message<Object> s = msg; |
因?yàn)镺bject的范圍比String的范圍大。
而在通配符“？”上有衍生出了兩個(gè)子符號(hào)：
設(shè)置泛型的上限：？extends 類；
? 例如：？extends Number，表示只能是Number或者是Number的子類Integer等；
? 2.設(shè)置泛型的下限：？super類；
? 例如：？super String，表示只能是String或者是String的父類（Object）
設(shè)置泛型上限
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package com.demo;class Message<T extends Number>{ private T info; public T getInfo() { return info; } public void setInfo(T info) { this.info = info; }}public class MessageDemo { public static void main(String[] args) { Message<Integer> msg = new Message<>(); msg.setInfo(100); //100 print(msg); } public static void print(Message<? extends Number> s){ System.out.println(s.getInfo()); }} |
設(shè)置泛型下限
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package com.demo;class Message<T>{ private T info; public T getInfo() { return info; } public void setInfo(T info) { this.info = info; }}public class MessageDemo { public static void main(String[] args) { Message<String> msg = new Message<>(); msg.setInfo("Hello,world!100"); //Hello,world!100 print(msg); } //此時(shí)使用通配符“?”描述的是它可以接收任何任意數(shù)據(jù)類型，但是由于不確定類型，無法修改 public static void print(Message<? super String> s){ System.out.println(s.getInfo()); }} |
3.4 泛型接口
在之前的所有定義的泛型之中，都是在類上定義的，而對(duì)于接口也是可以進(jìn)行泛型定義的，而使用泛型定義的接口可以稱為泛型接口。
|
1
2
3
|
interface Message<T>{ public String echo(T msg);} |
而對(duì)于泛型接口的實(shí)現(xiàn)，在Java中有兩種方式：
方式一：在子類上繼續(xù)定義泛型，同時(shí)此泛型繼續(xù)在接口上使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package com.test;interface IMessage<T>{ public void print(T t);}class MessageImpl<T> implements IMessage<T>{ @Override public void print(T t) { // TODO Auto-generated method stub System.out.println(t); } }public class MessageTest { public static void main(String[] args) { IMessage<String> msgimpl = new MessageImpl(); msgimpl.print("Hello,world!!"); }} |
方式二：在子類上設(shè)置具體類型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package com.test;interface IMessage<T>{ public void print(T t);}class MessageImpl implements IMessage<String>{ @Override public void print(String t) { // TODO Auto-generated method stub System.out.println(t); } }public class MessageTest { public static void main(String[] args) { IMessage<String> msgimpl = new MessageImpl(); msgimpl.print("Hello,world!!"); }} |
3.5 泛型方法
對(duì)于泛型除了可以在類上定義，也可以在方法上定義，而在方法上進(jìn)行泛型的時(shí)候這個(gè)方法不一定非在泛型類中定義。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class TestDemo { public static void main(String[] args) { // TODO 自動(dòng)生成的方法存根 Integer result[] = get(1,2,3); for(int temp : result){ System.out.println(temp); } } public static <T> T[] get(T... date){ return date; }} |
4、JDK三大主要特性——枚舉
在講解枚舉之前回顧一個(gè)概念：多例設(shè)計(jì)模式，構(gòu)造方法私有化（非public），之后在類的內(nèi)部存在若干個(gè)指定的對(duì)象，通過一個(gè)方法返回指定對(duì)象。
4.1 多例與枚舉
定義一個(gè)描述顏色基色的多例設(shè)計(jì)類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
package com.demo;class Color { private static final Color RED = new Color("紅色"); private static final Color GREEN = new Color("綠色"); private static final Color BLUE = new Color("藍(lán)色"); private String title; private Color(String title){ this.title=title; } public String toString(){ return this.title; } public static Color getColor(int num){ switch(num){ case 0: return RED; case 1: return GREEN; case 2: return BLUE; default: return null; } }}public class ColorDemo { public static void main(String[] args) { Color c = Color.getColor(0); System.out.println(c); }} |
基于枚舉開發(fā)
|
1
2
3
4
5
6
7
8
9
|
package com.demo;enum Color { RED,BULE,PINK;}public class ColorDemo { public static void main(String[] args) { System.out.println(Color.RED); }} |
4.2 Enum類
很明顯，現(xiàn)在可以發(fā)現(xiàn)，利用枚舉實(shí)現(xiàn)多例設(shè)計(jì)會(huì)更加的簡(jiǎn)單直白一些，但是在Java之中，枚舉并不是一個(gè)新的類型，嚴(yán)格來講，每一個(gè)使用enum定義的類實(shí)際上都屬于一個(gè)類繼承了Enum父類而已，而java.lang.Enum類定義如下：
|
1
2
3
|
public abstract class Enum<E extends Enum<E>>extends Objectimplements Comparable<E>, Serializable |
而在Enum類種子紅定義了兩個(gè)方法：
取得枚舉的序號(hào)：public final int ordinal()；
取得枚舉的名稱：public final String name()。
|
1
2
3
4
5
6
7
8
9
10
|
package com.demo;enum Color { RED,BULE,PINK;}public class ColorDemo { public static void main(String[] args) { //0===RED System.out.println(Color.RED.ordinal() + "===" + Color.RED.name()); }} |
取得所有顏色數(shù)據(jù)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package com.demo;enum Color { RED,BULE,PINK;}public class ColorDemo { public static void main(String[] args) { /*0===RED 1===BULE 2===PINK*/ for (Color c : Color.values()) { System.out.println(c.ordinal() + "===" + c.name()); } }} |
面試題：請(qǐng)解釋enum和Enum的區(qū)別？
enum是一個(gè)關(guān)鍵字，使用enum定義的枚舉類本質(zhì)上相當(dāng)于一個(gè)類繼承了Enum類而已。
4.3 枚舉中定義其它結(jié)構(gòu)
按照之前所理解，枚舉就屬于多例設(shè)計(jì)模式，那么既然是多例設(shè)計(jì)模式，對(duì)于類之中就肯定有多種組成，包括屬性，方法，構(gòu)造方法，在枚舉之中也同樣可以定義以上的內(nèi)容，不過需要注意的是，枚舉類之中定義的構(gòu)造方法絕對(duì)不能是public，必須私有化。
除了這些要求之外枚舉之中每一個(gè)定義的對(duì)象必須定義在第一行。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package com.demo;enum Color { RED("紅色"),BULE("藍(lán)色"),PINK("粉色"); private String c; private Color(String c){ this.c = c; } public String toString(){ return this.c; }}public class ColorDemo { public static void main(String[] args) { /*紅色*/ System.out.println(Color.RED); }} |
枚舉接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package com.demo;interface IColor{ public String getColor();}enum Color implements IColor{ RED("紅色"),BULE("藍(lán)色"),PINK("粉色"); private String c; private Color(String c){ this.c = c; } public String toString(){ return this.c; } @Override public String getColor() { // TODO Auto-generated method stub return this.c; }}public class ColorDemo { public static void main(String[] args) { /*紅色*/ System.out.println(Color.RED); }} |
4.4 枚舉應(yīng)用
只有指定的幾個(gè)對(duì)象
性別
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
package com.demo;class Person{ private String name; private int age; private Sex sex; public Person(String name, int age, Sex sex) { super(); this.name = name; this.age = age; this.sex = sex; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]"; }}enum Sex{ MALE("男"),FEMALE("女"); private String sex; private Sex(String sex) { this.sex = sex; } public String toString(){ return this.sex; }}public class MaleDemo { public static void main(String[] args) { Person person = new Person("jack", 10, Sex.MALE); System.out.println(person.toString()); }} |
枚舉還可以進(jìn)行switch語句進(jìn)行編寫和判斷。
5、JDK三大主要特性——Annotation
在JDK1.5之后，程序允許通過注解（Annotation）的方式來進(jìn)行程序的定義，而在JavaSE之中攢在了三種Annotation：@Override、@Deprecated、@SuppressWarnings。
5.1 準(zhǔn)確的覆寫：@Override
方法的覆寫：發(fā)生繼承關(guān)系之中，子類定義了與父類的方法名稱相同、參數(shù)類型以及個(gè)數(shù)相同的覆寫，被覆寫的方法不能夠擁有比父類更為嚴(yán)格的訪問控制權(quán)限。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package com.annotation;class Person{ //現(xiàn)在是希望進(jìn)行toString()覆寫，但遺憾的由于你自己的輸入錯(cuò)誤，導(dǎo)致方法的覆寫錯(cuò)誤 //@Override public String tostring(){//現(xiàn)在希望可以進(jìn)行toString()方法的覆寫 return "一個(gè)人"; }}public class Demo1 { public static void main(String[] args) { System.out.println(new Person().tostring()); }} |
這個(gè)時(shí)候不叫覆寫，屬于自己定義一個(gè)擴(kuò)展的方法，最為重要的是，這個(gè)問題在程序編譯的根本就無法顯示出來。但是現(xiàn)在為了保證我們的覆寫方法的嚴(yán)格，可以使用一個(gè)注解（@Override）來檢測(cè)：如果該方法確定成的覆寫了
，則不會(huì)有我們的語法錯(cuò)誤，如果進(jìn)行成功的覆寫，認(rèn)為語法的錯(cuò)誤。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package com.annotation;class Person{ //現(xiàn)在是希望進(jìn)行toString()覆寫，但遺憾的由于你自己的輸入錯(cuò)誤，導(dǎo)致方法的覆寫錯(cuò)誤 public String toString(){//現(xiàn)在希望可以進(jìn)行toString()方法的覆寫 return "一個(gè)人"; }}public class Demo1 { public static void main(String[] args) { System.out.println(new Person()); }} |
5.2 聲明過期操作：@Deprecated
對(duì)于程序開發(fā)而言，往往一些使用的類要進(jìn)行修改或者是維護(hù)，如果說現(xiàn)在一個(gè)類之中的某個(gè)方法，可能一開始推出的時(shí)候正常使用，但是在后面的版本就存在了一些問題，在修改之后不希望人再去使用這些方法，那么肯定不能直接刪除，因?yàn)槿绻苯觿h除了，那么之前的程序就會(huì)出現(xiàn)問題了，所以最好的做法是告訴用戶：這個(gè)方法存在了問題，不建議再使用了，這個(gè)時(shí)候就使用“@Deprecated”聲明。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package com.annotation;class Person1{ @Deprecated//表示該方法不建議使用，即使使用仍然不會(huì)報(bào)錯(cuò) public Person1(){} public Person1(String name){} @Deprecated public void print(){}}public class Demo2 { public static void main(String[] args) { Person1 person = new Person1();//明確標(biāo)記過期 person.print(); }} |
5.3 壓制警告：@SuppressWarning
程序在編譯的時(shí)候如果提示警告但是不會(huì)報(bào)錯(cuò)只是存在了某些安全隱患，肯定會(huì)提示用戶，所以不想讓其顯示的話，就增加壓制警告信息。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package com.annotation;class Person1<T>{ @Deprecated//表示該方法不建議使用，即使使用仍然不會(huì)報(bào)錯(cuò) public Person1(){} public Person1(String name){} @Deprecated public void print(){}}public class Demo2 { @SuppressWarnings("rawtypes") public static void main(String[] args) { Person1 person = new Person1();//明確標(biāo)記過期 person.print(); }} |
關(guān)于軟件的開發(fā)模式；
? 第一階段：會(huì)將所有的操作都寫在程序之中，例如：網(wǎng)絡(luò)程序，連接程序，連接的服務(wù)器地址，用戶驗(yàn)證等；
? 第二階段：程序+配置文件，配置文件和程序相分離，配置文件過多，后期修改非常復(fù)雜；
? 第三階段：將配置文件寫回到程序之中，但是和程序進(jìn)行有效的分離。
6、接口定義加強(qiáng)
造成此種尷尬的局面的核心問題在于，接口只是一個(gè)方法的聲明，而沒有具體方法的實(shí)現(xiàn)，所以隨著時(shí)間的推移，如果出現(xiàn)以上的問題，該接口將無法繼續(xù)使用。從JDK1.8為了解決這個(gè)問題，專門提供兩種專門的接口。
可以使用default來定義普通方法，需要通過對(duì)象調(diào)用。可以使用static來定義靜態(tài)方法，通過接口名就能使用。
定義普通方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package com.annotation;interface IMess{ public default void fun(){//追加普通方法，又方法體了 System.out.println("hello,world!"); } public void print();}class MessImpl implements IMess{ @Override public void print() { // TODO Auto-generated method stub System.out.println("www.baidu.com"); } }public class Demo3 { public static void main(String[] args) { MessImpl msg = new MessImpl(); msg.print(); msg.fun(); }} |
定義static方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
package com.annotation;interface IMess{ public default void fun(){//追加普通方法，又方法體了 System.out.println("hello,world!"); } public static IMess getInstance(){//定義靜態(tài)方法 return new MessImpl(); } public void print();}class MessImpl implements IMess{ @Override public void print() { // TODO Auto-generated method stub System.out.println("www.baidu.com"); } }public class Demo3 { public static void main(String[] args) {// MessImpl msg = new MessImpl(); IMess msg = IMess.getInstance(); msg.print(); msg.fun(); }} |
整體來說，接口更像抽象類，但是比抽象類強(qiáng)大在于，接口的子類依然可以實(shí)現(xiàn)多繼承的關(guān)系，而抽象類繼續(xù)保持單繼承。
7、Lambda表達(dá)式
最具有代表性的就是haskell.函數(shù)式編程和面向?qū)ο缶幊虨閮纱箝_發(fā)陣營(yíng)
傳統(tǒng)的面向?qū)ο箝_發(fā)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package com.annotation;interface IMess{ public void print();}public class Demo3 { public static void main(String[] args) { IMess msg = new IMess(){ public void print(){ System.out.println("Hello,world!"); }; }; msg.print(); }} |
使用匿名內(nèi)部類來實(shí)現(xiàn)接口最大好處就是節(jié)約了一個(gè)文件，最大的缺點(diǎn)就是看的眼花繚亂，對(duì)于此操作有了更簡(jiǎn)化的體現(xiàn)。如果采用函數(shù)式編程模型。
函數(shù)式編程模型
|
1
2
3
4
5
6
7
8
9
10
|
package com.annotation;interface IMess{ public void print();}public class Demo3 { public static void main(String[] args) { IMess msg = ()->System.out.println("Hello,world!"); msg.print(); }} |
如果想要使用函數(shù)式編程前提，接口只能寫一個(gè)方法，如果編寫兩個(gè)方法，則會(huì)出現(xiàn)語法錯(cuò)誤。可以在接口的開頭加上@FunctionalInterface聲明這是一個(gè)函數(shù)接口。
實(shí)際上對(duì)于以上的語法形式：
(參數(shù) )->單行語句；
這個(gè)時(shí)候方法本身只包含一行語句，那么直接編寫語句即可，如果要是有多行語句，則就需要我們使用"{}"
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package com.annotation;@FunctionalInterfaceinterface IMess{ public void print();}public class Demo3 { public static void main(String[] args) { IMess msg = ()->{ System.out.println("Hello,world!"); System.out.println("Hello,world!"); System.out.println("Hello,world!"); }; msg.print(); }} |
如果現(xiàn)在你的表達(dá)式里面的內(nèi)容只是一行進(jìn)行數(shù)據(jù)的返回，那么直接使用語句即可，不用寫return。
|
1
2
3
4
5
6
7
8
9
10
|
package com.annotation;interface IMath{ public int add(int x, int y);}public class Demo4 { public static void main(String[] args) { IMath msg = (p1, p2)-> p1 + p2; System.out.println(msg.add(10, 20)); }} |
到此這篇關(guān)于Day11基礎(chǔ)不牢地動(dòng)山搖-Java基礎(chǔ)的文章就介紹到這了,更多相關(guān)Java基礎(chǔ)內(nèi)容請(qǐng)搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！
原文鏈接：https://blog.csdn.net/zsr6135/article/details/119721881
