使用enum关键字定义的枚举类实现接口

首先我们要知道,这里我们说的使用enum关键字定义的枚举类实现接口中的接口都是内部声明了抽象方法的接口

我们使用enum关键字定义的枚举类实现接口有两种情况:

情况一:

实现接口,在枚举类中统一实现接口中的抽象方法

• 对于情况一而言,接口中的方法时在类中统一实现的,那么这个时候所有的枚举类对象如果执行这个接口中的方法时都是执行的这一个统一的方法

情况二:

实现接口,让枚举类的每个对象分别实现接口中的抽象方法

• 对于情况二而言, 接口中的方法是让每个对象都分别实现了的,没有去统一的实现接口中的抽象方法,那么这个时候使用哪个对象调用的接口中的抽象方法,那么就会调用的哪个对象具体重写的方法

注意: 情况二方式只适用于通过enum关键字定义的枚举类,如果是自定义枚举类的方式则不适用

这里我们通过举例来理解情况一和情况二的区别

1. 首先是情况一

• 我们先给出接口

package 枚举类.枚举类的定义.enum关键字定义枚举类;

public interface Info {
    //省略了public abstract 
    void show();
}

• 然后我们给出使用情况一方式实现了接口的枚举类

package 枚举类.枚举类的定义.enum关键字定义枚举类;


//通过enum关键字定义枚举类
public enum Season2 implements Info{
    /*
    1. 通过enum关键字定义枚举类时,首先我们上来就要提供当前枚举类的对象, 多个对象之间使用,(逗号)隔开,末尾对象使用;(封号结束)

    注意: 这里创建对象的时候省略了很多不重要的东西比如: new关键字, 变量类型 ,构造方法名
    补充: 这里如果是使用无参构造器创建对象的话那么()也可以省略

     */
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    /*
    后面的步骤就和我们自定义枚举类时一样
     */

    /*
    2. 声明Season1类的属性(常量), 使用private final关键字共同修饰
     */
    private final String seasonName;
    private final String seasonDesc;

