java_枚举类型

枚举类型的由来：从前设置常量，常常设置在接口中，为了常量定义更加整洁，枚举类型被广泛使用；

A

枚举类型的使用:

定义一个枚举类型并用switch语句获取枚举类型的值；

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

/*interface ENUM{
	public final static int A_int=1;
	public final static int B_int=2;
	public final static int C_int=3;
}*/
public class Enum{
	enum INT{
		A_int,
		B_int,
		C_int
	}
	
	public static void doit(INT c){
		switch(c){
		case A_int:System.out.println("1");
					break;
		case B_int:System.out.println("2");
					break;
		case C_int:System.out.println("3");
					break;
		}	
	}

	public static void main(String[] args) {	
		Enum enum1=new Enum();
		enum1.doit(INT.A_int);
	}


}

枚举类型的常用方法：

1.

values（）    ：枚举类型成员以数组形式返回；

public class Enum{
	enum INT{
		A_int,
		B_int,
		C_int
	}
	public static void main(String[] args) {	
		for(int i = 0;i < INT.values().length;i ++){
			System.out.println("枚举常量类型的成员"+INT.values()[i]);
		}
	}
}

运行截图：

2.

valueof()        :可以将普通字符串转化成枚举实例；

如：A.valueof("abc");

3.

compareTo()   :比较两个枚举对象在定义时的顺序；

如：A_int.comareTo(B_int)         //比较A_int和B_int的顺序

实践：项目中创建一个类，在该类中使用枚举类型中的valueOf（）和compareTo（）

public class Enum{
	enum INT{
		A_int,
		B_int,
		C_int
	}
	public static void compare(INT Int){
		for(int i = 0 ; i < Int.values().length ; i ++){
			System.out.println(Int + "与" + INT.values()[i] + "比较结果为" + 
							   Int.compareTo(INT.values()[i]));
		}
	}
	public static void main(String[] args) {	
					compare(INT.valueOf("A_int"));	
	}
}

截图结果：

观察可知：compareTo返回值为两个比较的数的相对位置。

4.

ordinal()    :获取某位置的索引值

public class Enum{
	enum INT{
		A_int,
		B_int,
		C_int,
		D_int
	}
	public static void main(String[] args) {	
					for(int i = 0 ; i < INT.values().length ; i++){
						System.out.println(INT.values()[i] + "的索引值" + INT.values()[i].ordinal());
					}
	}
}

截图：

B

枚举类型的构造方法：

规定：枚举类型中构造方法必须是private修饰符修饰。语法如下：

public class Enum{
	enum INT{
		A_int("我是枚举变量0"),
		B_int("我是枚举变量1"),
		C_int("我是枚举变量2"),
		D_int(3),
		E_int;
		private int i = 4;
		private String description;
		private INT(){							//空的构造
		}
		private INT(String description) {		//String构造
			this.description = description;
		}
		private INT(int i){				//int构造				
			this.i = this.i + i;
		}
		public String getdescription(){	//返回的desription
			return description;
		}
		public int getI(){	//返回i
			return i;
		}	
	}
	public static void main(String[] args) {	
					for(int i = 0 ; i < INT.values().length ; i++){
						System.out.println(INT.values()[i] + "调用getDescription（）的方法为："
											+ INT.values()[i].getdescription());
					}
					System.out.println(INT.valueOf("D_int") + "调用getI方法为" 
											+ INT.valueOf("D_int").getI());
	}
}

从枚举类型中可以看出，无论是有参还是无参的构造函数，权限只能是private；

在实现构造函数的过程中，程序根据valueof（）中给出的类型和枚举类型中的预先定义自动构造，

然后实现相应的函数的内容，这一点我们在description和i的变化可以看出来；

interface d{
	public String getDescripion();
	public int getI();	//返回i
}
public class Enum {
	enum INT implements d{
		A_int{			//可以在枚举类型中设置内部方法
			public String getDescripion(){
				return "我是枚举变量1";
			}
			public int getI(){	//返回i
				return i;
			}
		},
		B_int{
			public String getDescripion(){
				return "我是枚举变量2";
			}
			public int getI(){	//返回i
				return i;
			}
		},
		C_int{
			public String getDescripion(){
				return "我是枚举变量3";
			}
			public int getI(){	//返回i
				return i;
			}
		};
		private static  int i = 4;
	}
	public static void main(String[] args) {	
					for(int i = 0 ; i < INT.values().length ; i++){
						System.out.println(INT.values()[i] + "调用getDescription（）的方法为："
											+ INT.values()[i].getDescripion());
						System.out.println(INT.values()[i] + "调用getI方法为" 
								+ INT.values()[i].getI());
					}
					
	}
}

枚举类型的优点：

类型安全

紧凑有效的定义

和程序完美交互

运行效率高

这里的优点都是摘自书上的内容，有比较才有优点，很不理解，这个疑问暂且搁置。