枚举类的两种定义方式及练习
- 大纲：
枚举类的使用
1.枚举类的理解：
枚举类型本质上也是一种类，只不过是这个类的对象是有限的，固定的几个，不能让用户随意创建。
2.举例：
- 星期：Monday（星期一）......Sunday（星期天）
- 性别：Man(男)、Woman（女）
- 月份：January（1月）......December(12月)
- 季节：Spring（春天）......Winter（冬天）
- 三原色：red（红色）、green（绿色）、blue（蓝色）
- 支付方式：Cash（现金）、WeChatPay(微信)、Alipay(支付宝)、BankCard(银行)、CreditCard（信用卡）
- 就职状态：Busy(忙碌)、Free(空闲)、Vocation(休假)、Dimission(离职)
- 订单状态：Nonpayment（未付款）、Paid(已付款)、Fulfilled（已配货）、Delivered(已发货)、Checked(已确认收货)、Return(退货)、Exchange(换货)、Cancel(取消)
- 线程状态：创建、就绪、运行、阻塞、死亡
3.开发中的建议：
开发中，如果针对于某个类，其实例是确定个数的。则推荐将此类声明为枚举类。
如果枚举类的实例只有一个，则可以看做是单例的实现方式。
4.JDK5.0之前如何自定义枚举类（了解）
见代码
5.JDK5.0中使用enum定义枚举类
见代码
6.Enum中的常用方法：
6.1 使用enum关键字定义的枚举类，默认其父类是java.lang.Enum类
使用enum关键字定义的枚举类，不要显示的去定义其父类，否则报错。
6.2 熟悉Enum类中常用的方法
String toString():默认返回的是常量名（对象名），可以继续手动重写该方法！
（关注）static 枚举类型[] values():返回枚举类型的对象数组。该方法可以很方便的遍历所有的枚举值，是一个静态方法
（关注）static 枚举类型 valueOf(String name):可以把一个字符串转为对应的枚举对象。要求字符串必须是枚举类对象的"名字"。如不是，会有运行时异常，IllegalArgumentException。
String name():得到当前枚举常量的名称。建议优先使用toString()。
int ordinal():返回当前枚举常量的次序号，默认从0开始
7.枚举类实现接口的操作
情况1：枚举类实现接口，在枚举类中重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时，执行的是同一个方法。
情况2：让枚举类的每一个对象去重写接口方法。当通过不同的枚举类对象调用此方法时，执行的是不同的实现方法。
-
枚举类型本质上也是一种类，只不过是这个类的对象是有限的，固定的几个，不能让用户随意创建。
-
枚举类的例子举不胜举：
- 星期：Monday（星期一）…Sunday（星期天）
- 性别：Man(男)、Woman（女）
- 月份：January（1月）…December(12月)
- 季节：Spring（春天）…Winter（冬天）
- 三原色：red（红色）、green（绿色）、blue（蓝色）
- 支付方式：Cash（现金）、WeChatPay(微信)、Alipay(支付宝)、BankCard(银行)、CreditCard（信用卡）
- 就职状态：Busy(忙碌)、Free(空闲)、Vocation(休假)、Dimission(离职)
- 订单状态：Nonpayment（未付款）、Paid(已付款)、Fulfilled（已配货）、Delivered(已发货)、Checked(已确认收货)、Return(退货)、Exchange(换货)、Cancel(取消)
- 线程状态：创建、就绪、运行、阻塞、死亡
-
若枚举只有一个对象，则可以作为一种单例模式的实现方式。
-
枚举类的实现：
-
在jdk5.0之前，需要程序员自定义枚举类型。
私有化类的构造器，保证不能在类的外部创建其对象在类的内部创建枚举类的实例。声明为：
public static final,对外暴露这些常量对象对象如果有
实例变量，应该声明为private final(建议，不是必须)，并在构造器中初始化
package oop.demo14_enum; public class SeasonTest { public static void main(String[] args) { //Season.SPRING; System.out.println(Season.SPRING); System.out.println(Season.SUMMER); System.out.println(Season.AUTUMN); System.out.println(Season.WINTER); System.out.println(Season.WINTER.getSeasonName()); System.out.println(Season.WINTER.getSeasonDesc()); } } //jdk5.0之前定义枚举类的方式 class Season{ //2.声明当前类的对象的实例变量,需要使用private final修饰 private final String seasonName;//seasonName季节的名称 private final String seasonDesc;//seasonDese季节的描述 //1.私有化类的构造器 private Season(String seasonName,String seasonDesc) { this.seasonName = seasonName; this.seasonDesc = seasonDesc; } //3.提供实例变量的get方法 public String getSeasonName() { return seasonName; } public String getSeasonDesc() { return seasonDesc; } //4.创建当前类的的实例，需要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 WINTER = new Season("冬天","白雪皑皑"); @Override public String toString() { return "Season{" + "seasonName='" + seasonName + '\'' + ", seasonDesc='" + seasonDesc + '\'' + '}'; } }输出:
- 在jdk5.0之后，java支持
enum关键字来快速定义枚举类型。
-
public class SeasonTest1 {
public static void main(String[] args) {
System.out.println(Season1.SPRING.getClass());//输出class oop.demo14_enum.Season1 获取当前所属的类
System.out.println(Season1.SPRING.getClass().getSuperclass());//输出class java.lang.Enum 获取当前所属的类的父类
System.out.println(Season1.SPRING.getClass().getSuperclass().getSuperclass());//输出class java.lang.Object
}
}
//jdk5.0中使用enum关键字定义枚举类
enum Season1 { //默认的父类Enum.java
//1.必须在枚举类的开头声明多个对象。对象之间使用','隔开
SPRING ("春天","春暖花开"),
SUMMER ("夏天","夏日炎炎"),
AUTUMN ("秋天","秋分瑟瑟"),
WINTER ("冬天","白雪皑皑");
//2.声明当前类的对象的实例变量,需要使用private final修饰
private final String seasonName;//seasonName季节的名称
private final String seasonDesc;//seasonDesc季节的描述
//3.私有化类的构造器
private Season1(String seasonName,String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.提供实例变量的get方法
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
}
输出：
-
Enum中的常用方法及枚举类实现接口：
枚举类实现接口情况一：在枚举类中重写接口中的抽象方法，当通过不同的枚举类对象调用此方法时，执行的是同一个方法。
package oop.demo14_enum;
public class SeasonTest1 {
public static void main(String[] args) {
// System.out.println(Season1.SPRING.getClass());//输出class oop.demo14_enum.Season1 获取当前所属的类
// System.out.println(Season1.SPRING.getClass().getSuperclass());//输出class java.lang.Enum 获取当前所属的类的父类
// System.out.println(Season1.SPRING.getClass().getSuperclass().getSuperclass());//输出class java.lang.Object
//测试方法
//1.toString()
System.out.println(Season1.SPRING);//输出SPRING，也可以后面重写toString,输出的就是Season1{seasonName='春天', seasonDesc='春暖花开'}
System.out.println(Season1.SUMMER);//输出SUMMER
System.out.println("---------------------------");
//2.name
System.out.println(Season1.SPRING.name());//输出SPRING
System.out.println("---------------------------");
//3.values()
Season1[] values = Season1.values();//Season1.values();然后Alt+Enter 其实就是把枚举类的所有对象都放在了前面的数组里面
for (int i = 0; i < values.length; i++) {
System.out.println(values[i]);
/*
输出：
Season1{seasonName='春天', seasonDesc='春暖花开'}
Season1{seasonName='夏天', seasonDesc='夏日炎炎'}
Season1{seasonName='秋天', seasonDesc='秋分瑟瑟'}
Season1{seasonName='冬天', seasonDesc='白雪皑皑'}
*/
}
System.out.println("---------------------------");
//4.valueOf(String objName):返回当前枚举类中名称为objName的枚举类对象。
//如果枚举类中不存在objName名称的对象，则报错。
String objName = "WINTER";
Season1 season1 = Season1.valueOf(objName);
System.out.println(season1);//输出：Season1{seasonName='冬天', seasonDesc='白雪皑皑'}
System.out.println("---------------------------");
//5.ordinal()
System.out.println(Season1.AUTUMN.ordinal());//输出2，像数组下标
System.out.println("---------------------------");
//通过枚举类的对象，调用重写接口中的方法
Season1.SUMMER.show();//输出：这是一个季节
}
}
interface Info{
void show();
}
//jdk5.0中使用enum关键字定义枚举类
enum Season1 implements Info{ //默认的父类Enum.java
//1.必须在枚举类的开头声明多个对象。对象之间使用','隔开
SPRING ("春天","春暖花开"),
SUMMER ("夏天","夏日炎炎"),
AUTUMN ("秋天","秋分瑟瑟"),
WINTER ("冬天","白雪皑皑");
//2.声明当前类的对象的实例变量,需要使用private final修饰
private final String seasonName;//seasonName季节的名称
private final String seasonDesc;//seasonDesc季节的描述
//3.私有化类的构造器
private Season1(String seasonName,String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.提供实例变量的get方法
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
@Override
public String toString() {
return "Season1{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
@Override
public void show() {
System.out.println("这是一个季节");
}
}
输出：
情况2：让枚举类的每一个对象去重写接口方法。当通过不同的枚举类对象调用此方法时，执行的是不同的实现方法。
package oop.demo14_enum;
public class SeasonTest2 {
public static void main(String[] args) {
Season2[] values = Season2.values();
for (int i = 0; i < values.length; i++) {
values[i].show();
}
}
}
interface Info1{
void show();
}
//jdk5.0中使用enum关键字定义枚举类
enum Season2 implements Info1 { //默认的父类Enum.java
//1.必须在枚举类的开头声明多个对象。对象之间使用','隔开
SPRING("春天", "春暖花开"){
@Override
public void show() {
System.out.println("这是春天");
}
},
SUMMER("夏天", "夏日炎炎"){
@Override
public void show() {
System.out.println("这是夏天");
}
},
AUTUMN("秋天", "秋分瑟瑟"){
@Override
public void show() {
System.out.println("这是秋天");
}
},
WINTER("冬天", "白雪皑皑"){
@Override
public void show() {
System.out.println("这是冬天");
}
};
//2.声明当前类的对象的实例变量,需要使用private final修饰
private final String seasonName;//seasonName季节的名称
private final String seasonDesc;//seasonDesc季节的描述
//3.私有化类的构造器
private Season2(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.提供实例变量的get方法
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
@Override
public String toString() {
return "Season2{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
输出：
练习1：
package oop.demo14_enum.exercises;
public class Employee { //Employee:员工
private String name;
private int age;
private Status status;
//get,set方法
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 Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
//无参构造器
public Employee() {
}
//有参构造器
public Employee(String name, int age, Status status) {
this.name = name;
this.age = age;
this.status = status;
}
//toString
@Override
public String toString() {
return "Employee{" +
"员工姓名是：'" + name + '\'' +
", 年龄是" + age +
", 状态是" + status +
'}';
}
}
package oop.demo14_enum.exercises;
//定义公司中员工的状态
public enum Status { //Status:状态
Busy,Free,Vocation,Dimission;
}
package oop.demo14_enum.exercises;
public class EmployeeTest {
public static void main(String[] args) {
Employee e1 = new Employee("冰默",21,Status.Free);
System.out.println(e1);
}
}
输出：
练习2：
案例：使用枚举类实现单例模式
package oop.demo14_enum.exercises02;
public class BankTest1 {
public static void main(String[] args) {
//Bank1.instance = null;
System.out.println(GirlFriend.小美);//输出：小美
}
}
//jdk5.0之前使用枚举类定义单例模式
class Bank1{
//私有的无参构造器
private Bank1() {
}
public static final Bank1 instance = new Bank1();//instance:实例
//不用方法调了，直接用类调用，所以就不用下面的方法了
// public static Bank1 getInstance() {
// return instance;
// }
}
//jdk5.0使用enum关键字定义枚举类的方式定义单例模式
enum Bank2{
PBC;//(中国人民银行)
}
enum GirlFriend{
小美(18);
private final int age;
//私有有参构造
private GirlFriend(int age) {
this.age = age;
}
}
练习3：
案例：颜色枚举类Color（使用enum声明）
1.声明颜色枚举类：7个常量对象，RED,ORANGE,YELLOW,GREEN,CYAN,BLUE,PURPLE;
2.在测试类中，使用枚举类，获取绿色对象，并打印对象。
package oop.demo14_enum.exercise03;
public enum Color {
RED,ORANGE,YELLOW,GREEN,CYAN,BLUE,PURPLE;
}
练习3拓展：
案例3拓展：颜色枚举类（使用enum声明）
（1）声明颜色枚举类Color;
- 声明final修饰的int类型的属性red,green,blue
- 声明final修饰的String类型的属性description
- 声明有参构造器Color（int red,int green,int blue,String description）
- 创建7个常量对象：红、橙、黄、绿、青、蓝、紫；
- 重写toString方法，例如：RED(255,0,0)-->红色
（2）在测试类中，使用枚举类，获取绿色对象，并打印对象。
提示：
- 7个常量对象的RGB值如下：
红：（255,0,0）
橙：（255,128,0）
黄：（255,255,0）
绿：（0,255,0）
青：（0,255,255）
蓝：（0,0,255）
紫：（128,0,255）
package oop.demo14_enum.exercise04;
enum Color {
RED(255,0,0, "红色"), //RGB值有红绿蓝组成，红：255，绿：0，蓝：0
ORANGE(255,128,0,"橙色"),
YELLOW(255,255,0,"黄色"),
GREEN(0,255,0,"绿色"),
CYAN(0,255,255,"青色"),
BLUE(0,0,255,"蓝色"),
PURPLE(128,0,255,"紫色");//没写对象他会一直有个分号';'，就是让你写对象
private final int red,green,blue;
private final String description;//描述
Color(int red, int green, int blue, String description) {
this.red = red;
this.green = green;
this.blue = blue;
this.description = description;
}
public int getRed() {
return red;
}
public int getGreen() {
return green;
}
public int getBlue() {
return blue;
}
public String getDescription() {
return description;
}
@Override
public String toString() {
return name() + "(" + red + "," + green + "," + blue + ")" + "-->" + description;//name()代表枚举enum对象名
}
}
package oop.demo14_enum.exercise04;
public class ColorTest {
public static void main(String[] args) {
System.out.println(Color.GREEN);
}
}
输出：
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
