Java泛型枚舉Annotation接口詳細解讀與Eclipse發(fā)展
1、Eclipse開發(fā)工具
1.1 Eclipse歷史
Eclipse中文翻譯為日蝕，指的是吞沒一切的光芒，那么這個及其具備挑釁一位的名字實際上是針對于SU年公司。在2000年之后一直處于互聯(lián)網(wǎng)低潮，而SUN公司從這一低潮之后就再也沒有起來過，而后SUN公司最為尷尬的是，他在硬件上沒有過多的收益，而且軟件的編程語言Java也不是SUN的賺錢工具，它只是變成了一個出賣版權的公司了。
對于Java的IDE（集成開發(fā)環(huán)境）本身也是經過了一些歷史的調整。
1995年的時候，Java誕生，但是SUN公司卻高調宣布，我們自己不生成IDE，給其他第三方公司生產；
在Java產生之后，Borland公司來時入手Java的IDE生產，所以后來的JBuilder就成為了Java開發(fā)的唯一選擇（不選擇JBuilder都使用記事本，IDEA,JCREATOR,EDIPLUS….），后倆一直到了JBuilderX之后才正常；
2003年之后有了Eclipse，在2004年之后有了SUN自己的開發(fā)工具———NetBeans
而從整個國內的Java開發(fā)模式上也一直在發(fā)生著改變；
豪華級架構：操作系統(tǒng)+數(shù)據(jù)庫+中間件+開發(fā)工具+編程語言；
IBM體系：AIX+IBM DB2+WwbsphereApplicationServer+WSAD；
超級雜牌軍體系：UNIX+Oracle+Weblogic+JBuilder；
免費架構：Linux+MySQL+Tomcat/JBoss+Eclipse；
而對于開發(fā)工具最早的霸主就是JBuilder，但是遺憾的是，2006年的時候Borland倒閉了，倒閉的原因是因為沒有干聲多為的開源風潮，因為有許多的學習者，它可能并不需要如此專業(yè)的工具，所以當時Borland公司的市場就出現(xiàn)了問題，于是倒閉就成為了必然，最后Borland技術部單獨成立了一家技術公司，繼續(xù)從事JBuilder的研究，但是今天的JBuilder已經基本上無法去問津了，完全被Eclipse取代了。
Eclipse是由IBM開發(fā)的，之后將其轉送給了今天的Eclipse組織，進行開源項目的推廣，而Eclipse的前身是IBM VisualAge，而后IBM根據(jù)Eclipse的1.0模型，產生后來的WSAD來發(fā)工具。Eclipse本身是免費的，但是其是靠插件收費（中國連插件都不需要收費），其本身有一下幾個基本組成：JDT,JUNIT測試工具,CVS客戶端，插件開發(fā)，用戶可以直接登陸www.eclipse.org下載Eclipse的最新版本，JUNO（朱諾，小行星的名字）版，而且Eclipse現(xiàn)在可以直接解壓縮后使用，不用單獨的安裝，是純粹的綠色版。
當我們Java項目簡歷完成值周，可以在項目的目錄小發(fā)現(xiàn)兩個文件夾：
Src:是保存所有的*.java程序，都是按照包名稱進行保存的；
Bin：保存所有生成的*.class文件，按照包名稱進行保存的。
下面簡歷一個新的類：TestDemo.java
使用Eclipse本身最大的好處在于方便的進行隨筆提示，并且在每一次*.java程序保存的時候，會由Eclipse自動的將其編譯為*.class文件。
另外在Eclipse之中還可以存在一些代碼生成工具，例如：現(xiàn)在有如下簡單類
package com.sxau;
public class Person {
private String name;
private int age;
}
這個類肯定是作為簡單Java類出現(xiàn)，那么現(xiàn)在很明顯簡單Java類的開發(fā)原則：
所有屬性封裝，已經封裝；生成setter，getter方法；構造方法，必須要有無參構造覆寫Object中的一些方法
1.2 快捷鍵
除了以上的生成方式還可以通過快捷鍵生成
ALT+/：代碼自動補充提示；CTRL+1：進行錯誤代碼矯正提示；CTRL+D：刪除當前行代碼；CTRL+SHIFT+O：自動導入包；CTRL+SHIFT+F：格式化代碼顯示；CTRL+/：注釋/取消注釋；CTRL+shift+l：快捷鍵列表CTRL+H：搜索
項目也可以進行刪除操作，但是在刪除項目的時候有兩種方式：
方式一：是從項目的工作區(qū)之中刪除，以后可以恢復；
方式二：徹底從硬盤上刪除項目。
如果想導入項目則可以使用導入的方式。
以上是利用導入的方式完成了項目的導入，而現(xiàn)在也可以通過導出的方式，將一個項目之中的所有*.class文件自動生成*.jar文件。
1.3 Debug調試
在Eclipse之中，為了方便永華的開發(fā)，還提供了DEBUG功能，可以利用此功能進行項目的調試操作，而如果要想進行調試，首先需要設置斷點。斷點指的是程序執(zhí)行到此處的時候，自動停止，而后交給人工控制執(zhí)行。
**范例：**設置斷點
package com.util;
public class MyMath {
private MyMath(){}
public static int add(int x, int y){
int temp = 0;
temp = x + y;
return temp;
}
}
測試類
package com.test;
import com.util.MyMath;
public class TestMath {
public static void main(String[] args) {
int result = MyMath.add(2, 3);//將此處設置為斷電
System.out.println("加法結果" + result);
}
}
進入調試試圖之后可以通過以下方式進行代碼調試：
- 單步跳入（F5）：進入到代碼之中觀察代碼的執(zhí)行；
- 單步跳過（F6）：不關心代碼之中的執(zhí)行，只關心最終的結果；
- 單步返回（F7）：返回到單步跳過的狀態(tài)
- 恢復執(zhí)行（F8）：不再調試直接將程序運行完成。
1.4 JUNIT測試工具
軟件測試行業(yè)：2003年——2006年之后，各個公司一直都在招聘軟件測試人員，而且都是外包到IBM或微軟的公司進行測試。但是，今天的軟件測試來講，這個行業(yè)已經很難了。
軟件測試是一個黃金職位，對于軟件測試是需要有一套完整測試理論和數(shù)據(jù)設計的，而如果學習過軟件工程應該知道軟件測試分為兩類：
1 黑盒測試：主要是測試功能，例如一些xx版，是不接觸代碼的，但是公司會提供工具；
2 白盒測試：指的是性能測試，或者是算法調整。
而這幾年隨著行業(yè)的發(fā)展，實際上又給出了一種新的測試職位——Use Case(用測)測試工程師，對于這種職位而言，國內的平均待遇是程序員的3-5倍，如果按照正常的一個程序員的工資是8000來算，那么這種人的平均工資就是2-5萬，但是人很難難找，一般而言此類人員在行業(yè)中需要8-10年的項目經驗，并且精通業(yè)務。
JUNIT是一個比較常用的測試工具，準們可以進行Use Case測試的，在日后所開發(fā)的程序里都要寫大量的JUNIT測試程序。
**范例：**定義要測試的程序
package com.util;
public class MyMath {
private MyMath(){}
public static int add(int x, int y){
int temp = 0;
temp = x + y;
return temp;
}
}
測試類
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測試的時候有兩種形式：
1.JUNIT Test Case：表示一個測試用例，主要完成一個業(yè)務的測試；
2.JUNIT Test Case：表示一組測試用例，包含多個Test Case。
對于JUNIT的測試結果來說，一共分為兩種：
1.GREEM BAR：測試通過；
2.RED BAR：測試失敗。
2、Java基礎新特性
Java的發(fā)展從1995年開始經歷了許多的過程，但是有三個最具有代表性的JDK版本；
JDK1.0：標志著java的誕生；
JDK1.2：加入了javax.swing組件，這是主要新特性；
JDK1.5：標記為tiger，出現(xiàn)了許多一直沿用至今的特性；
JDK1.8：Lambda表達式、接口的定義加強
已經接觸過了一些新特性，例如：自動裝箱與拆箱、switch對String的判斷支持。
2.1 可變參數(shù)
在講解可變參數(shù)之前，首先思考一個問題：如果說現(xiàn)在要實現(xiàn)若干個整型變量的相加操作，問，此方法該如何設計？使用數(shù)組接收，因為參數(shù)個數(shù)不確定，按照之前所學，只能使用數(shù)組完成。
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}));
}
/**
* 實現(xiàn)任意個數(shù)的數(shù)據(jù)相加操作處理
* @param data相加操作數(shù)據(jù)
* @return 返回多個數(shù)據(jù)的相加結果
*/
public static int add(int [] data){
int sum = 0;
for (int i = 0; i < data.length; i++) {
sum += data[i];
}
return sum;
}
}
以上的確是實現(xiàn)了技術要求，但是現(xiàn)在有一個新的問題產生了：如果按照題目要求，應該是可以任意的傳遞多個數(shù)據(jù)，但是以上實際上傳的是一個數(shù)據(jù)，只不過一個數(shù)據(jù)使用數(shù)組的形式封裝。那么為了更好的解決這個問題，可以使用JDK1.5的可變參數(shù)的方式來解決此問題
Public [static] [final] 返回值類型 方法名稱（參數(shù)類型…變量）{ //雖然方式改變了
[return [返回值];]
}
發(fā)現(xiàn)現(xiàn)在進行方法參數(shù)的定義的時候有了一些變化，而這個時候的參數(shù)可以說是數(shù)組形式。
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));
}
/**
* 實現(xiàn)任意個數(shù)的數(shù)據(jù)相加操作處理
* @param data相加操作數(shù)據(jù)
* @return 返回多個數(shù)據(jù)的相加結果
*/
public static int add(int ... data){
int sum = 0;
for (int i = 0; i < data.length; i++) {
sum += data[i];
}
return sum;
}
}
有了可變參數(shù)在日后進行方法調用的過程之中，就可以比較直觀的傳遞任意多個參數(shù)，但是異常的操作在開發(fā)之中不建議使用，最好別用。
2.2 foreach輸出
首先需要解釋的是：foreach并不是新的概念，最早是在NET中提出來的，多為foreach可以理解為增強型的for循環(huán)，下面來回顧一下最早的for循環(huán)：
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));
}
/**
* 實現(xiàn)任意個數(shù)的數(shù)據(jù)相加操作處理
* @param data相加操作數(shù)據(jù)
* @return 返回多個數(shù)據(jù)的相加結果
*/
public static int add(int ... data){//接收原始數(shù)組
int sum = 0;
for (int i : data) { //將數(shù)組中的每一個元素設置給x
sum += i;//這種循環(huán)避免了腳標的問題
}
return sum;
}
}
但是有了foreach之后，那么對于數(shù)組或者是集合的輸出就有了新的支持，語法如下：
for(數(shù)據(jù)類型 變量 ：數(shù)組|集合){
//操作代碼
}
對于這種for循環(huán)避免了數(shù)組越界的問題，但依然只是要求會使用，能看懂就行，不過個人建議：最好別用。
2.3 靜態(tài)導入
如果說想在想要導入一個不同包的類的方法，那么肯定使用import完成，即：如下是之前所采用的格式。
定義一個MyMath類
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值周，如果一個雷之中的全部方法都是static型的，則可以使用如下的語法進行導入：
import static 包.類.*；
表示的是將這個指定類之中的全部方法導入進來，最后就好像這些方法全部都是在主類之中定義的一樣。
package com.test;
import static com.util.MyMath.*;//靜態(tài)導入
public class TestMath {
public static void main(String[] args) {
System.out.println(add(10,20));
System.out.println(sub(30,10));
}
}
這種比較難受的方法，也只是出現(xiàn)在講課之中，本人是絕對不會使用的，你們也可以忘記它。
3、 JDK三大主要特性——泛型
泛型可以幫助我們解決參數(shù)轉換的問題
3.1 泛型的引出
下面首先通過一個簡單分析來研究一下泛型出現(xiàn)的主要目的是什么？例如現(xiàn)在要求定義一個表示坐標的操作類（Point）這個類可以表示三種類型的坐標：
整數(shù)坐標：x=10、y=20；
小數(shù)坐標：x=10.1、y=20.3；
字符串數(shù)據(jù)：x=“東經10度”、y=“西經20度”。
類之中如果想要表示以上的數(shù)據(jù)，一定需要定義x和y兩個屬性，而且每一個屬性可以接收三種數(shù)據(jù)類型，那么只能使用Object類來定義會比較合適，這樣會發(fā)生如下的幾種轉換關系：
整數(shù)：int→自動裝箱為Integer→向上轉型為Object；
小數(shù)：double→自動裝箱為Double→向上轉型為Obejct;
字符串：字符串→向上轉型為Obejct；
設置整形
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ù)據(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ù)
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ù)據(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);
}
}
設置字符串
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ù)據(jù)
Point p = new Point();
p.setX("東經10");
p.setY("西經20");
//第二步：取出數(shù)據(jù)
String x = (String)p.getX();
String y = (String)p.getY();
System.out.println("x = " + x + ",y = " + y);
}
}
看起來所有功能都實現(xiàn)了，并根據(jù)之前所學的內容，也只能做到這些了，但是本程序還有一系列問題。
本程序解決問題的關鍵就在Object類，所有的類型都可以想Obejct轉換，但是成也是它敗也是它。
public class PointDemo {
public static void main(String[] args) {
Point point = new Point();
//設置參數(shù)
point.setX(10);
point.setY("北緯");
//取出參數(shù)
String x = (String) point.getX();
String y = (String) point.getY();
System.out.println("x的坐標是："+x+"y的坐標是："+y);
}
}
這個時候程序并沒有任何的語法錯誤，因為數(shù)字10 被包裝成了Integer，可以使用Obejct接收，從技術上而言，本操作沒有問題，但是從實際來講，因為沒有統(tǒng)一，多以在取得數(shù)據(jù)并且執(zhí)行向下轉型的過程中就會出現(xiàn)如下的錯誤提示信息：
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)
所以，就可以得出一個結論，以上的程序存在安全隱患，但是并沒有在程序的編譯過程中檢查出來，而現(xiàn)在就可以利用泛型來解決這種問題。
3.2 泛型實現(xiàn)
泛型：類之中操作的屬性或方法的參數(shù)類型不在定義的時候聲明，而是在使用的時候動態(tài)設置。
package com.demo;
//在定義Point不知道是什么類型，由使用者來進行定義使用
class Point<T> {//T表示參數(shù)，一個占位標記
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ù)據(jù)
Point<String> p = new Point<String>();
p.setX("東經10");
p.setY("西經20");
//第二步：取出數(shù)據(jù)
String x = p.getX();//避免了向下轉型
String y = p.getY();
System.out.println("x = " + x + ",y = " + y);
}
}
測試沒有了向下轉型的操作關系，那么程序就避免了安全性的問題，而且如果設置的類型不統(tǒng)一，在程序編譯的過程之中也是可以很好的解決了，直接會報出語法錯誤。
而且當用戶在使用Point類聲明對象的時候沒有設置泛型，程序在編譯的過程之中，會提示警告信息，而且為了保證程序不出現(xiàn)錯誤，所有的類型都將使用Obejct進行處理。使用泛型可以很好的解決數(shù)據(jù)類型的統(tǒng)一問題。
但是在此處需要提醒的是，JDK1.5和JDK1.7在定義泛型的時候是稍微有些區(qū)別的。
JDK1.5的時候聲明泛型的操作
Point<String> p= new Point<String>();
以上是JDK1.5的語法，在聲明對象和實例化對象的時候都必須設置好泛型類型。
JDK1.7的時候簡化了
Point<String> p= new Point< >();
這個時候實例化對象時泛型的泛型類型就通過聲明時泛型類型來定義了。
3.3 通配符
泛型的而出現(xiàn)的確是可以解決了數(shù)據(jù)的統(tǒng)一問題以及避免了向下轉型操作，但同事也會帶來新的問題，下面通過一段程序，來觀察一下會產生什么問題？
為了簡化定義一個簡單的泛型
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!");
print(msg);//以上的類對象進行引用傳遞
}
public static void print(Message<String> s){
System.out.println(s.getInfo());
}
}
但是如果現(xiàn)在定義的泛型類型不是String呢？例如：換成了int（不能是基本數(shù)據(jù)類型，只能是包裝類）
public class MessageDemo {
public static void main(String[] args) {
Message<Integer> msg = new Message<>();
msg.setInfo(100);
print(msg);//無法進行引用傳遞
}
public static void print(Message<String> s){
System.out.println(s.getInfo());
}
}
發(fā)現(xiàn)這個時候的print()方法無法再接收Message對象的引用，因為這個方法只能夠接收Message對象的引用，那么可以將print()方法重載換成Message
public class MessageDemo {
public static void main(String[] args) {
// TODO 自動生成的方法存根
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());
}
}
這個時候發(fā)現(xiàn)按照之前的方式根本就無法進行方法的重載，方法的重載沒有說為一個類而定義的，因為方法重載的時候觀察的不是泛型類型，而是類的名稱，或者說是數(shù)據(jù)類型的，所以現(xiàn)在就可以發(fā)現(xiàn)，這個給出了泛型類之后，就相當于將一個類又劃分成了幾個小類。
那么現(xiàn)在的問題：方法接收的參數(shù)問題又嚴重了，而且比之前使用對象多態(tài)性解決問題時出現(xiàn)的麻煩更大了，至少那個時候可以利用重載來接收一個類的所有子類對象，而現(xiàn)在連重載都使用不了。
這個時候，有人提出了，干脆在定義方法的時候就別寫泛型類型了。
定義方法的時候不定義泛型類型
public class MessageDemo {
public static void main(String[] args) {
// TODO 自動生成的方法存根
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)在的程序可算是正常了，但是新的問題又來了。問題就在于方法操作中，沒有類型限制了。
public static void print(Message msg){
msg.setInfo(100);
System.out.println(msg.getInfo());
}
發(fā)現(xiàn)此時在print()方法之中操作的時候，由于沒有設置泛型類型，那么所有類型都統(tǒng)一變?yōu)榱薕bject，也就可以修改了。而通過本程序也就發(fā)現(xiàn)了，必須找到一種方法，：此方法可以接收任意的泛型類型的設置，并且不能修改，只能輸出，為了解決這樣的問題，可以使用通配符“？”表示。
public static void print(Message<?> msg){
System.out.println(msg.getInfo());
}
由于“？”出現(xiàn)的情況較多，尤其在學習一些類庫的時候，所以對于“？”就記住一點，表示任意類型，如果有參數(shù)返回的時候也是這個“？”，當成Object進行理解。
既然現(xiàn)在談到了Obejct，那么現(xiàn)在實際上又有了另外一個問題：對于所有的子類，都是Object子類，那么如果對于之前的程序都使用Object能不能接收？
Message<String> msg = new Message<>(); Message<Object> s = msg;
因為Object的范圍比String的范圍大。
而在通配符“？”上有衍生出了兩個子符號：
設置泛型的上限：？extends 類；
例如：？extends Number，表示只能是Number或者是Number的子類Integer等；
2.設置泛型的下限：？super類；
例如：？super String，表示只能是String或者是String的父類（Object）
設置泛型上限
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());
}
}
設置泛型下限
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ù)據(jù)類型，但是由于不確定類型，無法修改
public static void print(Message<? super String> s){
System.out.println(s.getInfo());
}
}
3.4 泛型接口
在之前的所有定義的泛型之中，都是在類上定義的，而對于接口也是可以進行泛型定義的，而使用泛型定義的接口可以稱為泛型接口。
interface Message<T>{
public String echo(T msg);
}
而對于泛型接口的實現(xiàn)，在Java中有兩種方式：
方式一：在子類上繼續(xù)定義泛型，同時此泛型繼續(xù)在接口上使用
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!!");
}
}
方式二：在子類上設置具體類型
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 泛型方法
對于泛型除了可以在類上定義，也可以在方法上定義，而在方法上進行泛型的時候這個方法不一定非在泛型類中定義。
public class TestDemo {
public static void main(String[] args) {
// TODO 自動生成的方法存根
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三大主要特性——枚舉
在講解枚舉之前回顧一個概念：多例設計模式，構造方法私有化（非public），之后在類的內部存在若干個指定的對象，通過一個方法返回指定對象。
4.1 多例與枚舉
定義一個描述顏色基色的多例設計類
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("藍色");
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ā)
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)，利用枚舉實現(xiàn)多例設計會更加的簡單直白一些，但是在Java之中，枚舉并不是一個新的類型，嚴格來講，每一個使用enum定義的類實際上都屬于一個類繼承了Enum父類而已，而java.lang.Enum類定義如下：
public abstract class Enum<E extends Enum<E>> extends Object implements Comparable<E>, Serializable
而在Enum類種子紅定義了兩個方法：
取得枚舉的序號：public final int ordinal()；
取得枚舉的名稱：public final String name()。
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ù)
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());
}
}
}
面試題：請解釋enum和Enum的區(qū)別？
enum是一個關鍵字，使用enum定義的枚舉類本質上相當于一個類繼承了Enum類而已。
4.3 枚舉中定義其它結構
按照之前所理解，枚舉就屬于多例設計模式，那么既然是多例設計模式，對于類之中就肯定有多種組成，包括屬性，方法，構造方法，在枚舉之中也同樣可以定義以上的內容，不過需要注意的是，枚舉類之中定義的構造方法絕對不能是public，必須私有化。
除了這些要求之外枚舉之中每一個定義的對象必須定義在第一行。
package com.demo;
enum Color {
RED("紅色"),BULE("藍色"),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);
}
}
枚舉接口
package com.demo;
interface IColor{
public String getColor();
}
enum Color implements IColor{
RED("紅色"),BULE("藍色"),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 枚舉應用
只有指定的幾個對象
性別
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());
}
}
枚舉還可以進行switch語句進行編寫和判斷。
5、JDK三大主要特性——Annotation
在JDK1.5之后，程序允許通過注解（Annotation）的方式來進行程序的定義，而在JavaSE之中攢在了三種Annotation：@Override、@Deprecated、@SuppressWarnings。
5.1 準確的覆寫：@Override
方法的覆寫：發(fā)生繼承關系之中，子類定義了與父類的方法名稱相同、參數(shù)類型以及個數(shù)相同的覆寫，被覆寫的方法不能夠擁有比父類更為嚴格的訪問控制權限。
package com.annotation;
class Person{
//現(xiàn)在是希望進行toString()覆寫，但遺憾的由于你自己的輸入錯誤，導致方法的覆寫錯誤
//@Override
public String tostring(){//現(xiàn)在希望可以進行toString()方法的覆寫
return "一個人";
}
}
public class Demo1 {
public static void main(String[] args) {
System.out.println(new Person().tostring());
}
}
這個時候不叫覆寫，屬于自己定義一個擴展的方法，最為重要的是，這個問題在程序編譯的根本就無法顯示出來。但是現(xiàn)在為了保證我們的覆寫方法的嚴格，可以使用一個注解（@Override）來檢測：如果該方法確定成的覆寫了
，則不會有我們的語法錯誤，如果進行成功的覆寫，認為語法的錯誤。
package com.annotation;
class Person{
//現(xiàn)在是希望進行toString()覆寫，但遺憾的由于你自己的輸入錯誤，導致方法的覆寫錯誤
public String toString(){//現(xiàn)在希望可以進行toString()方法的覆寫
return "一個人";
}
}
public class Demo1 {
public static void main(String[] args) {
System.out.println(new Person());
}
}
5.2 聲明過期操作：@Deprecated
對于程序開發(fā)而言，往往一些使用的類要進行修改或者是維護，如果說現(xiàn)在一個類之中的某個方法，可能一開始推出的時候正常使用，但是在后面的版本就存在了一些問題，在修改之后不希望人再去使用這些方法，那么肯定不能直接刪除，因為如果直接刪除了，那么之前的程序就會出現(xiàn)問題了，所以最好的做法是告訴用戶：這個方法存在了問題，不建議再使用了，這個時候就使用“@Deprecated”聲明。
package com.annotation;
class Person1{
@Deprecated//表示該方法不建議使用，即使使用仍然不會報錯
public Person1(){}
public Person1(String name){}
@Deprecated
public void print(){}
}
public class Demo2 {
public static void main(String[] args) {
Person1 person = new Person1();//明確標記過期
person.print();
}
}
5.3 壓制警告：@SuppressWarning
程序在編譯的時候如果提示警告但是不會報錯只是存在了某些安全隱患，肯定會提示用戶，所以不想讓其顯示的話，就增加壓制警告信息。
package com.annotation;
class Person1<T>{
@Deprecated//表示該方法不建議使用，即使使用仍然不會報錯
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();//明確標記過期
person.print();
}
}
關于軟件的開發(fā)模式；
第一階段：會將所有的操作都寫在程序之中，例如：網(wǎng)絡程序，連接程序，連接的服務器地址，用戶驗證等；
第二階段：程序+配置文件，配置文件和程序相分離，配置文件過多，后期修改非常復雜；
第三階段：將配置文件寫回到程序之中，但是和程序進行有效的分離。
6、接口定義加強
造成此種尷尬的局面的核心問題在于，接口只是一個方法的聲明，而沒有具體方法的實現(xiàn)，所以隨著時間的推移，如果出現(xiàn)以上的問題，該接口將無法繼續(xù)使用。從JDK1.8為了解決這個問題，專門提供兩種專門的接口。
可以使用default來定義普通方法，需要通過對象調用?？梢允褂胹tatic來定義靜態(tài)方法，通過接口名就能使用。
定義普通方法
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方法
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();
}
}
整體來說，接口更像抽象類，但是比抽象類強大在于，接口的子類依然可以實現(xiàn)多繼承的關系，而抽象類繼續(xù)保持單繼承。
7、Lambda表達式
最具有代表性的就是haskell.函數(shù)式編程和面向對象編程為兩大開發(fā)陣營
傳統(tǒng)的面向對象開發(fā)
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();
}
}
使用匿名內部類來實現(xiàn)接口最大好處就是節(jié)約了一個文件，最大的缺點就是看的眼花繚亂，對于此操作有了更簡化的體現(xiàn)。如果采用函數(shù)式編程模型。
函數(shù)式編程模型
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ù)式編程前提，接口只能寫一個方法，如果編寫兩個方法，則會出現(xiàn)語法錯誤?？梢栽诮涌诘拈_頭加上@FunctionalInterface聲明這是一個函數(shù)接口。
實際上對于以上的語法形式：
(參數(shù) )->單行語句；
這個時候方法本身只包含一行語句，那么直接編寫語句即可，如果要是有多行語句，則就需要我們使用"{}"
package com.annotation;
@FunctionalInterface
interface 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)在你的表達式里面的內容只是一行進行數(shù)據(jù)的返回，那么直接使用語句即可，不用寫return。
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));
}
}
到此這篇關于Day11基礎不牢地動山搖-Java基礎的文章就介紹到這了,更多相關Java基礎內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
Java實戰(zhàn)之基于I/O流設計的圖書管理系統(tǒng)
這篇文章主要介紹了Java實戰(zhàn)之基于I/O流設計的圖書館管理系統(tǒng),文中有非常詳細的代碼示例,對正在學習java的小伙伴們有非常好的幫助,需要的朋友可以參考下2021-04-04
這篇文章主要介紹了MyBatis的動態(tài)SQL語句實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-01-01
這篇文章主要介紹了Java對文件的隨機讀寫以及壓縮處理操作,是Java入門學習中的基礎知識,需要的朋友可以參考下2015-10-10
這篇文章主要為大家介紹了Java8新特性 StreamAPI實例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-11-11
這篇文章主要介紹了用Java實現(xiàn)一個簡單的布隆過濾器,布隆過濾器是1970年由布隆提出的,它實際上是一個很長的二進制向量和一系列隨機映射函數(shù),布隆過濾器可以用于檢索一個元素是否在一個集合中,需要的朋友可以參考下2023-12-12
Java獲取年月日(格式：xxxx年xx月xx日)的方法詳解
在開發(fā)應用程序時,經常需要獲取當前的年、月、日,并以特定格式進行展示或處理,本文將介紹如何獲取年月日,并將其格式化為“xxxx年xx月xx日”的形式,幫助你在應用程序中處理日期信息,需要的朋友可以參考下2023-10-10
MyBatis執(zhí)行批處理操作的實現(xiàn)示例
在MyBatis中,批處理操作是一種高效執(zhí)行多條語句的方式,下面就來介紹一下MyBatis執(zhí)行批處理操作的實現(xiàn)示例,具有一定的參考價值,感興趣的可以了解一下2024-07-07
springboot中nacos-client獲取配置的實現(xiàn)方法
本文主要介紹了springboot中nacos-client獲取配置的實現(xiàn)方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2023-04-04
SpringBoot中使用Redis?Stream實現(xiàn)消息監(jiān)聽示例
本文主要介紹了SpringBoot中使用Redis?Stream實現(xiàn)消息監(jiān)聽示例，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-06-06
在實際開發(fā)中項目會非常多,如何在項目中快速定位,你說需要找到的類或方法,可以利用idea的全局搜索功能,下面這篇文章主要給大家分享介紹了關于idea全局搜索快捷鍵超詳細總結的相關資料,需要的朋友可以參考下2023-01-01