列舉與泛型

列舉

使用列舉型別設定常量

interface Constants{						//將常量放置在介面中
	public static final int Constants_A=1;
	public static final int Constants_B=11;
}

public class ConstantsTest {
	enum Constants2{						//將常量放置在列舉型別中
		Constants_A,Constants_B;			//enum是定義列舉型別的關鍵字，
	}
	
	public static void doit(int i){
		switch(i){
		case Constants.Constants_A:
			System.out.println("doit() Constants_A");
			break;
		case Constants.Constants_B:
			System.out.println("doit() Constants_B");
			break;
		}
	}
	
	public static void doit2(Constants2 c){
		switch(c){
		case Constants_A:
			System.out.println("doit2() Constants_A");
			break;
		case Constants_B:
			System.out.println("doit2() Constants_B");
			break;
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ConstantsTest.doit(Constants.Constants_A);
		ConstantsTest.doit2(Constants2.Constants_A);
		ConstantsTest.doit2(Constants2.Constants_B);
		ConstantsTest.doit(3);
		//ConstantsTest.doit2(3);
	}

}
/*
在以上程式碼中，當使用者呼叫doit()方法時，即使編譯器不接受在介面中定義的常量引數，也不會報錯；但呼叫doit2()方法，任意傳遞引數，編譯器就會報錯，因為這個方法只能接收列舉型別的常量作為其引數。·
*/

操作列舉型別成員的方法

方法名稱	具體含義	使用方法
values()	該方法可以將列舉型別成員以陣列的形式返回	列舉型別名稱.values()
valueOf()	該方法可以實現將普通字串轉換為列舉例項	列舉型別名稱.valueOf(“abc”)
compareTo()	該方法用於比較兩個列舉物件在定義時的順序	列舉物件.compareTo()
ordinal()	該方法用於得到列舉成員的位置索引	列舉物件.ordinal()

public class ShowEnum {
	enum Constants{
		Constants_A,Constants_B,Constants_C,Constants_D
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Constants[] enumArray=Constants.values();
		for(int i=0;i<enumArray.length;i++){
			System.out.println("列舉型別成員變數：  "+enumArray[i]);
		}
	}

}
/*輸出結果：
列舉型別成員變數：  Constants_A
列舉型別成員變數：  Constants_B
列舉型別成員變數：  Constants_C
列舉型別成員變數：  Constants_D
*/

public class EnumMethodTest {
	enum Constants {
		Constants_A, Constants_B, Constants_C, Constants_D
	}

	public static void compare(Constants c) {
		Constants[] array = Constants.values();
		for (int i = 0; i < array.length; i++) {
			System.out.println(c + "與" + array[i] + "的比較結果為：" + c.compareTo(array[i]));
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		compare(Constants.valueOf("Constants_B"));
	}

}
/*輸出結果
Constants_B與Constants_A的比較結果為：1
Constants_B與Constants_B的比較結果為：0
Constants_B與Constants_C的比較結果為：-1
Constants_B與Constants_D的比較結果為：-2
*/

注：呼叫compareTo()方法時，如果方法中引數在呼叫該方法的列舉物件位置之前，則返回正整數，；如果兩個互相比較的列舉成員的位置相同，則返回0；如果方法中引數在呼叫該方法的列舉物件之後，則返回負整數。

public class EnumIndexTest {
	enum Constants2{
		Constans_A,Constans_B,Constans_C
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=0;i<Constants2.values().length;i++){
			System.out.println(Constants2.values()[i]+"在列舉型別中位置索引值"+Constants2.values()[i].ordinal());
		}
	}
}
/*輸出結果
Constans_A在列舉型別中位置索引值0
Constans_B在列舉型別中位置索引值1
Constans_C在列舉型別中位置索引值2
*/

列舉型別中的構造方法

public class EnumConTest {
   enum Constants2{
   	Constants_A("我是列舉成員A"),
   	Constants_B("我是列舉成員B"),
   	Constants_C("我是列舉成員C"),
   	Constants_D(3);
   	private String description;
   	private int i=4;
   	//定義引數為String型的構造方法
   	private Constants2(String description){
   		this.description=description;
   	}
   	private Constants2(int i){
   		this.i=this.i+i;
   	}
   	public String getDescription(){
   		return description;
   	}
   	public int getI(){
   		return i;
   	}
   	
   }
   public static void main(String[] args) {
   	// TODO Auto-generated method stub
   	Constants2[] array=Constants2.values();
   	for(int i=0;i<array.length;i++){
   		System.out.println(array[i]+"呼叫getDscription()方法為："+array[i].getDescription());
   	}
   	Constants2 c2=Constants2.valueOf("Constants_D");
   	System.out.println(c2+"呼叫getI()方法為："+c2.getI());
   }

}
/*輸出結果
Constants_A呼叫getDscription()方法為：我是列舉成員A
Constants_B呼叫getDscription()方法為：我是列舉成員B
Constants_C呼叫getDscription()方法為：我是列舉成員C
Constants_D呼叫getDscription()方法為：null
Constants_D呼叫getI()方法為：7
*/

泛型

定義泛型類

語法：類名 其中T代表一個型別的名稱

public class OverClass<T> {
	private T over;
	public T getOver(){
		return over;
	}
	public void setOver(T over){
		this.over=over;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//例項化一個Boolean型的物件
		OverClass<Boolean> over1=new OverClass<Boolean>();
		OverClass<Float> over2=new OverClass<Float>();
		over1.setOver(true);
		over2.setOver(12.3f);
		Boolean b=over1.getOver();
		Float f=over2.getOver();
		System.out.println(b);
		System.out.println(f);
	}
}
/*輸出結果
true
12.3
*/

泛型的常規用法

定義泛型類時宣告多個型別

//MutiOverClass<T1,T2>
//MutiOverClass:泛型類名稱
MutiOverClass<Boolean,Float>=new MutiOverClass<Boolean,Float>();

定義泛型類時宣告陣列型別

public class ArrayClass<T> {
	private T[] array;
	
	public T[] getArray(){
		return array;
	}
	
	public void setArray(T[] array){
		this.array=array;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayClass<String> a=new ArrayClass<String>();
		String[] array={"成員a","成員b","成員c","成員d"};
		a.setArray(array);
		for(int i=0;i<a.getArray().length;i++){
			System.out.println(a.getArray()[i]);
		}
		
	}

}

集合類宣告容器的元素

import java.util.HashMap;
import java.util.Map;

public class MutiOverClass<K, V> {
	public Map<K,V> m=new HashMap<K,V>();
	
	public void put(K k,V v){
		m.put(k, v);
	}
	public V get(K k){
		return m.get(k);
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MutiOverClass<Integer, String> mu =new MutiOverClass<Integer,String>();
		for(int i=0;i<5;i++){
			mu.put(i,"我是集合成員"+i);
		}
		for(int i=0;i<mu.m.size();i++){
			System.out.println(mu.get(i));
		}
	}

}
/*輸出結果
我是集合成員0
我是集合成員1
我是集合成員2
我是集合成員3
我是集合成員4
*/