Java基础学习——Java网络编程（三）自定义枚举类、枚举类的常用方法、枚举类实现接口、枚举类的实际应用

一、什么是枚举

枚举法：一枚一枚的列举出来，列举的元素是有限的、确定的。

例如：星期（一、二、三、四、五、六、日）、性别（男、女）、季节（春、夏、秋、冬）

在Java中的关键字为enum

二、枚举类的编写

1.自定义一个Season枚举类（JDK1.5之前，现在基本不使用）

public class Season {
    //属性，由于这个属性例如赋值为“春天”--“春暖花开”，那么这一组属性都是不能更改的，所以需要加上final修饰符
    private final String seasonName;
    private final String seasonDesc;

    /*final必须初始化，但是使用=初始化，只能定义一个值，所以需要利用构造器给属性赋值。
    并且这个构造器只能在类的内部调用，不能给外部使用，所以加上private修饰符。
     */
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    /*定义枚举类的 有限的，确定的对象
      对于这个创建的对象，要给外界直接调用，所以public static修饰
      并且这个对象其实相当于这个类的一个属性了，这个属性不能被更改，加上final修饰，常量名使用大写字母。
     */
    public static final Season SPRING=new Season("春天","春暖花开");
    public static final Season SUMMER=new Season("夏天","烈日炎炎");
    public static final Season AUTUMN=new Season("秋天","硕果累累");
    public static final Season WINNER=new Season("冬天","冰天雪地");

    //对于seasonName，seasonDesc属性，不可以更改，所以只提供get方法
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    //提供打印的toString方法


    @Override
    public String toString() {
        return "Season{" +
                "季节：'" + seasonName + '\'' +
                ", 描述：'" + seasonDesc + '\'' +
                '}';
    }
}

调用枚举里的对象

public class Test {
    public static void main(String[] args) {
        //使用自定义的枚举类Season
        //调用Season类的SUMMER属性，可以看到返回的是一个Season类的对象。
        Season summer =Season.SUMMER;
        System.out.println(summer/*.toString()*/);
        System.out.println(summer.getSeasonDesc());
    }
}

运行结果如下：

2.使用Enum关键字创建枚举类（JDK1.5之后提供）

对上面的代码进行修改，枚举类中的对象必须放在枚举类的最上面，并且由逗号隔开，分号结尾。

public enum Season {
    //这里enum枚举类里面的对象一定是具有public static final的特点，且是Season类的对象，所以这部分代码可以去掉
    SPRING("春天","春暖花开"),
    SUMMER("夏天","烈日炎炎"),
    AUTUMN("秋天","硕果累累"),
    WINNER("冬天","冰天雪地");
    
    
    //属性，由于这个属性例如赋值为“春天”--“春暖花开”，那么这一组属性都是不能更改的，所以需要加上final修饰符
    private final String seasonName;
    ···
    ···

利用下面的代码可以看到enum 定义的枚举类的父类是java.lang.Enum，可以继承该类的所有方法。而我们自定义的class枚举类父类是Object。

System.out.println(Season.class.getSuperclass().getName());

3.按照源码的编写方式修改自定义的enum枚举类

源码里的枚举类，例如下面这个，可以看到非常简单，只有枚举类的对象

那么对于我们上面自己编写的枚举类，如果没有提供属性seasonName和seasonDesc，那么也就不用提供构造器给对象赋值，也不用利用toString方法打印，这些代码都可以删除，只剩下对象名。修改后如下

public enum Season {
    //这是一个没有提供属性的枚举类，那么对应的赋值，构造器，toString()、get()等方法都不用写
    //包括括号也可以省略
    SPRING,
    SUMMER,
    AUTUMN,
    WINNER;
}

三、枚举类的常用方法

public class Test {
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        //常用方法
        //1.toString()方法：获取对象的名字
        System.out.println(autumn/*.toString()*/);

        System.out.println("----------------");
        //2.values()：获取枚举类里面的对象的数组
        Season[] values = Season.values();
        //增强for循环输出数组元素
        for (Season s:values){
            System.out.println(s);
        }
        System.out.println("----------------");
        //3.valueOf()：已知对象名，获取这个对象，返回的是Season类的对象
        Season spring = Season.valueOf("SPRING");   //对象名必须传正确，否则会抛异常
        System.out.println(spring);
    }
}

四、枚举类实现接口

1.先自定义一个接口

public interface MyInterface {
    //随便定义一个show方法
    void show();
}

2.让枚举类实现这个接口

如果枚举类实现了接口，那么就要重写接口里的方法，但是如果直接重写show()方法， 此时只有一个show()方法，会导致无论调用枚举类的哪一个对象，调用的都是同一个show()方法。这种写法代码灵活性很差。

枚举类中提供了分别重写实现接口的方法的方式：

public enum Season implements MyInterface{
    SPRING{//先打花括号，再输入show。
        @Override
        public void show() {
            System.out.println("春天");

        }
    },
    SUMMER{
        @Override
        public void show() {
            System.out.println("夏天");
        }
    },
    AUTUMN{
        @Override
        public void show() {
            System.out.println("秋天");
        }
    },
    WINNER{
        @Override
        public void show() {
            System.out.println("冬天");
        }
    };
}

此时再调用枚举类的对象的show方法，就可以实现调用对象的不同，运行的方法也不同。

public class Test{
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        autumn.show();
        Season winner = Season.WINNER;
        winner.show();
    }
}

 五、枚举类的实际应用

1.将类里面的一个有限的确定的属性写为枚举类

创建性别的枚举类

public enum Sex {
    男,
    女;
}

创建Person类，将枚举类作为它的一个属性

public class Person {
    private String name;
    private int age;
    private Sex sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Sex getSex() {
        return sex;
    }

    public void setSex(Sex sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

创建Person类的对象，并赋值

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("小明");
        p.setAge(20);
        p.setSex(Sex.男);

        System.out.println(p);
    }
}

 运行结果

2.枚举类和switch循环结合 

switch的()内可以传int、short、byte、char、string、枚举类型

public class Test {
    public static void main(String[] args) {
        Sex sex = Sex.男;
        //switch的()内可以传int、short、byte、char、string、枚举类型
        switch (sex){
            case 男:
                System.out.println("是男孩");
                break;
            case 女:
                System.out.println("是女孩");
                break;
        }
    }
}

运行结果