【02 Java 面向对象编程：5.5 枚举类】

最新推荐文章于 2024-10-06 20:16:20 发布

江桥诗

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量337

点赞数

分类专栏： Java SE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_50707328/article/details/123236288

版权

Java SE 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的枚举类型，包括其基本概念、定义方式、枚举类的方法如values()、toString()、ordinal()等，并展示了如何通过valueOf()方法转换字符串为枚举对象。此外，还探讨了枚举类如何实现接口以及重写抽象方法的两种方式，提供了具体的代码示例。

摘要由CSDN通过智能技术生成

文章目录

- - 5.5 枚举类

5.5 枚举类

5.5.1 基本概念

一年中的所有季节：春季、夏季、秋季、冬季。

所有的性别：男、女。
键盘上的所有方向按键：向上、向下、向左、向右。

在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做

枚举类型。

实例：编程实现所有方向的枚举

package demo04;

//编程实现所有方向的枚举：上下左右
public class Direction {
    private final String desc;      //常量

    //2.声明本类类型的引用指向本类类型的对象
    //方式二
    public static final Direction UP=new Direction("向上");
    public static final Direction DOWN=new Direction("向下");
    public static final Direction LEFT=new Direction("向左");
    public static final Direction LINGHT=new Direction("向右");

    //1.私有化构造方法
    private Direction(String desc) {
        this.desc=desc;
    }
    /*//通过构造方法对final修饰的成员变量进行赋值
    方式一
    public Direction(String desc) {
        this.desc = desc;
    }*/
    //通过公有的get方法使外部类可以访问本类的成员变量
    public String getDesc() {
        return desc;
    }
}

package demo04;

public class DirectionTest {
    public static void main(String[] args) {
        /*Direction d1=new Direction("向上");
        Direction d2=new Direction("向下");
        Direction d3=new Direction("向左");
        Direction d4=new Direction("向右");
        System.out.println("获取到的方向是："+d1.getDesc());
        System.out.println("获取到的方向是："+d2.getDesc());
        System.out.println("获取到的方向是："+d3.getDesc());
        System.out.println("获取到的方向是："+d4.getDesc());
        System.out.println("-------------------------------------");
        //可以无限制的new新对象
        System.out.println("获取到的方向是："+new Direction("向前").getDesc());*/

        Direction d1=Direction.UP;
        Direction d2=Direction.DOWN;
        Direction d3=Direction.LEFT;
        Direction d4=Direction.LINGHT;
        System.out.println("获取到的方向是："+d1.getDesc());
        System.out.println("获取到的方向是："+d2.getDesc());
        System.out.println("获取到的方向是："+d3.getDesc());
        System.out.println("获取到的方向是："+d4.getDesc());
    }
}

5.5.2 定义

使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java 5开始增加的一种引

用数据类型。
```
public enum  DirectionEnum {
    //2.声明本类类型的引用指向本类类型的对象
     UP("向上"),DOWN("向下"),LEFT("向左"),RINGHT("向右");
```

枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。

UP("向上"),DOWN("向下"),LEFT("向左"),RINGHT("向右");
//相当于
public static final Direction UP=new Direction("向上");
    public static final Direction DOWN=new Direction("向下");
    public static final Direction LEFT=new Direction("向左");
    public static final Direction LINGHT=new Direction("向右");

枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的。
```
 //1.私有化构造方法
    private DirectionEnum(String desc) {
        this.desc=desc;
```

整体代码解析

public enum  DirectionEnum {
    //2.声明本类类型的引用指向本类类型的对象
     UP("向上"),DOWN("向下"),LEFT("向左"),RINGHT("向右");
    
    private final String desc;      //常量

    //1.私有化构造方法
    private DirectionEnum(String desc) {
        this.desc=desc;
    }
    /*//通过构造方法对final修饰的成员变量进行赋值
    public Direction(String desc) {
        this.desc = desc;
    }*/
    //通过公有的get方法使外部类可以访问本类的成员变量
    public String getDesc() {
        return desc;
    }
}

public class DirectionTest {
    public static void main(String[] args) {
     
        DirectionEnum de = DirectionEnum.LEFT;
        System.out.println("获取到的方向是："+de.getDesc());
    }
}

5.5.3 Enum类的方法和概念

所有的枚举类都继承自java.lang.Enum类，常用方法如下：

方法	概念
static T[] values()	返回当前枚举类中的所有对象（隶属于类层级）
String toString()	返回当前枚举类对象的名称（隶属于对象层级）
int ordinal()	获取枚举对象在枚举类中的索引位置（隶属于对象层级）
static T valueOf(String str)	将参数指定的字符串名转为当前枚举类的对象（隶属于类层级）
int compareTo(E o)	比较两个枚举对象在定义时的顺序（隶属于对象层级）

static T[] values() ：返回当前枚举类中的所有对象，返回类型为数组（隶属于类层级）

//代码解析
//功能类
public enum  DirectionEnum {
    //2.声明本类类型的引用指向本类类型的对象
     UP("向上"),DOWN("向下"),LEFT("向左"),RINGHT("向右");}

