java枚举类型与泛型

• 枚举类型：取代以往定义常量的方式，同时枚举类型还提供程序编译时进行检查的功能

// 以往定义常量的方法
public interface Constants{
    public static final int Constants_A = 1;
    public static final int Constants_B = 2;
}

// 用枚举代替以往的方法
public enum Constants{
    CONSRANT_A,
    CONSRANT_B,
    CONSRANT_C
}

• 枚举类型可以看作是一个类，枚举类中的成员可以看作是枚举类型的一个具体的实例，这些枚举类型的成员都默认被final、static、public修饰
• 枚举类型的方法：

public class ConstantsDemo {
    public static void main(String[] args){
        System.out.println(Arrays.toString(Constants.values()));
        // 这个方法通过名称获取enum的实例，名称不存在的话会报错
        System.out.println(Constants.valueOf("CONSTANT_1"));
        // 比较两个实例在定义时候的顺序，输出为定义的顺序的差值
        System.out.println(Constants.CONSTANT_2.compareTo(Constants.CONSTANT_1));
        // 定义时的位置索引，索引从0开始算
        System.out.println(Constants.CONSTANT_2.ordinal());
    }
}

• 枚举类型的构造方法：

public class EnumTest {
    enum Constant{
        /*
        * aaa
        * */
        CONSTANT_A(),
        CONSTANT_B("小明");
        private String name;
        private int i;
        private Constant(){}
        private Constant(String name){
            this.name = name;
        }
        private Constant(int i){
            this.i = i;
        }

        public String getName(){
            return this.name;
        }

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

    public static void main(String[] args){
        System.out.println(Constant.CONSTANT_B.getName());
    }
}

• 泛型的基本用法，可以用于变量、数组、容器、类、接口等

public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;
 
    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
 
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

• 泛型的高级用法

// 限制泛型可用的类型
public class LimitClass<? extends List>{
    // do something
}

// 使用类型通配符
A<? extends List> a = null;
a = new A<ArraList>();

// 限定参数的类型
public void test(A<? extends List> a){}

• 泛型使用注意事项

// 这里需要注意的是L1我们是可以通过set方式添加值，而L2不行，L2只能删除和获取值
List<String> L1 = new List();
List<?> L2 = L1；

• 泛型的向上限制

// 这里实现向上限制
A<? super List> a = null;
a = new A<Object>;