疯狂java学习笔记1005---枚举类

 实例有限而且固定的类，在java里称为枚举类。

手动实现枚举类：

public class Season
{
    private final String name;
    private final String desc;
    public static final Season SPRING = new Season("春天","趁青踏青");
    public static final Season SUMMER = new Season("夏天","下日炎炎");
    public static final Season FALL = new Season("秋天","秋高气爽");
    public static final Season WINTER = new Season("冬天","围炉赏雪");
    public static Season getSeason(int seasonNum)
    {
        switch(seansonNum)
        {
            case 1:return SPRING;
            case 2:return SUMMER;
            case 3:return FALL;
            case 4:return WINTER;
            default: return null;
        }
    }
    //将构造器定义成private访问权限
    private Season(String name,String desc)
    {
        this.name = name;
        this.desc = desc;
    }
    //只为name 和 desc 提供getter方法
    public String getName()
    {
        return name;
    }
    public String getDesc()
    {
        return desc;
    }
}
class SeasonTest
{
    public SeasonTest(Season s)
    {
        System.out.println(s.getName()+",这真是一个"+ s.getDesc()+"的季节");
    }
    public static void main(String[] args)
    {
        //直接使用Season的FALl常量代表一个Season对象
        new SeasonTest(Season.FALL);
    }
}

枚举类入门：

/*
    枚举类继承的不是Object类而是Enum类
    非抽象的枚举类默认使用final修饰，抽象的由abstract修饰
    枚举类的构造器默认private
    枚举类的所有实例必须在枚举类的第一行显式列出，且默认public static final修饰
*/
enum SeasonEnum
{
    //在第一行列出4个枚举实例
    SPRING,SUMMER,FALL,WINTER;//如果使用实例，则使用SeasonEnum.SPRING
}
public class EnumTest
{
    public void judge(SeasonEnum s)
    {
        //switch语句里的表达式可以是枚举类
        switch(s)
        {
            case SPRING:System.out.println("春暖花开，正好踏青");    break;
            case SUMMER:System.out.println("夏日炎炎，适合游泳");    break;
            case FALL:System.out.println("秋高气爽，进补及时");  break;
            case WINTER:System.out.println("冬日雪飘，围炉赏雪");    break;
        }
    }
    public static void main(String[] args)
    {
        //所有枚举类都有一个values方法，返回该枚举类的所有实例
        for(SeasonEnum s : SeasonEnum.values())
        {
            System.out.println(s);
        }
        new EnumTest().judge(SeasonEnum.SPRING);
    }
}

 switch的扩展：

switch的控制表达式可以是任何枚举类型，当switch控制表达式使用枚举类型时，后面case表达式中的值直接使用枚举值的名字，无需添加枚举类做限定。

枚举类的方法，Field，构造器

 

enum Gender
{
    MALE,FEMALE;
    //定义一个public修饰的实例变量
    private String name;
    public void setName(String name)
    {
        switch(this)
        {
            case MALE:
            if(name.equals("男"))
            {
                this.name = name;
            }
            else
            {
                System.out.println("参数错误");
                return;
            }
            break;
            case FEMALE:
            if(name.equals("女"))
            {
                this.name = name;
            }
            else
            {
                System.out.println("参数错误");
                return;
            }
            break;
        }
    }
    public String getName()
    {
        return this.name;
    }
}
public class GenderTest
{
    public static void main(String[] args)
    {
        //通过Enum的valueOf方法来获取指定枚举类的枚举值
        Gender g = Enum.valueOf(Gender.class ,"FEMALE");

        g.setName("女");

        System.out.println(g + "代表："+ g.getName());

        g.setName("男");//提示参数错误

        System.out.println(g + "代表："+ g.getName());
    }
}

因为我们将所有的Field都使用final修饰，所以必须在构造器中为这些Field指定初始值，为枚举类显示定义带参数的构造器：

 

public enum Gender
{
    MALE("男"),FEMALE("女");
    private final String name;
    //枚举类的构造器只能使用private修饰
    private Gender(String name)
    {
            this.name = name;
    }
    public String getName()
    {
        return this.name;
    }
}

上面的编辑代码等于：

 

public static final Gender MALE = new Gender("男");
public static final Gender MALE = new Gender("女");

 

本文出自 “java程序猿的博客” 博客，转载请与作者联系！