【JAVA-枚举和泛型】

枚举类型是将常量封装在类或接口中，本质上还是以类的形式存在。泛型可以减少代码量，还不会因为对象置于某个容器中而失去其类型。

枚举

1.1 使用枚举类型设置常量

常量一般放在接口，便于使用，且在接口中使用final或static关键字修饰。

package Enum;

interface Constants{
    public static final int Constants_A = 1;
    public static final int Constants_B = 12;
}

public class ConstantTest {
    enum Constants2 {
        Constants_A,Constants_B
    }

    public static void doit(int c){
        switch(c){
            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){
        ConstantTest.doit(Constants.Constants_A);
        ConstantTest.doit(Constants.Constants_B);
        ConstantTest.doit2(Constants2.Constants_A);
        ConstantTest.doit2(Constants2.Constants_B);
    }
}

常用方法：

package Enum;

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

    public static void compare(Constants c){
        Constants enumArray[] = Constants.values();
        for(int i = 0;i<enumArray.length;i++){
            System.out.println(c + "与枚举类型成员变量:"+enumArray[i]+"的比较结果为" + c.compareTo(enumArray[i]));
        }
    }

    public static void showOrdinal(){
        for(int i=0;i<Constants.values().length;i++){
            System.out.println(Constants.values()[i] + "在枚举类型中位置索引值" + Constants.values()[i].ordinal());
        }
    }
    public static void main(String[] args){
        compare(Constants.valueOf("Constants_B"));
        showOrdinal();
    }

}

Constants_B与枚举类型成员变量:Constants_A的比较结果为1
Constants_B与枚举类型成员变量:Constants_B的比较结果为0
Constants_B与枚举类型成员变量:Constants_C的比较结果为-1
Constants_B与枚举类型成员变量:Constants_D的比较结果为-2
Constants_A在枚举类型中位置索引值0
Constants_B在枚举类型中位置索引值1
Constants_C在枚举类型中位置索引值2
Constants_D在枚举类型中位置索引值3

1.3 枚举类型的构造方法

枚举类型中可以添加构造方法，但是构造方法必须是private修饰符或者是默认修饰符。定义一个有参构造方法后需要对枚举类型成员使用该构造方法。如Constant("我是枚举常量")，Constant(2)可以相应的使用参数为String型和int型构造方法。然后可以在枚举类型中定义成员变量，在构造方法中为变量赋值，这样就可以在枚举类型中定义该成员变量的getXXX()方法。

package Enum;

public class EnumConTest {
    enum Constants2{
        Constants2_A("我是枚举成员A"),
        Constants2_B("我是枚举成员B"),
        Constants2_C("我是枚举成员C"),
        Constants2_D(2);


        private String description;
        private int i;
        private Constants2(String description){
            this.description = description;
        }
        private Constants2(int i){
            this.i = i;
        }

        public String getDescription(){
            return this.description;
        }

        public int getI() {
            return this.i;
        }
    }

    public static void main(String[] args){
        Constants2 array[] = Constants2.values();
        for(int i = 0;i < array.length;i++){
            System.out.println(array[i] + "调用getDescription()方法的结果为:" + array[i].getDescription());
        }
        Constants2 cons = Constants2.valueOf("Constants2_D");
        System.out.println(cons + "调用getI()方法的结果为：" + cons.getI());
    }
}

Constants2_A调用getDescription()方法的结果为:我是枚举成员A
Constants2_B调用getDescription()方法的结果为:我是枚举成员B
Constants2_C调用getDescription()方法的结果为:我是枚举成员C
Constants2_D调用getDescription()方法的结果为:null
Constants2_D调用getI()方法的结果为：2

除了上面这种方式，还可以将方法定义在接口中，使枚举类型实现该接口，然后使每个枚举类型实现接口中的方法： 

package Enum;


interface EnumInterface{
    public String getDescription();
    public int getI();
}

public enum AnyEnum implements EnumInterface{

    Constant_A {
        public String getDescription(){
            return ("我是枚举类型A");
        }
        public int getI(){
            return i;
        }
    },

    Constant_B {
        public String getDescription(){
            return ("我是枚举类型B");
        }
        public int getI(){
            return i;
        }
    },

    Constant_C {
        public String getDescription(){
            return ("我是枚举类型C");
        }
        public int getI(){
            return i;
        }
    },
    Constant_D {
        public String getDescription(){
            return ("我是枚举类型D");
        }
        public int getI(){
            return i;
        }
    };

    private static int i = 5;

    public static void main(String[] args){
        AnyEnum array[] = AnyEnum.values();
        for(int i = 0;i<array.length;i++){
            System.out.println(array[i] + "调用getDescription()方法为:" + array[i].getDescription());
            System.out.println(array[i] + "调用getI()方法为:" + array[i].getI());
        }
    }
}

使用枚举类型的优点：类型安全，运行效率高，紧凑有效，完美交互。

泛型

在某些强制类型转换的错误不会被编译器捕捉，(向上转型是安全的，向下转型操作时用错了类型，或者并没有执行该操作，就会出现异常)所以提供了泛型机制。

①定义泛型

类名<T>

其中T是泛型的名称，代表某一种类型，在创建该类对象时需要指定T所代表的具体类型，如果不指定具体类型，则采用Object型。
定义泛型数组：

package Enum;

public class OverClass<T> {
    private T over;
    private T getOver(){
        return this.over;
    }
    public void setOver(T over){
        this.over = over;
    }
    public static void main(String[] args){
        OverClass<Boolean> over1 = new OverClass<Boolean>();
        OverClass<Float> over2 = new OverClass<Float>();
        over1.setOver(true);
        over2.setOver(12.3f);
        System.out.println(over2.getOver());
        System.out.println(over1.getOver());
    }

}

12.3
true

②泛型的常规用法：

(i)定义泛型类时声明多个类型

class Myclass<T1,T2>

(ii)定义泛型类时声明数组类型

 但是不能使用泛型建立一个数组实例

package Enum;

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){
        ArrayClass<String> a = new ArrayClass<String>();
        String[] array = {"成员1","成员2","成员3"};
        a.setArray(array);
        for(String str:a.getArray()){
            System.out.println(str);
        }
    }
}

成员1
成员2
成员3

(iii)集合类声明容器元素

集合接口，集合类都被定义了泛型，比如List<E>的泛型E，Map<K,V>的泛型K,V。

常见的被泛型化的集合有：

package Enum;

import java.util.*;

public class ListClass {
    public static void main(String[] args){
        List<Integer> a = new ArrayList<Integer>();
        a.add(1);
        for(int i=0;i<a.size();i++){
            System.out.println("获取ArrayList容器的值:" + a.get(i));
        }
        Map<Integer,String> m = new HashMap<Integer,String>();
        for(int i=0;i<5;i++){
            m.put(i,"成员"+i);
        }
        for(int i = 0;i<m.size();i++){
            System.out.println("获取Map容器的值:"+m.get(i));
        }
        Set<Character> set = new HashSet<Character>();
        set.add('一');
        set.add('二');
        for(Character c : set){
            System.out.println("获取Set容器的值:"+c);
        }
    }
}

获取ArrayList容器的值:1
获取Map容器的值:成员0
获取Map容器的值:成员1
获取Map容器的值:成员2
获取Map容器的值:成员3
获取Map容器的值:成员4
获取Set容器的值:一
获取Set容器的值:二