2. 程式人生 > >13. 泛型和枚舉

13. 泛型和枚舉

阿新 • • 發佈：2017-06-11
了解 urn 特性 font sca 編譯過程 每一個 編程語言 str1

1. 泛型

Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。

泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。

假定我們有這樣一個需求：寫一個排序方法，能夠對整形數組、字符串數組甚至其他任何類型的數組進行排序，該如何實現？
答案是可以使用 Java 泛型。
使用 Java 泛型的概念，我們可以寫一個泛型方法來對一個對象數組排序。然後，調用該泛型方法來對整型數組、浮點數數組、字符串數組等進行排序。

1.1 為什麽需要泛型

1.1.1 沒有泛型會怎麽樣

先看下面的代碼：

List list = new ArrayList();  
list.add("RIMI");  
list.add(100);  
for (int i = 0; i < list.size(); i++) {  
  String name = (String) list.get(i); //取出Integer時，運行時出現異常  
System.out.println("name:" + name);  
}

本例向list類型集合中加入了一個字符串類型的值和一個Integer類型的值（這樣是合法的，因為此時list默認的類型為Object類型）。

在循環中，由於忘記了之前添加了Integer類型的值或其他原因，運行時會出現java.lang.ClassCastException。為了解決這個問題，泛型應運而生。

1.1.2 泛型的使用

Java泛型編程是JDK1.5版本後引入的。泛型讓編程人員能夠使用類型抽象，通常用於集合裏面。

只要在上例中將第1行代碼改成如下形式，那麽就會在編譯list.add(100)時報錯。

List<String> list = new ArrayList<String>();

通過List，直接限定了list集合中只能含有String類型的元素，從而在上例中的第6行中，無須進行強制類型轉換，因為集合能夠記住其中元素的類型信息，編譯器已經能夠確認它是String類型了。

1.1.3 泛型只在編譯階段有效

ArrayList<String> a = new ArrayList<String>();  
ArrayList b = new ArrayList();  
Class c1 = a.getClass();  
Class c2 = b.getClass();  
System.out.println(c1 == c2); //true

上面程序的輸出結果為true。因為所有反射的操作都是在運行時的，既然為true，就證明了編譯之後，程序會采取去泛型化的措施。

也就是說Java中的泛型，只在編譯階段有效。在編譯過程中，正確檢驗泛型結果後，會將泛型的相關信息擦出，並且在對象進入和離開方法的邊界處添加類型檢查和類型轉換的方法。也就是說，成功編譯過後的class文件中是不包含任何泛型信息的。

1.2 泛型方法

你可以寫一個泛型方法，該方法在調用時可以接收不同類型的參數。根據傳遞給泛型方法的參數類型，編譯器適當地處理每一個方法調用。

下面是定義泛型方法的規則：

  • 所有泛型方法聲明都有一個類型參數聲明部分（由尖括號分隔），該類型參數聲明部分在方法返回類型之前（在下面例子中的< E >）。 (java中E，T，？的區別？)
  • 每一個類型參數聲明部分包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱為一個類型變量，是用於指定一個泛型類型名稱的標識符。
  • 類型參數能被用來聲明返回值類型，並且能作為泛型方法得到的實際參數類型的占位符。
  • 泛型方法體的聲明和其他方法一樣。註意類型參數只能代表引用型類型，不能是原始類型（像int,double,char的等）。

下面的例子演示了如何使用泛型方法打印不同字符串的元素：

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 輸出數組元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

    public static void main( String args[] )
    {
        // 創建不同類型數組： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { ‘H‘, ‘E‘, ‘L‘, ‘L‘, ‘O‘ };

        System.out.println( "整型數組元素為:" );
        printArray( intArray  ); // 傳遞一個整型數組

        System.out.println( "\n雙精度型數組元素為:" );
        printArray( doubleArray ); // 傳遞一個雙精度型數組

        System.out.println( "\n字符型數組元素為:" );
        printArray( charArray ); // 傳遞一個字符型數組
    } 
}

結果為：

整型數組元素為:
1 2 3 4 5 

雙精度型數組元素為:
1.1 2.2 3.3 4.4 

字符型數組元素為:
H E L L O

1.3 泛型類

泛型類的聲明和非泛型類的聲明類似，除了在類名後面添加了類型參數聲明部分。

和泛型方法一樣，泛型類的類型參數聲明部分也包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱為一個類型變量，是用於指定一個泛型類型名稱的標識符。因為他們接受一個或多個參數，這些類被稱為參數化的類或參數化的類型。

示例：

public class Box<T> {

  private T t;

  public void add(T t) {
    this.t = t;
  }

  public T get() {
    return t;
  }

  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();

    integerBox.add(new Integer(10));
    stringBox.add(new String("睿峰科技"));

    System.out.printf("整型值為 :%d\n\n", integerBox.get());
    System.out.printf("字符串為 :%s\n", stringBox.get());
  }
}

運行結果：

整型值為 :10

字符串為 :睿峰科技

1.4 類型通配符

1、類型通配符一般是使用?代替具體的類型參數。例如 List<?> 在邏輯上是List,List 等所有List<具體類型實參>的父類。