//测试类
public class DirectionEnumTest {
    public static void main(String[] args) {
//1.获取DirectionEnum类型的所有对象      //values方法隶属于类层级，使用类名.的方式调用
        DirectionEnum[] arr=DirectionEnum.values();}

tring toString()：返回当前枚举类对象的名称（隶属于对象层级）

int ordinal()：获取枚举对象在枚举类中的索引位置（隶属于对象层级）

/编程实现枚举类的测试，调用从Enum类继承下来的方法
public class DirectionEnumTest {
    public static void main(String[] args) {

        //1.获取DirectionEnum类型的所有对象      //values方法隶属于类层级，使用类名.的方式调用
        DirectionEnum[] arr=DirectionEnum.values();
        //2.打印每个枚举对象在枚举类型的名称和索引位置
        for(int i=0;i<arr.length;i++) {
            System.out.println("获取到的名称是："+arr[i].toString());
            System.out.println("获取到的索引位置是："+arr[i].ordinal());
        }

static T valueOf(String str)：将参数指定的字符串名转为当前枚举类的对象（隶属于类层级）

//3.根据参数指定的字符串得到枚举类型的对象，将字符串转换为枚举对象
//        DirectionEnum de=DirectionEnum.valueOf("向下");   编译ok，运行发生IllegalArgumentException:非法参数异常
        DirectionEnum de=DirectionEnum.valueOf("DOWN");
//        System.out.println("转换出来的枚举对象名称是:"+de.toString());  //DOWN
        System.out.println("转换出来的枚举对象名称是:"+de);  //DOWN 当打印引用变量时,会自动调用toString()方法
        System.out.println("----------------------");

int compareTo(E o)：比较两个枚举对象在定义时的顺序（隶属于对象层级）

//4.使用获取的枚举对象与已有的枚举对象进行比较
        for(int i=0;i<arr.length;i++) {
            //UP:0  DOWN:1  LEFT:2  RIGHT:3
            //调用对象为1
            //所以与数组的比较顺序为:1 0 -1 -2
            System.out.println("调用对象与数组中的对象先后比较的顺序为:"+de.compareTo(arr[i]));
        }

5.5.4 Enum类实现接口的方式

枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个(方式一)，或者每个对象都重写(方式二)。

//接口类
package demo04;

public interface DirectionInterface {
    public abstract void show();
}

//功能类
package demo04;

public enum  DirectionEnum implements DirectionInterface{
    //2.声明本类类型的引用指向本类类型的对象
    //public static final Direction UP=new Direction("向上");
    //方式二:使用匿名内部类的方式调用并重写:
    //接口/父类类型 引用变量名=new 接口/父类类型() {"方法的重写"}
     UP("向上"){
        @Override
        public void show() {
            System.out.println("向上移动了一下");
        }
    },DOWN("向下") {
        @Override
        public void show() {
            System.out.println("向下移动了一下");

        }
    },LEFT("向左") {
        @Override
        public void show() {
            System.out.println("向左移动了一下");

        }
    },RINGHT("向右") {
        @Override
        public void show() {
            System.out.println("向右移动了一下");

        }
    };
    private final String desc;      //常量


    //1.私有化构造方法
    private DirectionEnum(String desc) {
        this.desc=desc;
    }
    /*//通过构造方法对final修饰的成员变量进行赋值
    public Direction(String desc) {
        this.desc = desc;
    }*/
    //通过公有的get方法使外部类可以访问本类的成员变量
    public String getDesc() {
        return desc;
    }

    /*  方式一
    @Override
    public void show() {
        System.out.println("可以实现接口的抽象方法的重写了");
    }*/
}

//测试类
package demo04;

//编程实现枚举类的测试，调用从Enum类继承下来的方法
public class DirectionEnumTest {
    public static void main(String[] args) {
        System.out.println("---------------------------------------------------");
        for(int i=0;i<arr.length;i++) {
            arr[i].show();
        }
    }
}

枚举类测试类源代码

package demo04;

//编程实现枚举类的测试，调用从Enum类继承下来的方法
public class DirectionEnumTest {
    public static void main(String[] args) {

        //1.获取DirectionEnum类型的所有对象      //values方法隶属于类层级，使用类名.的方式调用
        DirectionEnum[] arr=DirectionEnum.values();
        //2.打印每个枚举对象在枚举类型的名称和索引位置
        for(int i=0;i<arr.length;i++) {
            System.out.println("获取到的名称是："+arr[i].toString());
            System.out.println("获取到的索引位置是："+arr[i].ordinal());
        }

        //3.根据参数指定的字符串得到枚举类型的对象，将字符串转换为枚举对象
//        DirectionEnum de=DirectionEnum.valueOf("向下");   编译ok，运行发生IllegalArgumentException:非法参数异常
        DirectionEnum de=DirectionEnum.valueOf("DOWN");
//        System.out.println("转换出来的枚举对象名称是:"+de.toString());  //DOWN
        System.out.println("转换出来的枚举对象名称是:"+de);  //DOWN 当打印引用变量时,会自动调用toString()方法
        System.out.println("----------------------");

        //4.使用获取的枚举对象与已有的枚举对象进行比较
        for(int i=0;i<arr.length;i++) {
            //UP:0  DOWN:1  LEFT:2  RIGHT:3
            //调用对象为1
            //所以与数组的比较顺序为:1 0 -1 -2
            System.out.println("调用对象与数组中的对象先后比较的顺序为:"+de.compareTo(arr[i]));
        }
        System.out.println("---------------------------------------------------");
        for(int i=0;i<arr.length;i++) {
            arr[i].show();
        }
    }
}