zoukankan      html  css  js  c++  java
  • java 枚举类型

    枚举的实质是什么?

    枚举继承了ENUM类,枚举类型的每一个成员都以该类型的一个实例,而且默认的都是声明为public static final的 ,而且枚举里的每一个对象 就是当前枚举实例化的对象枚举里面所有的方法,里面的每个对象都可以调用

    enum中的方法:

    A.ordinal()用来返回枚举值在枚举类中的顺序。

    B.compareTo ()比较两个枚举值的顺序,返回顺序之差。

    C.values(),静态方法,返回包含一个全部枚举值的数组。

    D.toString(),返回枚举常量的名称

    E.valueOf(),返回指定没弄成的枚举类型的枚举常量。 

     先看个简单示例:

    enum FruitEnum {
        APPLE(1), ORANGE(2);    //    调用构造函数来构造枚举项
    
        private int value = 0;
    
        private FruitEnum(int value) {    //    必须是private的,否则编译错误
            this.value = value;
        }
    
        public static FruitEnum valueOf(int value) {    //    手写的从int到enum的转换函数
            switch (value) {
            case 1:
                return APPLE;
            case 2:
                return ORANGE;
            default:
                return null;
            }
        }
    
        public int value() {
            return this.value;
        }
    }
    
    public static void main(String[] args) {
        System.out.println(FruitEnum.APPLE.value());    //    1
        System.out.println(FruitEnum.ORANGE.value());    //   2
        System.out.println(FruitEnum.valueOf(1));        //  FruitEnum.APPLE
        System.out.println(FruitEnum.valueOf(2));        //  FruitEnum.ORANGE
    }

     

    下面就是网络上的各种版本的用法了:
    用法一:常量

    public enum Color {  
      RED, GREEN, BLANK, YELLOW  
    } 
    View Code

    用法二:switch

    enum Signal {
            GREEN, YELLOW, RED
        }
    
        public class TrafficLight {
            Signal color = Signal.RED;
    
            public void change() {
                switch (color) {
                case RED:
                    color = Signal.GREEN;
                    break;
                case YELLOW:
                    color = Signal.RED;
                    break;
                case GREEN:
                    color = Signal.YELLOW;
                    break;
                }
            }
        }
    View Code

    用法三:向枚举中添加新方法

    public enum Color {
            RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
            // 成员变量
            private String name;
            private int index;
    
            // 构造方法
            private Color(String name, int index) {
                this.name = name;
                this.index = index;
            }
    
            // 普通方法
            public static String getName(int index) {
                for (Color c : Color.values()) {
                    if (c.getIndex() == index) {
                        return c.name;
                    }
                }
                return null;
            }
    
            // get set 方法
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public int getIndex() {
                return index;
            }
    
            public void setIndex(int index) {
                this.index = index;
            }
        }
    View Code

    用法四:覆盖枚举的方法

    public class Test {
        public enum Color {
            RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
            // 成员变量
            private String name;
            private int index;
    
            // 构造方法
            private Color(String name, int index) {
                this.name = name;
                this.index = index;
            }
    
            // 覆盖方法
            @Override
            public String toString() {
                return this.index + "_" + this.name;
            }
        }
    
        public static void main(String[] args) {
            System.out.println(Color.RED.toString());
        }
    }
    View Code

    用法五:实现接口

    public interface Behaviour {
            void print();
    
            String getInfo();
        }
    
        public enum Color implements Behaviour {
            RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
            // 成员变量
            private String name;
            private int index;
    
            // 构造方法
            private Color(String name, int index) {
                this.name = name;
                this.index = index;
            }
    
            // 接口方法
    
            @Override
            public String getInfo() {
                return this.name;
            }
    
            // 接口方法
            @Override
            public void print() {
                System.out.println(this.index + ":" + this.name);
            }
        }
    View Code

    实例

    public interface DateInfo {
         public String getDateInfo();
     }
    
    public enum Season2 implements DateInfo {
        
        SPRING("春天","春风又绿江南岸"){
            @Override
            public String getDateInfo() {
                return "2-5";
            }
        },
        SUMMER("夏天","映日荷花别样红"){
            @Override
            public String getDateInfo() {
                return "5-8";
            }
        },
        FALL("秋天","秋水共长天一色"){
            @Override
            public String getDateInfo() {
                return "8-11";
            }
        },
        WINTER("冬天","窗寒西岭千秋雪"){
            @Override
            public String getDateInfo() {
                return "11-2";
            }
        },;
        
        private String name;
        private String desc;
        
        private Season2(String name,String desc){
            this.name = name;
            this.desc = desc;
        }
    
        public String getName() {
            return name;
        }
    
        public String getDesc() {
            return desc;
        }
    
    /*    @Override 改为利用匿名内部类重写的方法更酷些
        public String getDateInfo() {
            System.out.println(this.toString().equals("SPRING"));
            return null;
        }  */    
    }
    
    Season2类继承接口DateInfo
    
    
    public class TestSeason {
    
        public static void main(String[] args) {
    
    //        Season SPRING = Season.SPRING;
    //        System.out.println(SPRING);
    //        System.out.println(Season2.SPRING);
            for(Season2 s:Season2.values()){
    //            System.out.println(s);
    //            System.out.println(s.toString().equals("SPRING"));
                System.out.println(s.getDateInfo());    
            }
            
            String str = "WINTER";
            Season2 s = Season2.valueOf(Season2.class, str);
            System.out.println(s.getName()+" "+s.getDesc());
        }
    }
    
    TestSeason测试类

     

  • 相关阅读:
    JS window对象 Navigator对象 Navigator 对象包含有关浏览器的信息,通常用于检测浏览器与操作系统的版本。
    JS window对象 返回下一个浏览的页面 forward()方法,加载 history 列表中的下一个 URL。
    JS window对象 取消计时器clearTimeout() setTimeout()和clearTimeout()一起使用,停止计时器。 语法: clearTimeout(id_of_setT
    JS window对象 History 对象 history对象记录了用户曾经浏览过的页面(URL),并可以实现浏览器前进与后退相似导航的功能。语法: window.history.[属性|方法]
    JS window对象 返回前一个浏览的页面 back()方法,加载 history 列表中的前一个 URL。 语法: window.history.back();
    JS window对象 计时器setTimeout() setTimeout()计时器,在载入后延迟指定时间后,去执行一次表达式,仅执行一次。 语法: setTimeout(代码,延迟时间);
    JS window对象取消计时器clearInterval() clearInterval() 方法可取消由 setInterval() 设置的交互时间。
    ELK问题处理
    nginx 日志变量含义
    nginx ssl 更换问题
  • 原文地址:https://www.cnblogs.com/yujian-bcq/p/4597497.html
Copyright © 2011-2022 走看看