public class GenericTest {

    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();

        name.add("icon");
        age.add(18);
        number.add(314);

        getData(name);
        getData(age);
        getData(number);

   }

   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

輸出結果為：

data :icon
data :18
data :314

解析： 因為getDate()方法的參數是List類型的，所以name，age，number都可以作為這個方法的實參，這就是通配符的作用

2、類型通配符上限通過形如List來定義，如此定義就是通配符泛型值接受Number及其下層子類類型。

public class GenericTest {

    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();

        name.add("icon");
        age.add(18);
        number.add(314);

        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3

   }

   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }

   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

輸出結果：

data :18
data :314

解析： 在(//1)處會出現錯誤，因為getUperNumber()方法中的參數已經限定了參數泛型上限為Number，所以泛型為String是不在這個範圍之內，所以會報錯

3、類型通配符下限通過形如 List<? super Number>來定義，表示類型只能接受Number及其三層父類類型，如Objec類型的實例。

<? extends T>和<? super T>的區別
<? extends T>表示該通配符所代表的類型是T類型的子類。
<? super T>表示該通配符所代表的類型是T類型的父類。

這也被稱為泛型的上下邊界

1.5 泛型的好處

  1. 類型安全。

    通過知道泛型定義的變量類型限制，編譯器可以更有效地提高Java程序的類型安全。

  2. 消除強制類型轉換。

    消除源代碼中的許多強制類型轉換。這使得代碼更加可讀，並且減少了出錯機會。所有的強制轉換都是自動和隱式的。

  3. 提高性能。

    Lits list1 = new ArrayList();  
list1.add("RIMI");  
String str1 = (String)list1.get(0);  

List<String> list2 = new ArrayList<String>();  
list2.add("RIMI");  
String str2 = list2.get(0);

    對於上面的兩段程序，由於泛型所有工作都在編譯器中完成，javac編譯出來的字節碼是一樣的（只是更能確保類型安全），那麽何談性能提升呢？是因為在泛型的實現中，編譯器將強制類型轉換插入生成的字節碼中，但是更多類型信息可用於編譯器這一事實，為未來版本的 JVM 的優化帶來了可能。

1.6 List與List<?>

  1. List實際上也是List
  2. 而List<?>表示具有某種特定類型的非原生List，只是我們不知道那種類型是什麽。

練習：

用TreeSet裝入學生類型和工人類型兩種類型，兩種類型都要進行排序。要求只有一個比較器。

2. 枚舉

// 枚舉定義
public enum Color {//enum是計算機編程語言中的一種數據類型。枚舉類型：在實際問題中，有些變量的取值被限定在一個有限的範圍內。
     RED, GREEN, BLANK, YELLOW 
}
// 枚舉使用
public static void main(String[] args) { 
    System.out.println( isRed( Color.BLANK ) ) ;  //結果： false
    System.out.println( isRed( Color.RED ) ) ;    //結果： true

}
// 枚舉值的使用
static boolean isRed( Color color ){
    if ( Color.RED.equals( color )) {
        return true ;
    }
    return false ;
}

===================================================
public enum Color {
    RED, GREEN, BLANK, YELLOW
}

public static void main(String[] args) {
    showColor(Color.RED);
}

static void showColor(Color color) {
    switch (color) {
    case BLANK:
        System.out.println(color);
        break;
    case RED:
        System.out.println(color);
        break;
    default:
        System.out.println(color);
        break;
    }
}



===================================================
//自定義函數
public enum Color {
    RED("紅色", 1), GREEN("綠色", 2), BLANK("白色", 3), YELLO("黃色", 4);
    private String name;
    private int index;
    private Color(String name, int index) {
        this.name = name;
        this.index = index;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
}


public static void main(String[] args) {
    // 輸出某一枚舉的值
    System.out.println(Color.RED.getName());
    System.out.println(Color.RED.getIndex());
    // 遍歷所有的枚舉
    for (Color color : Color.values()) {
        System.out.println(color + "  name: " + color.getName() + "  index: " + color.getIndex());
    }
}

13. 泛型和枚舉

相關推薦

13. 泛型和枚舉

了解 urn 特性 font sca 編譯過程 每一個 編程語言 str1 html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address

2基本類型數組和枚舉類型——重拾Java

arraycopy 字符 第一個 system.in abs xtend 劃線 ann else 2.1 標識符和關鍵字 2.1.1標識符 標識符：用來標誌類名、變量名、方法名、類型名、數組名、文件名的有效字符序列稱為標識符。簡單地說，標識符就是一個名字。 Java關於標識

泛型和面向對象C++

div ted 轉換函數 avi primer auto 友元 line 指針 1. 在類內部定義的函數默覺得inline，內聯函數應該在頭文件裏定義，由於其定義對編譯器必須是可見的，以便編譯器可以在調用點內聯展開該函數的代碼。此時，僅有函數原型是不夠的。 2.a

快學Scala 第九課 （伴生對象和枚舉）

over objectc yellow str imp 擴展類 new 伴生對象 ray Scala沒有靜態方法和靜態字段， 你可以用object這個語法結構來達到同樣的目的。 對象的構造器只有在第一次被使用時才調用。 伴生對象apply方法： 類和它的伴生對象可以互相訪問

十二、事件，委托，泛型委托，集合（泛型和非泛型），Lambda表達式（聲明委托，使用委托，簡單的委托示例，action<T>和func<t>委托，多播委托，匿名方法，Lambda表達式，參數，事件）

multicast new 調用方法 多播 ted 被調用 輸入參數 pac cas 事件(Event) 事件是一種對象或類能夠提供通知的成員，客戶端可以通過提供事件處理程序為相應的事件可添加可執行代碼，事件可以理解為一種特殊的委托。 委托(Delegate) 委托是存有對

C# 泛型和委托

color program object turn cnblogs urn task pub cdd using System; using System.Collections.Generic; using System.Linq; using System.Text;

C++/C 聯合和枚舉

虛函數 c語言 靜態成員 靜態成員函數 union ons 相同 聯合 nio 聯合Union 1.一個聯合變量的地址和一個聯合變量任意一個成員地址相同。 2.同類型的聯合變量不能比較大小。 3.可以定義構造函數和析構函數，但不能有虛函數和靜態成員函數，不能作為基類或派生類

Java泛型和類型安全的容器

swa 註意 取出 i++ long gpo system style res 示例： 1 public class Apple { 2 private static long counter; 3 private final long id = coun

Effective Java 第三版——32.合理地結合泛型和可變參數

-o expose 靜態工廠 變體 dom 圖片 fas 另一個 對數 Tips 《Effective Java, Third Edition》一書英文版已經出版，這本書的第二版想必很多人都讀過，號稱Java四大名著之一，不過第二版2009年出版，到現在已經將近8年的時間

函數輸入參數類型為枚舉時，則限定函數參數的接收範圍，非枚舉值輸入則錯誤

sun span fun clas 範圍 函數參數 類型 枚舉類 入參 1 typedef enum 2 { 3 Mon = 1, 4 Tues, 5 Wed, 6 Thurs, 7 Fri, 8

java異常、泛型和反射

（1）異常 異常的概念：所謂異常是指程式在執行過程中發生的一些不正常事件。（如：除0溢位，陣列下標越界，所讀取的檔案不存在） 異常導致的結果：java程式的執行過程中如出現異常事件，可以生成一個異常類物件。該異常物件封裝了異常事件的資訊，並將其提交給java執行時系統，這個過程成為丟擲異

泛型和列舉類幾點筆記

物件的儲存：1、陣列（基本資料型別&引用資料型別）2、集合（引用資料型別） 陣列儲存資料的弊端：長度一旦初始化，就不可變；真正給陣列元素賦值的個數沒有現成的方法可用 為什麼要有泛型 1.解決元素儲存的安全性問題。2.解決獲取資料元素時，需要型別強制的問題

JAVA基礎複習（六）泛型和集合

1、泛型的優點是能在編譯時檢測出錯誤，一旦編譯器認為泛型型別是安全使用的，就會將它轉換為原始型別，泛型類或方法允許使用者指定可以和這些類或方法一起工作的物件型別 2、泛型型別必須是引用型別，不能使用int、double等基本型別來替代泛型集合 3、泛型集合類的構造方法和普通類相同,定義一個泛

Java 泛型和萬用字元

Java 泛型和萬用字元        很多時候，反射並不能滿足業務的需求，Java 泛型和萬用字元與反射配合使用可使得反射的作用發揮到完美的地步，從而實現真正的通用。 直接上程式碼 import java.

scala中泛型和隱式轉化

隱式轉化 邊寫邊譯模式中:   new Person[Int](15,18).max() class Data(number: Int){ def show(): Int ={ print("1"+" "+number) 2 } } implicit def show(n

C# 利用泛型和反射靈活接收資料

private void button1_Click(object sender, EventArgs e) { //dic是獲取到的資料列表，這裡假設成有這三種 Dictionary<string, object> dic = new Dictionary

java反射（9）泛型和Class類

在不適用泛型的時候，必須將利用反射得到的物件進行強制轉換才可以對他進行相應的賦值，如下 package Chapter_6; import java.util.Date; public class YeekuObjectFactory { public stat

泛型和介面的方式設計一個計算器

首先，定義一個介面，進行統一和約束程式碼， 泛型在編寫時，是Object型別的，所以為了計算，把Object轉成字串進行計算，BigDecimal類對字串處理更加精確，計算時用BigDecimal類中的方法進行計算 public interface ICounter {

通過泛型和反射構建一個簡單的集合操作工具類

      平時在操作集合物件的時候（比如List）；我想一次新增大於一個數據的時候，往往需要通過一個集合物件呼叫兩次add方法，比如： List<Person> personList=new ArrayList<>(); Person p1=n

JAVA中泛型和Object的區別

重點：泛型的主要目的之一就是用來指定容器，而由編譯器來保證型別的正確性。此處以別處的demo為例，具體出處於（https://www.cnblogs.com/xujanus/p/8474553.html）：問題：下面2個方法的宣告有何不同public Object doSom