枚举类型与泛型

JDK1.5中新增了枚举类型和泛型，枚举类型可以取代以往常量的定义方式，将常量封装在类或接口中，还提供了安全检查功能。枚举类型本质上还是以类的形式存在。泛型的出现不仅可以让程序员少写很多代码，主要的作用是解决类型安全问题，提供编译时的安全检查，不会因为将对象置于某个容器中而失去类型。

枚举类型
以往定义常量的方式使用接口，这样在程序中可以直接被使用，而且该常量不能被修改，接口中定义常量是修饰符为final和static，如下实例：

package enumeration.simple;

public interface ConstantDemos {
public static final int Constants_A = 1;
public static final int Constants_B = 12;
} JDK1.5以后采用枚举类型代替常量定义方式：
package enumeration.simple;

public enum Constants {
Constants_A,
Constants_B,
Constants_C
}
其中enum为定义枚举类型的关键字，可以通过Constants.Constants_A的方式进行调用。
编译器即使没有接收到接口中定义的常量参数，也不会报错；但如果是枚举类型，该方法就只能接收枚举类型的常量作为参数，其他任何形式都会报错。枚举类型与传统定义常量的方式相比具有类型检测的功能。
package enumeration;

interface Constants1{
public static final int CONSTANTS_A = 1;
public static final int CONSTANTS_B = 2;
}
public class ConstantsTest {
enum Constants2 {
CONSTANTS_A, CONSTANTS_B
}
public static void doit(int c){
switch(c){
case Constants1.CONSTANTS_A:
System.out.println("diot: CONSTANTS_A");
break;
case Constants1.CONSTANTS_B:
System.out.println("diot: CONSTANTS_B");
break;
}
}
public static void doit2(Constants2 c){
switch(c){
case CONSTANTS_A:
System.out.println("diot2: CONSTANTS_A");
break;
case CONSTANTS_B:
System.out.println("diot2: CONSTANTS_B");
break;
}
}
public static void main(String[] args) {
// 不接收常量参数也不会报错
ConstantsTest.doit(Constants1.CONSTANTS_A);
// 必须是枚举类型
ConstantsTest.doit2(Constants2.CONSTANTS_A);
ConstantsTest.doit2(Constants2.CONSTANTS_B);
ConstantsTest.doit(3);
}
}
另外，枚举类型可以看作是一个类，而每个枚举类型成员都可以看作是枚举类型的一个实例，枚举类型成员默认都是被final、public、static修饰。而且枚举类型的类都继承自java.lang.Enum类，该类中有操作枚举类型的方法：
values（）：将枚举类型的成员以数组的形式返回；

valueOf（）：将普通字符串转为枚举类型的实例；

compareTo（）：用于比较两个枚举对象在定义时的顺序；

ordinal（）：用于得到枚举成员的索引位置；

package enumeration;

public class ShowEnum {
enum Constants2{
Constants_a, Constants_b
}
public static void compare(Constants2 c){
for(int i = 0; i < Constants2.values().length; i++){
System.out.println(c + " and " + Constants2.values()[i
a7e8
] + " compare and result is " + c.compareTo(Constants2.values()[i]));
}
}
public static void main(String[] args) {
for(int i = 0; i < Constants2.values().length; i++){
System.out.println(Constants2.values()[i]);
}
compare(Constants2.Constants_a);
for(int i = 0; i < Constants2.values().length; i++){
System.out.println(Constants2.values()[i].ordinal());
}
}
}

package enumeration;

public class EnumIndexTest {
enum Constants2{
Constants_A, Constants_B, Constants_C, Constants_D;
}
public static void main(String[] args) {
for(int i = 0; i < Constants2.values().length; i++){
System.out.println(Constants2.values()[i] + "---" + Constants2.values()[i].ordinal());
}
}
}

枚举类型种可以添加构造方法，但是规定必须为private修饰符锁修饰。
package enumeration.simple;

public class EnumIndexTest {
enum Constants{
Constants_A("a"),
Constants_B("b"),
Constants_C(1);

private String des;
private int i = 4;

private Constants(){

}

private Constants(String des){
this.des = des;
}

private Constants(int i){
this.i = this.i + i;
}

public String getDes(){
return des;
}

public int getI(){
return i;
}
}
public static void main(String[] args) {
for(int i = 0; i < Constants.values().length; i++){
System.out.println(Constants.values()[i] + "---" + Constants.values()[i].getDes());
}
System.out.println(Constants.valueOf("Constants_C") + "---" + Constants.valueOf("Constants_C").getI());
}
}
使用枚举类型的优势为：
类型安全；

紧凑有效的数据定义；

运行效率高；

可以和程序其他部分完美交互；

泛型
在没有泛型之前，Java也提供了对Object的引用任意化的 操作，对Object引用进行向下转型及向上转型（通常向下转型会出现问题），但是某些强制类型转换不会被编译器捕捉，而在运行时出现异常，所以出现了泛型机制。

T代表一个类型的名称。
package genericity;

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) {
OverClass<Boolean> over1 = new OverClass<Boolean>();
OverClass<Float> over2 = new OverClass<Float>();
over1.setOver(true);
over2.setOver(67.9F);
System.out.println(over1.getOver());
System.out.println(over2.getOver());
}
}
使用泛型这种形式将不会发生ClassCastException异常，因为在编译器中就可以检查类型匹配是否正确。

定义泛型类时声明数组类型
package genericity;

public class ArrayClass<T> {
private T[] array;

public void setT(T[] array){
this.array = array;
}

public T[] getT(){
return array;
}

public static void main(String[] args) {
ArrayClass<String> a = new ArrayClass<String>();
String[] arr = {"num1", "num2", "num3", "num4"};
a.setT(arr);
for(int i = 0; i < a.getT().length; i++){
System.out.print(a.getT()[i] + " ");
}
}
}
可以在使用泛型机制时声明一个数组，但是不可以使用泛型来建立数组的实例。
常用的被泛型化的集合类：
ArrayList<E>、HashMap<K，V>，HashSet<E>，Vector<E>；

限制泛型可用类型

class 类名称<T extends anyClass>，其中anyClass可以是类或接口，但都必须使用extends关键字。

package genericity;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LimitClass<T extends List> {
LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
LimitClass<List> l3 = new LimitClass<List>();
}

使用类型通配符
泛型类名称<? extends List> a = null;

A<? extends List> a = null;

a = new A<ArrayList>();

a = new A<LinkedList>();

注意：使用通配符创建出来的集合对象，不能改变集合中的值。

定义为泛型的类和接口也可以被继承与实现，
package genericity;

public class ExtendClass<T1> {
class SubClass<T1, T2, T3> extends ExtendClass<T1>{}
}

package genericity;

public interface i<T1> {
class SubClass<T1, T2, T3> implements i<T1>{}
}

泛型总结：
泛型的类型参数只能是类类型，不能是简单基本类型，如A<int>这种方式定义是错误的；

泛型的类型参数可以是多个；

可以使用extends关键字限制泛型的类型；

可以使用通配符限制泛型的类型；