    /*
    3. 私有化类的构造器,并给对象的属性赋值

    注意: 使用构造器赋值的方式可以让我们的每个对象都唯一存在一个常量
     */
    private Season2(String seasonName , String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    /*
    4. 其他诉求:
    4.1 获取枚举类对象的属性
     */
    public String getSeasonName(){
        return this.seasonName;
    }
    public String getSeasonDesc(){
        return this.seasonDesc;
    }

    /*
    4.2 根据需求提供toString()方法

    注意: 这里我们即使不重写toString()方法,输出此枚举类对象的时候也不会输出地址值,因为我们使用enum关键字定义的枚举类都是直接继承了
    java.lang.Enum类,而Enum类中重写了继承自Object类的toString()方法,Enum类中重写的toString()方法输出的就是枚举类对象所对应的常量名
     */
    @Override
    public String toString() {
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
    //重写的接口中的show()方法
    @Override
    public void show(){
        System.out.println("这是一个季节!");
    }
}
//对使用enum关键字定义的枚举类的测试
class Season2Test{
    public static void main(String[] args) {
        //获取枚举类的对象
        Season2 spring = Season2.SPRING;
        //调用show()方法,这个时候不管我们使用哪个枚举类的对象调用此方法,都会输出: 这是一个季节!
        spring.show();
    }
}

2. 然后是情况二

• 我们同样还是先给出接口
  • 两次的接口都是同一个接口

package 枚举类.枚举类的定义.enum关键字定义枚举类;

public interface Info {
    //省略了public abstract 
    void show();
}

• 然后我们给出使用情况二方式实现此接口的枚举类

package 枚举类.枚举类的定义.enum关键字定义枚举类;


//通过enum关键字定义枚举类
public enum Season3 implements Info{
    /*
    1. 通过enum关键字定义枚举类时,首先我们上来就要提供当前枚举类的对象, 多个对象之间使用,(逗号)隔开,末尾对象使用;(封号结束)

    注意: 这里创建对象的时候省略了很多不重要的东西比如: new关键字, 变量类型 ,构造方法名
    补充: 这里如果是使用无参构造器创建对象的话那么()也可以省略

     */
    
    //注意,这里我们给每个对象都重写了接口中的抽象方法
    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. 声明Season1类的属性(常量), 使用private final关键字共同修饰
     */
    private final String seasonName;
    private final String seasonDesc;

    /*
    3. 私有化类的构造器,并给对象的属性赋值

    注意: 使用构造器赋值的方式可以让我们的每个对象都唯一存在一个常量
     */
    private Season3(String seasonName , String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    /*
    4. 其他诉求:
    4.1 获取枚举类对象的属性
     */
    public String getSeasonName(){
        return this.seasonName;
    }
    public String getSeasonDesc(){
        return this.seasonDesc;
    }

    /*
    4.2 根据需求提供toString()方法

    注意: 这里我们即使不重写toString()方法,输出此枚举类对象的时候也不会输出地址值,因为我们使用enum关键字定义的枚举类都是直接继承了
    java.lang.Enum类,而Enum类中重写了继承自Object类的toString()方法,Enum类中重写的toString()方法输出的就是枚举类对象所对应的常量名
     */
    @Override
    public String toString() {
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}
//对使用enum关键字定义的枚举类的测试
class Season3Test{
    public static void main(String[] args) {
        //获取枚举类的对象
        Season3 spring = Season3.SPRING;
        //调用show()方法,这个时候使用不同的对象调用show()方法都会有不同的结果,因为每个对象中都分别重写了接口中的抽象方法
        spring.show();
    }
}

总结:

1.只有枚举类在实现接口之后可以通过给每个对象重写接口中的抽象方法而不用去统一在枚举类中实现

• 那么为什么枚举类可以,其他类不可以?
  • 因为接口中定义的必须要被重写的方法一定义非静态方法,那么非静态方法的调用者又是对象,那么如果是普通的类,那么可以无限的创建对象,我们不可能让无限个对象都去重写接口中的方法,我们就只能在类中统一进行重写,所有这个普通的类的对象都使用这个重写的方法 - 但是枚举类不同,枚举类的对象时给定的(枚举类的对象数量是确定的, 每个对象也都是确定的,不可变的),所以我们可以让有限个枚举类的对象分别去实现接口中的抽象方法

枚举类 ：
类的对象的个数是可数多个的这样的类叫作枚举类。

1. 自定义枚举类
2. 使用enum实现枚举类
3. enum类中常见方法
4. 实现接口的枚举类

方式1：

class Season{
	private final String seasonName;
	private final String seasonDes;
	//1.私有化构造器
	private Season(String seasonName,String seasonDes){
		this.seasonDes = seasonDes;
		this.seasonName = seasonName;
	}
	
	//2.创建对象
	public final static Season SPRING = new Season("春天","春眠不觉晓");
	public final static Season SUMMER = new Season("夏天","处处蚊子咬");
	public final static Season AUTUMN = new Season("秋天","夜来风雨声");
	public final static Season WINTER = new Season("冬天","冬天穿棉袄");
	
	public String getSeasonName() {
		return this.seasonName;
	}
	public String getSeasonDes() {
		return this.seasonDes;
	}
}


public class EnumTest {

	public static void main(String[] args) {
		System.out.println(Season.SUMMER.getSeasonName());
	}
}

执行结果：

方式2：

格式 ： enum 枚举类的类名{

}

Enum常用方法

• values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
• valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。

enum Season2{
	//2.创建对象
	 SPRING,SUMMER,AUTUMN,WINTER;
}

/*
 *  1.使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再继承其他类
	2.枚举类的构造器只能使用 private 权限修饰符
	3.枚举类的所有实例必须在枚举类中显式列出(, 分隔    ; 结尾)。
		列出的实例系统会自动添加 public static final 修饰
	4.必须在枚举类的第一行声明枚举类对象

 */
enum Season3{
	 //1.声明的对象必须放在首行，多个对象之间用","分开";"结尾
	 //对象前面默认省略的是public static final
	SPRING("春天"),SUMMER("夏天"),AUTUMN("秋天"),WINTER("冬天");
	 
	private final String name;
	private Season3(String name){ //2.构造器默认就是私有的也只能是private。
	  this.name = name;
	}
	  
	public String getName() {
		return name;
	}
	  
	  
}


public class EnumTest2 {

	/*
	 *  values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
		valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。
			如不是，会有运行时异常：IllegalArgumentException。

	 */
	public static void main(String[] args) {
		//返回枚举类型的对象数组
		Season3[] values = Season3.values();
		System.out.println(values[0].getName());
		
		//根据名字获取指定对易用 - 严格区分大小写
		Season3 winter = Season3.valueOf("WINTER");
		System.out.println(winter.getName());
	}
}

执行结果：

实现接口的枚举类：

interface MyInterface {
	void description();
}

enum Season4 implements MyInterface {
	SPRING {
		@Override
		public void description() {
			System.out.println("这是一个季节的类 SPRING");
		}
	},
	SUMMER {
		@Override
		public void description() {
			System.out.println("这是一个季节的类 SUMMER");
		}
	},
	AUTUMN {
		@Override
		public void description() {
			System.out.println("这是一个季节的类 AUTUMN");
		}
	},
	WINTER {
		@Override
		public void description() {
			System.out.println("这是一个季节的类 WINTER");
		}
	};

}

public class EnumTest3 {

	public static void main(String[] args) {

		Season4.SPRING.description();
		Season4.AUTUMN.description();
	}
}

输出结果：

根据尚硅谷的视频做的JUC学习笔记

一、枚举类的创建

1. 自定义枚举类

步骤：（1）声明Season对象的属性：private final修饰（2）2.私有化类的构造器，并给对象属性赋值（3）提供当前枚举类的多个对象：public static final的（4）其他诉求

public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}
//自定义枚举类
class Season{
    //1.声明Season对象的属性：private final修饰
    private final String seasonName;//季节名称
    private final String seasonDesc;//季节描述
    //2.私有化类的构造器，并给对象属性赋值
    public Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //3.提供当前枚举类的多个对象：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("冬天","冰天雪地");
    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.其他诉求2：提供toString()方法
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

2. 使用 enum 关键字定义枚举类

步骤：（1）提供当前枚举类的多个对象,多个对象之间用逗号隔开，末尾使用分号结束（2）声明Season对象的属性：private final修饰（3）私有化类的构造器，并给对象属性赋值（4）其他诉求

public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        System.out.println(summer);//SUMMER
        System.out.println(summer.getSeasonName());//夏天
        System.out.println(Season1.class.getSuperclass());//class java.lang.Enum
    }
}
//使用enum关键字定义枚举类
enum Season1 {
    //1.提供当前枚举类的多个对象,多个对象之间用逗号隔开，末尾使用分号结束
    SPRING("春天", "春暖花开"),
    SUMMER("夏天", "夏日炎炎，有你超甜"),
    AUTUMN("秋天", "秋高气爽"),
    WINTER("冬天", "冰天雪地");
    //2.声明Season对象的属性：private final修饰
    private final String seasonName;//季节名称
    private final String seasonDesc;//季节描述
    //3.私有化类的构造器，并给对象属性赋值
    private Season1(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //4.其他诉求：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

说明：定义的枚举类默认继承于java.lang.Enum类

二、Enum 类中的常用方法

三、使用 enum 关键字定义的枚举类实现接口

1. 实现接口，在enum类中实现抽象方法

public class Test1 {
    public static void main(String[] args) {
        STATUS busy = STATUS.BUSY;
        busy.show();//一种状态
    }
}
interface Info {
    void show();
}
enum STATUS implements Info {
    FREE("自由人"),
    BUSY("忙碌中");
    private final String status;
    STATUS(String status) {
        this.status = status;
    }
    @Override
    public void show() {
        System.out.println("一种状态");
    }
}

2. 让枚举类的对象分别实现接口中的抽象方法

public class Test2 {
    public static void main(String[] args) {
        STATUS1[] values = STATUS1.values();
        for (int i = 0; i < values.length; i++) {
            values[i].show();//自由的飞翔		匆匆忙忙，慌慌张张
        }
    }
}
interface Info2 {
    void show();
}
enum STATUS1 implements Info2 {
    FREE("自由人") {
        @Override
        public void show() {
            System.out.println("自由的飞翔");
        }
    },
    BUSY("忙碌中") {
        @Override
        public void show() {
            System.out.println("匆匆忙忙，慌慌张张");
        }
    };
    private final String status;
    STATUS1(String status) {
        this.status = status;
    }
}