枚举

本质就是一个类/单例，里面有一组限定的对象。回忆单例（1、构造器私有；2、类内部创建一个对象；3、添加public static修饰符暴露该对象）。

jdk1.5后，通过关键字enum创建枚举类。枚举类默认提供私有构造方法，属性默认添加private final static修饰，也就是常量。

常见方法

• 1.toString(): 返回的是常量名（对象名），使用enum定义的类，可以继续重写该方法！

• 2.name():返回的是常量名（对象名） 【很少使用】

• 3.ordinal():返回常量的次序号，默认从0开始。

• 4.values():返回该枚举类的所有的常量对象，返回类型：当前枚举的数组类型，一个静态方法。

• 5.valueOf(String str):将字符串转换成当前的枚举类的对象，要求：该字符串必须为有效的枚举常量形式！否则报异常！

案例

package com.sire.source.base15.enumu;  
/*枚举类*/  
public class Test1 {  
    public static void main(String[] args){  
       /* Month a = Month.valueOf("c");// 获取枚举中的属性，如果没有回报错 
//        Month a = Month.a; 
        System.out.println(a); 
        // 循环打印所有属性 
        for(Month m: Month.values()){ 
            System.out.println(m); 
        } 
        System.out.println("属性名称："+a.name()); 
        System.out.println("属性序号："+a.ordinal()); 
        System.out.println(Month.b);*/  
       for(Stu s:Stu.values()){  
           System.out.println("编号："+s.ordinal()+"\t"+s);  
       }  
    }  
}  
enum Stu{  
    A("ha",23),B("xixi",36),C(),D(199);//调用构造  
    private String name;  
    private int age;  

    Stu(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
    Stu(int age) {  
        this.age = age;  
    }  
    Stu(){}  

    @Override  
    public String toString() {  
        return "Stu{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }  
}  
/*枚举类*/  
enum Month{  
    a,b,c,d;// 默认加public static final修饰。常量  
    Month() {// 构造方法默认修饰符为private  
    }  
}

效果：

枚举实现接口

规则：

• 1、枚举类可实现多个接口，但要求必须实现里面所有的抽象方法！

语法：

enum A implements 接口1，接口2{
    //抽象方法的实现
}

• 2、如果枚举类的常量可以继续重写抽象方法，语法：

enum A implements 接口1，接口2{
    常量名(参数【参数可以没有】){
        //抽象方法的实现或重写
    }
    //抽象方法的实现
}

• 3、枚举类不可以显式的通过extends继承其他类，因为已经默认继承了Enum

Idea按Ctrl+H：

案例

package com.sire.source.base15.enumu;  
/*枚举测试2：枚举实现接口*/  
public class Test2 {  
    public static void main(String[] args) {  
        for(User u:User.values()){  
            System.out.println(u.ordinal()+":"+u);  
        }  
        System.out.println("重写方法：");  
        User.A.show();  
        User.C.show();  
    }  
}  
enum User implements aa {  
    A(),B(230),C("sire",100){  
        @Override  
        public void show() {  
            System.out.println("嘿嘿");  
        }  
    };  

    private String name;  
    int age;  
    User() {}  
    User(int age) {  
        this.age = age;  
    }  
    User(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
    @Override  
    public String toString() {  
        return "User{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }  

    @Override  
    public void show() {  
        System.out.println("哈哈哈");  
    }  
}  
interface aa{  
    void show();  
}

效果