Java 枚举类型与泛型

枚举类型可以取代往常的常量定义方式，即：将常量封装在类或接口中。

枚举类型

使用枚举类型定义常量，枚举类型可以定义在类内也能定义在类外

public enum Constants{    //enum是枚举类型的关键字
	Constants_A,
	Constants_B,
	Constants_C;
}
程序中需要用到常量时，可以使用Constants.Constants_A来表示

枚举类型成员的操作方法

枚举类型可以看做一个类，它继承自java.lang.Enum类。当定义了枚举类型时，每个枚举类型的成员可以看做枚举类型的一个实例，这些成员默认被final、public、static修饰
枚举类型的常用方法

枚举类型名称.values()    
    返回枚举类型成员，以数组形式
枚举类型名称.valueOf("abc")    
    将普通字符串转换为枚举实例，注意该字符串必须是枚举类型中的成员名称，否则报错
枚举对象.compareTo()    
    比较两个枚举对象在定义时的顺序，正值说明参数在调用对象的前面，负值为在后面，0为位置相同
枚举对象.ordinal()    
    返回枚举成员的位置索引

枚举类型的构造方法

枚举类型中可以有构造方法，但该构造方法必须为private。若构造方法有参数，每个枚举类型成员必须使用该构造方法，因为每个成员都是一个枚举类型的实例

public enum Constants{
	Constants_A("我是枚举成员A"),
	Constants_B("我是枚举成员B");
	private String description;
	private Constants(){};
	private Constants(String description){
		this.description = description;
	}
	public String getDescription() {
        return description;
    }
}

枚举类型的优势

枚举类型声明了一种用户友好的变量定义方法，枚举了某种数据类型所有可能出现的值，他的优点如下：

1. 类型安全
2. 紧凑有效的数据定义
3. 可以和程序其他部分完美交互
4. 运行效率高

泛型

先来看一个问题，下面代码中向上转型不会后什么问题，但是向下转型时，如果用错了类型，就会出现异常。泛型机制有效解决了这一问题。

public class Test{
	private Object b;
	public Object getB(){
		return b;
	}
	public void setB(Object b){
		this.b = b;
	}
	public static void main(){
		Test t = new Test();
		t.setB(new Float(12.2));    //向上转型，Float-->Object
		Float f = (Float) t.getB();    //向下转型，Object-->Float
		Float f = (Integer) t.getB();    //向下转型类型异常，但由于无语法错误编译器无法发现，执行时会出现ClassCastException异常
	}
}

定义泛型类

Object类为最上层父类，为了使程序更具有普适性，通常使传入返回的值都以Object类为主，当需要使用时必须进行类型转换。
泛型的定义语法如下：

类名<T>    //T为类型名

使用泛型定义的类可以在类中以一个通用符号表示数据类型，声明该类对象时再根据需求指定的真正类型，而在类的方法中传参时不再需要进行类型转换。

public class fanxing_test<T> {    //定义泛型类
    private T over;    //定义泛型成员变量
    public T getOver(){
        return over;
    }
    public void setOver(T over){
        this.over = over;
    }
    public static void main(String[] args) {
        fanxing_test<Boolean> over1 = new fanxing_test<Boolean>();
        fanxing_test<Float> over2 = new fanxing_test<Float>();
        over1.setOver(true);
        over2.setOver(12.3f);
        System.out.println(over1.getOver());
        System.out.println(over2.getOver());
    }
}

泛型的常规用法

1. 定义泛型类时声明多个类型

MultiOverClass<T1,T2>
MultiOverClass<Boolean, Float> = new MultiOverClass<Boolean, Float>();

2. 定义泛型类时声明数组类型

public class fanxing_test<T1,T2> {    //定义泛型类
    private T1 over;    //定义泛型成员变量
    private T2[] array;    //定义泛型数组成员变量
    public T1 getOver(){
        return over;
    }
    public void setOver(T1 over){
        this.over = over;
    }

    public T2[] getArray() {
        return array;
    }
    public void setArray(T2[] array) {
        this.array = array;
    }

    public static void main(String[] args) {
        fanxing_test<Float,String> over2 = new fanxing_test<Float,String>();
        over2.setOver(12.3f);
        String[] array = {"C1","C2","C3","C4","C5"};
        over2.setArray(array);
        System.out.println(over2.getOver());
        for(int i=0; i<over2.getArray().length; i++){
            System.out.println(over2.getArray()[i]);
        }
    }
}

3. 集合类声明容器的元素

public class TestClass<K,V>{
	public Map<K,V> m = new HashMap<K,V>(); 
	public static void main(String[] args){
		TestClass<String,Integer> mu = new TestClass<String,Integer>();
	}
}
这里只做展示，事实上集合类中都已经泛型化了，使用时不需要额外定义类，直接传泛型的参即可

泛型的高级用法

1. 限制泛型可用类型

class 类名<T extends anyClass>     anyClass是某个接口或类

泛型只能是anyClass类型的

2. 使用类型通配符
   挖坑

3. 继承泛型类实现泛型接口
   挖坑

总结

泛型的参数类型只能是类类型，不能是简单类型，如A< int >是错误的
泛型的类型数可以不唯一
可以用extends关键字限制泛型类型
可以用通配符限制泛型类型