目录
1、声明
2、代码
声明(性别)
switch(红绿灯)
3、常用方法
values() 方法
compareTo() ,valueOf()方法
ordinal（）方法
4、枚举的构造方法
5、枚举实现接口
无参
1个参
2个参
String
6、自定义枚举类
7、覆盖基类方法
1、声明
是一个特定类型的类。所有枚举都是Java中的新类的隐式子类
不能手工进行子类定义
声明：
- 在枚举中需写全该枚举类型变量的每一个值，这些值称为枚举元素。
- 命名规范：枚举名称，首字母大写，驼峰标识；其枚举值，全大写，下划线分割；
- 任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。
使用：
- 枚举名 变量名=枚举名.枚举值 [使用枚举名.枚举值取得每一个枚举值]
- 枚举名 变量名;
- 变量名=枚举名.枚举值
2、代码
-
声明(性别)
public enum Gender {
MALE,
FEMALE
}
public class GenderTest {
public static void main(String[] args) {
Gender g = null; //定义枚举变量
g = ;//给枚举赋//只能获取从已经定义好的枚举列表中枚举值
(g);
}
}
-
switch(红绿灯)
public enum Signal {
RED, YELLOW, GREEN
}
public class TrafficLight {
Signal color = ;
public void change() {
switch (color) {
case RED: {
color = ;
break;
}
case GREEN: {
color = ;
break;
}
case YELLOW: {
color = ;
break;
}
}
}
public static void main(String[] args) {
TrafficLight light = new TrafficLight();
//初始化信号灯颜色
= ;
//改变红绿灯
();
();
}
}
3、常用方法
-
values() 方法
通过调用枚举类型的 values() 方法可以将枚举的所有成员以数组形式返回，也可以通过该方法获取枚举类型的成员。
public class SignalValuesTest {
public static void main(String[] args) {
//value() 获取定义枚举值列表，以数组的形式返回
Signal[] values=();
for (int i = 0; i < ; i++) {
(values[i]);
}
}
}
-
compareTo() ,valueOf()方法
调用 valueOf() 方法获取枚举的一个成员，再调用 compareTo() 方法进行比较，并输出结果
Enum默认实现了接口。
枚举类型 变量=枚举类型.valueOf("枚举值")
- 如果指定的数与参数相等返回0。
- 如果指定的数小于参数返回 -1。
- 如果指定的数大于参数返回 1。
public enum Gender {
AAA,
MALE,
FEMALE
}
public class GenderTestForString {
public static void main(String[] args) {
//把字符串转成枚举类型
//把字符串转成对象？可以
//Gender g=("MALE1");//非法参数异常
Gender g = ("MALE");
(g);
for (Gender gender : ()) {
int result = (gender);
("g=" + g + ",gender=" + gender + ",result=" + result);
}
}
}
/*
MALE
g=MALE,gender=AAA,result=1
g=MALE,gender=MALE,result=0
g=MALE,gender=FEMALE,result=-1
*/
-
ordinal（）方法
可以获取一个成员在枚举中的索引位置。下 面的示例创建一个包含 3 个成员的枚举类型 Signal，然后调用 ordinal() 方法输出 成员及对应索引位置
Signal[] values=();
for(Signal s:values){
("索引："+()+"\t值："+s);
}
/*
索引：0 值：RED
索引：1 值：YELLOW
索引：2 值：GREEN
*/
4、枚举的构造方法
-
枚举相当于一个类，它也是有构造方法的。如果显式地写出了枚举的构造方法，那么就必须在创造枚举对象时相应地显式引用，否则就会出错。这也是 Java的运行机制一。
-
枚举中的每一个元素，都相当于一个对象的引用，这个元素可以有方法和字段
-
枚举类被初始化时调用构造方法，每个构造方法将以成员声明顺序被调用:有几个枚举值就按顺序依次调用构造方法创建几个对象
-
不能有public的构造方法，保证客户代码没有办法新建一个enum的实例。
-
和在普通类里面定义变量一样定义其它任何类型的非枚举变量，这些变量可以用任何你想用的修饰符。
public enum Color {
//定义枚举列表（枚举的实例对象引用），如果定义了构造方法，显示调用构造方法
//定义枚举列表必须要放在最前面，每个枚举值之间用逗号隔开，最后一个用分号
RED(), GREEN("绿色"){
public String getColorName(){
return ();
}
}, YELLOW("黄色"){
public String getColorName(){
return ();
}
}, BLUE("蓝色"){
public String getColorName(){
return ();
}
};
private String name;
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
//private构造方法 只能在类的内部被使用
Color() {
("无参构造方法被调用");
}
//从语法上不可以定义public构造方法，不希望枚举由其他人创建对象，只有自己内部来创建对象，可以很好地控制枚举列表
private Color(String name) {
= name;
("有参被调用name=" + name);
}
public static void main(String[] args) {
Color blue = ;
(blue);
();
("---------------------");
for (Color c : ()) (c);
("=====================");
//String str="GREEN"和是两种类型
String str = "GREEN";
//转换成枚举
Color c = (str);
(());
("=====================");
String a = "123";
String b = "456";
//a+b进行算术运算
(a + b);//字符串拼接
((a) + (b));
("=====================");
(());
(());
}
}
/*
无参构造方法被调用
有参被调用name=绿色
有参被调用name=黄色
有参被调用name=蓝色
BLUE
蓝色
---------------------
RED
GREEN
YELLOW
BLUE
=====================
绿色
=====================
123456
579
=====================
绿色
黄色
*/
5、枚举实现接口
-
所有的枚举都继承自类。由于Java 不支持多继承，所以枚举对 象不能再继承其他类
-
枚举可以实现接口,当一个枚举实现了一个接口之后，枚举中的每一个对象都要分别实现接口中的所有抽象方法
-
除了实现抽象接口，枚举自己内部也可以定义抽象方法。一旦枚举自己也定义了 抽象方法，那么枚举中的每个对象都要分别的实现这些方法，不然会报错。
-
代码构造 构造方法前的private可以省略不写，默认private
无参
public interface A {
int ma();
}
static void test01(){
//创建实现A接口的匿名类对象
A a=new A() {
@Override
public int ma() {
return 5;
}
};
//方法体只有一行代码可省略大括号，返回值不用return
A b=()->5;
A c=()->{
return 5;
};
//标准写法
A d=()->{
//("ni");
return 0;
};
(());
(());
(());
(());
("=================");
}
/*
5
5
5
ni
0
*/
1个参
public interface B {
int ma(int x);
}
static void test02(){
//创建实现B接口的匿名类对象
// B b=new B() {
// @Override
// public int ma(int x) {
// return 2*x;
// }
// };
// //标准写法
// B b=x->2*x;
B b=(int x)->{return 2*x;};
((10));
}
2个参
public interface C {
int ma(int x,int y);
}
static void test03(){
// C c=new C() {
// @Override
// public int ma(int x, int y) {
// return x+y;
// }
// };
// C c=(int x,int y)->{
// return x+y;
// };
C c=(x,y)->x+y;
((10,20));
}
String
@FunctionalInterface
public interface D {
void String(String str);
}
static void test04(){
// D d=new D() {
// @Override
// public void String(String str) {
// (str);
// }
// };
// D d=(String str)->{
// (str);
// };
D d=str-> (str);
("qwer");
}
}
6、自定义枚举类
- 所有枚举值都是public , static , final的
- 步骤如下:
-
声明枚举类型,在枚举值列表最后一列加分号,注意枚举值必须写在最前面.
-
在枚举值列表后加括号,括号里边写实参值,是传给构造方法用的
-
写枚举的私有的构造方法,形参类型要跟枚举值的实参列表类型一致
-
在枚举值后面写私有的成员变量,一般情况下应该和构造方法的形参保持一致 ，写成员变量的getter和setter方法
-
enum WeekDay{
Mon("Monday"),
Tue("Tuesday"),
Wed("Wednesday"),
Thu("Thursday"),
Fri("Fr iday"),
Sat("Saturday"),
Sun("Sunday");//优先列举枚举值
//以上是枚举的成员，必须先定义，而且使用分号结束
private String day;//成员属性.定义其它任何类型的非枚举变量
private WeekDay(String day){//构造方法，在列举枚举值时调用
=day;
}
//写成员变量的getter和setter方法
public String getDay(){
return day;
}
//普通方法
public static void printDay(int i){//自定义方法
switch(i) {
case 1:
();
break;
case 2:
();
break;
case 3:
();
break;
case 4:
();
break;
case 5:
();
break;
case 6:
();
break;
case 7:
();
break;
default:
("wrong number!");
}
}
public static void main(String[] args) {
for(WeekDay day:()){
(day+"====>"+());
}
(5);
}
}
/*
Mon====>Monday
Tue====>Tuesday
Wed====>Wednesday
Thu====>Thursday
Fri====>Friday
Sat====>Saturday
Sun====>Sunday
Fri
*/
7、覆盖基类方法
public class Test{
public enum Color{
RED("红色",1),
GREEN("绿色",2),
WHITE("白色",3),
YELLOW("黄色",4);
//成员变量
private String name;
private int index;
//构造方法
private Color(String name,int index){
=name;
=index;
}
//覆盖方法
@Override
public String toString(){
return +"-"+;
}
}
public static void main(String[] args){
(()); //输出：1-红色
}
}