1、枚举
枚举是一种数据类型，是一系列具有名称的常量的集合。
1.1 使用枚举类型设置常量
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);
}
}
1.2 深入了解枚举类型
枚举类型的对象继承与java.lang.Enum类，所以有以下的常用的方法：
| 方法 | 功能描述 | 使用方法 |
|---|---|---|
| values() | 将枚举类型成员以数组形式返回 | 枚举类型名称.values() |
| valueOf() | 实现将普通字符串转换为枚举类型 | 枚举类型名称.valueOf("abc") |
| compareTo() | 比较两个枚举对象在定义时的顺序 | 枚举对象.compareTo() |
| ordinal() | 得到枚举成员的位置索引 | 枚举对象.ordinal() |
直接用代码表示：
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修饰符或者是默认修饰符。
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());
}
}
}
2、范型
范型机制用法如下，这里T代表着一个类型的名称。：
类名<T>
2.1 定义范型类
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
使用范型类型定义的类再声明该类对象时可以根据不同的需求指定<T>真正的类型。这种形式可以避免ClassCastException异常。
1.2 范型的常规用法
声明多个类型
在定义范型类时，可以声明多个类型，语法如下：
mutiOverClass<T1,T2>
定义范型类时声明数组类型
定义范型类时也可以声明数组类型：
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
集合类声明容器的元素
通过在集合类中应用范型可以使集合类中的元素类型保证唯一性。
package Enum;
import java.util.Map;
import java.util.HashMap;
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){
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
其实，上面这种方法纯属多余，因为在JAVA中，这些集合框架都已经被范型化了，可以在主方法中直接使用public Map<K,V> m = new HashMap<K,V>()；来创建实例，下表列举了常用的被范型化的集合类：
| 集合类 | 范型定义 |
|---|---|
| ArrayList | ArrayList<E> |
| HashMap | HashMap<K,V> |
| HashSet | HashSet<E> |
| Vector | Vector<E> |
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容器的值:二
