Java自学笔记⑪

枚举与泛型

枚举

使用枚举类型设置常量

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
*/