精华内容
下载资源
问答
  • 枚举类实现接口【精】
    千次阅读
    2020-03-16 14:28:35

    枚举类实现接口【精】

    一、前言

    枚举类和普通类实现接口一样吗?

    二、枚举类实现接口

    枚举类实现接口与普通类实现接口是一样的,都需要实现接口的抽象方法。

    但是!!

    枚举类 实现接口的同一个抽象方法,该抽象方法在枚举类不同对象实现不同的行为。如何实现那?

    简单

    只要在枚举类的每个对象都重写该方法就可以做到不同对象实现该抽象方法不同的行为。

    三、枚举类实现接口实例

    • 先定义一个接口
    /**
     * 定义一个接口
     */
    interface Info {
        void describe();
    }
    • 创建一个枚举类实现该接口
    /**
     *  枚举类实现接口
     */
    public enum EnumImplement implements Info{  }
    • 重写接口的方法
    /**
     *  枚举类实现接口重写抽象方法
     */
    public enum EnumImplement implements Info{
    
        /**
         *  需求:实现接口,在不同的对象实现抽象方法不同的行为。
         *  实现方法:将接口的抽象方法在每个对象中重写实现不同的行为
         */
        SPRING("春天"){
            @Override
            public void describe() {
                System.out.println("春江水阿暖鸭先知");
            }
        },
        SUMMER("夏天"){
            @Override
            public void describe() {
                System.out.println("我爱山中夏,空冥花雨下。");
            }
        },
        AUTUMN("秋天"){
            @Override
            public void describe() {
                System.out.println("停车坐爱枫林晚,霜叶红于二月花。");
            }
        },
        WINTER("冬天"){
            @Override
            public void describe() {
                System.out.println("北国风光,千里冰封,万里雪飘。");
            }
        };
    
    •  枚举类实现接口完整实例
    
    /**
     * 定义接口
     */
    interface Info {
        void describe();
    }
    
    /**
     *  枚举类实现接口的抽象方法
     */
    public enum EnumImplement implements Info{
    
        /**
         *  需求:接口的抽象方法,在不同的对象实现不同的行为。
         *  实现方法:将接口的抽象方法在每个对象中重写实现不同的行为
         */
        SPRING("春天"){
            @Override
            public void describe() {
                System.out.println("春江水阿暖鸭先知");
            }
        },
        SUMMER("夏天"){
            @Override
            public void describe() {
                System.out.println("我爱山中夏,空冥花雨下。");
            }
        },
        AUTUMN("秋天"){
            @Override
            public void describe() {
                System.out.println("停车坐爱枫林晚,霜叶红于二月花。");
            }
        },
        WINTER("冬天"){
            @Override
            public void describe() {
                System.out.println("北国风光,千里冰封,万里雪飘。");
            }
        };
    
        //申明 EnumTest 对象的属性
        final String name;
    
        //提供有参构造器
        EnumImplement(String name) {
            this.name = name;
        }
    
        // 获取类对象属性
        public String getName() {
            return name;
        }
    }
    
    •  定义测试类,获取枚举类对象和对象属性
    public class App {
        public static void main(String[] args) {
    
            //获取 EnumImplement 所有对象
            EnumImplement[] values = EnumImplement.values();
            for (EnumImplement v : values) {
                //获取对象属性
                System.out.println(v.getName());
                v.describe();
            }
        }
    }
    • 获取枚举类对象及属性结果
    春天
    春江水阿暖鸭先知
    夏天
    我爱山中夏,空冥花雨下。
    秋天
    停车坐爱枫林晚,霜叶红于二月花。
    冬天
    北国风光,千里冰封,万里雪飘。
    

     

    更多相关内容
  • 主要介绍了Java实现接口枚举类,结合实例形式分析了java接口的枚举类相关原理与使用技巧,需要的朋友可以参考下
  • 使用enum关键字定义的枚举类实现接口 首先我们要知道,这里我们说的使用enum关键字定义的枚举类实现接口中的接口都是内部声明了抽象方法的接口 我们使用enum关键字定义的枚举类实现接口有两种情况: 情况一: 实现接口,...

    使用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.只有枚举类在实现接口之后可以通过给每个对象重写接口中的抽象方法而不用去统一在枚举类中实现

    • 那么为什么枚举类可以,其他类不可以?
      • 因为接口中定义的必须要被重写的方法一定义非静态方法,那么非静态方法的调用者又是对象,那么如果是普通的类,那么可以无限的创建对象,我们不可能让无限个对象都去重写接口中的方法,我们就只能在类中统一进行重写,所有这个普通的类的对象都使用这个重写的方法 - 但是枚举类不同,枚举类的对象时给定的(枚举类的对象数量是确定的, 每个对象也都是确定的,不可变的),所以我们可以让有限个枚举类的对象分别去实现接口中的抽象方法
    展开全文
  • 502.500.JAVA基础教程_枚举类与注解-使用enum关键字定义的枚举类实现接口(502).rar
  • 实现接口枚举类 方式1: class Season{ private final String seasonName; private final String seasonDes; //1.私有化构造器 private Season(String seasonName,String seasonDes){ this.seasonDes = ...

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

    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();
    	}
    }
    

    输出结果:
    在这里插入图片描述

    展开全文
  • 使用 enum 关键字定义枚举类二、Enum 中的常用方法三、使用 enum 关键字定义的枚举类实现接口1. 实现接口,在enum中实现抽象方法2. 让枚举类的对象分别实现接口中的抽象方法 一、枚举类的创建 1. 自定义枚举类...

    根据尚硅谷的视频做的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;
        }
    }
    
    展开全文
  • 主要介绍了Java枚举类接口实例原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • } } public class enumTest { public static void main(String[] args) { // 通过valueof方法获取指定枚举类的值 Gender gf = Enum.valueOf(Gender.class, "FEMALE"); Gender gm = Enum.valueOf(Gender.class, ...
  • 实现接口枚举类

    千次阅读 2019-06-16 08:56:34
    与普通类实现一个或多个接口完全一样,枚举类实现一个或多个接口时,也需要实现接口所包含的方法。 如果需要每个枚举值在调用同一个方法时呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法,每个枚举值...
  • 文章目录枚举类的理解枚举类的定义Enum的主要方法枚举类实现接口 枚举类的理解 当的对象只有有限个,且确定的,称此类为枚举类。 当需要定义一组常量时,强烈建议使用枚举类。 如果枚举类中只有一个对象,则...
  • 枚举类定义,实现接口与其常用方法 一.枚举类定义: 步骤一:提供当前枚举类的对象,且多个对象之间用",“隔开,最后一个对象用”; "结束。示例: enum Season { // 1.提供当前枚举类的对象,多个对象之间用“,”...
  • 这些通过共有的静态final域为每个枚举常量导出一个实例。枚举类型没有可以访问的构造器,所以它是真的final。客户端不能创建枚举类型的实例,也不能对它进行扩展,因此不存实例,而只存在声明过程的枚举常量。也...
  • (Java)让枚举实现一个接口

    千次阅读 2020-02-19 22:48:28
    枚举类也可以实现一个接口,但是因为接口中会存在抽象方法,所以枚举类中的每个对象都必须分别实现此抽象方法: ...enum Color implements Print{//枚举类实现接口 RED{ public String getColor(...
  • 枚举实现接口

    千次阅读 2018-08-02 00:11:15
     创建枚举类型要使用 enum 关键字,隐含了所创建的类型都是 java.lang.Enum 的子类(java.lang.Enum 是一个抽象)。枚举类型符合通用模式 Class Enum&lt;E extends Enum&lt;E&gt;&gt;,而 E...
  • 枚举的构造 若某事物的取值只有有限个,可以一个个罗列出来,则这个列举出来的类型就叫做枚举类型。 (1)使用public static 修饰的方法构造枚举 public class Size { private int size=1; //用staic final修饰...
  • package org.lgy.study.enumstudy; public interface ...枚举类也可以实现一个或多个接口,与普通类实现一个或多个接口完全一样。 枚举类实现一个或多个接口时,也需要实现接口所包含的方法。 */ ...
  • 用法五:实现接口 所有的枚举都继承自java.lang.Enum。由于Java 不支持多继承,所以枚举对象不能再继承其他。 public interface Behaviour { void print(); String getInfo(); } public enum Color ...
  • * 作用:可以让不同的枚举类对象分别调用实现接口重写的方法,从而实现不同的结果。 */ public class TestComputer { public static void main(String[] args) { // 实现不同的效果 Computer.DESKTOP.show();...
  • 四、使用enum关键字定义的枚举类实现接口的情况 栗子一:实现接口,在enum中实现抽象方法。 栗子二:让枚举类的 对象分别实现接口中的抽象方法。 五、注解(Annotation)概述 二、常见的Annotation 示例: 六、...
  • Java 枚举类和自定义枚举类和enum声明及实现接口1.枚举类1.枚举类的属性2.自定义枚举类2.Enum枚举类3.实现接口枚举类 1.枚举类 注: JDK1.5之前需要自定义枚举类 JDK 1.5 新增的 enum 关键字用于定义枚举类 ...
  • 可以实现接口吗? 下面正文开始解答!!! 1. 枚举类 枚举是一种特殊的数据类型,在Java5之后新增的特性,允许用常量来表示特定的数据片断,所有的枚举都继承自java.lang.Enum。 由于Java 不支持多继承,...
  • 枚举(三)用枚举实现接口的用法

    千次阅读 2016-05-26 19:53:25
    有一个枚举类实现了这个接口 在这个枚举类中定义了四个基本,加减乘除,但我们有时候还有别的算法列入求x的y次幂,x取余y,这个时候我们不方便扩展基础枚举,我们可以再声明一个枚举接口进行扩展就行: 在...
  • 又因为 java 的枚举类型是不支持继承的(至少我这的 jre 不支持),所以想到了 使用实现接口 来达到目的。首先,类库中的枚举:public enum P1Enum {A, B, C;}public enum P2Enum {AA, BB, CC;}然...
  • java中enum的两种接口实现方法

    千次阅读 2019-10-06 16:53:24
    和普通 Java 一样,枚举类可以实现一个或多个接口 若每个枚举值在调用实现的接口方法呈现相同的行为方式,...1、enum关键字定义枚举类实现接口的情况 ```java interface info{ void show(); } enum Season1 i...
  • 今天在看 《漫谈设计模式》的时候,看到状态模式的时候,居然发现,枚举类型原来也是可以 实现接口的。 真是涨见识了。 而且 枚举类型的静态属性也是可以 实现方法的, 只是如果没有 实现接口方法的情况下,...
  • 枚举里面的接口实现

    千次阅读 2019-03-31 13:42:52
    枚举式一个,这个,同样也有改由的功能,今天来说说枚举实现接口。下面还是来看看代码吧.首先我们定义一个接口 接口里面由两个抽象方法.代码如下. public interface enuminterface { //在接口里面定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 195,562
精华内容 78,224
关键字:

枚举类实现接口

友情链接: Lecture04_PSD.zip