java se基础--枚举类和注解

六.枚举类和注解

1.如何自定义枚举类.枚举类:类的对象是有限个的,确定的

         1.1私有化类的构造器,保证不能在类的外部创建其对象

         1.2在类的内部创建枚举类的实例,声明为:publicstatic final

         1.3若类有属性,那么属性声明为:privatefinal .此属性在构造器中赋值

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

         2.1其中常用的方法:values()  valueOf(String name);

         2.2枚举类如何实现接口:a.让类实现此接口,类的对象共享同一套接口的抽象方法的实现

                                  b.让类的每一个对象都去实现接口的抽象方法,进而通过类的对象调用被重写的抽象方法时,执行的效果不同

public class TestSeason1 {

         publicstatic void main(String[] args) {

                   Season1spring = Season1.SPRING;

                   System.out.println(spring);

                   spring.show();

                   System.out.println(spring.getSeasonName());

                  

                   System.out.println();

                   //1.values()

                   Season1[]seasons = Season1.values();

                   for(inti = 0;i < seasons.length;i++){

                            System.out.println(seasons[i]);

                   }

                   //2.valueOf(Stringname):要求传入的形参name是枚举类对象的名字。

                   //否则，报java.lang.IllegalArgumentException异常

                   Stringstr = "WINTER";

                   Season1sea = Season1.valueOf(str);

                  System.out.println(sea);

                   System.out.println();

                  

                   Thread.State[]states = Thread.State.values();

                   for(inti = 0;i < states.length;i++){

                            System.out.println(states[i]);

                   }

                   sea.show();

                  

         }

}

interface Info{

         voidshow();

}

//枚举类

enum Season1 implements Info{

         SPRING("spring","春暖花开"){

                   publicvoid show(){

                            System.out.println("春天在哪里？");

                   }

         },

         SUMMER("summer","夏日炎炎"){

                   publicvoid show(){

                            System.out.println("生如夏花");

                   }

         },

         AUTUMN("autumn","秋高气爽"){

                   publicvoid show(){

                            System.out.println("秋天是用来分手的季节");

                   }

         },

         WINTER("winter","白雪皑皑"){

                   publicvoid show(){

                            System.out.println("冬天里的一把火");

                   }

         };

        

         privatefinal String seasonName;

         privatefinal String seasonDesc;

        

         privateSeason1(String seasonName,String seasonDesc){

                   this.seasonName= seasonName;

                   this.seasonDesc= seasonDesc;

         }

         publicString getSeasonName() {

                   returnseasonName;

         }

         publicString getSeasonDesc() {

                   returnseasonDesc;

         }

        

         @Override

         publicString toString() {

                   return"Season [seasonName=" + seasonName + ", seasonDesc="

                                     +seasonDesc + "]";

         }

//      publicvoid show(){

//               System.out.println("这是一个季节");

//      }

}

 

3.注解Annotation

      3.1.JDK提供的常用的三个注释

                   @Override:限定重写父类方法,该注释只能用于方法

                   @Deprecated:用于表示某个程序元素(类,方法等)已过时

                   @SuppressWarnings:抑制编译器警告

      3.2如何自定义注解

                   以SuppressWarnings为例进行创建即可

      3.3元注解:可以对已有的注解进行解释说明

                   Retention:SOURCE  CLASS RUNTIME

                   Target:

                   Documented:javadoc

                   Inherited

 

 

 

Javaenum的用法详解

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

public enum Color {  

  RED, GREEN, BLANK, YELLOW  

} 

 

用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

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;

            }

        }

    }

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

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

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;

        }

    }

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。

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

    }

}

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。

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

        }

    }

用法六：使用接口组织枚举

public interface Food {

        enum Coffee implements Food {

            BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO

        }

        enum Dessert implements Food {

            FRUIT, CAKE, GELATO

        }

    }

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档

 

枚举和常量定义的区别

一、 通常定义常量方法

我们通常利用publicfinal static方法定义的代码如下，分别用1表示红灯，3表示绿灯，2表示黄灯。

public class Light {

        /* 红灯 */

        public final static int RED = 1;

        /* 绿灯 */

        public final static int GREEN = 3;

        /* 黄灯 */

        public final static int YELLOW = 2;

    }

二、 枚举类型定义常量方法

枚举类型的简单定义方法如下，我们似乎没办法定义每个枚举类型的值。比如我们定义红灯、绿灯和黄灯的代码可能如下：

public enum Light {

        RED, GREEN, YELLOW;

    }

我们只能够表示出红灯、绿灯和黄灯，但是具体的值我们没办法表示出来。别急，既然枚举类型提供了构造函数，我们可以通过构造函数和覆写toString方法来实现。首先给Light枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，同时覆写toString方法，在该方法中返回从构造函数中传入的参数，改造后的代码如下：

public enum Light {

    // 利用构造函数传参

    RED(1), GREEN(3), YELLOW(2);

    // 定义私有变量

    private int nCode;

    // 构造函数，枚举类型只能为私有

    private Light(int _nCode) {

        this.nCode = _nCode;

    }

    @Override

    public String toString() {

        return String.valueOf(this.nCode);

    }

}

三、 完整示例代码

枚举类型的完整演示代码如下：

public class LightTest {

    // 1.定义枚举类型

    public enum Light {

        // 利用构造函数传参

        RED(1), GREEN(3), YELLOW(2);

        // 定义私有变量

        private int nCode;

        // 构造函数，枚举类型只能为私有

        private Light(int _nCode) {

            this.nCode = _nCode;

        }

        @Override

        public String toString() {

            return String.valueOf(this.nCode);

        }

    }

    /**

     * 

     * @param args

     */

    public static void main(String[] args) {

        // 1.遍历枚举类型

        System.out.println("演示枚举类型的遍历 ......");

        testTraversalEnum();

        // 2.演示EnumMap对象的使用

        System.out.println("演示EnmuMap对象的使用和遍历.....");

        testEnumMap();

        // 3.演示EnmuSet的使用

        System.out.println("演示EnmuSet对象的使用和遍历.....");

        testEnumSet();

    }

    /**

     * 

     * 演示枚举类型的遍历

     */

    private static void testTraversalEnum() {

        Light[] allLight = Light.values();

        for (Light aLight : allLight) {

            System.out.println("当前灯name：" + aLight.name());

            System.out.println("当前灯ordinal：" + aLight.ordinal());

            System.out.println("当前灯：" + aLight);

        }

    }

    /**

     * 

     * 演示EnumMap的使用，EnumMap跟HashMap的使用差不多，只不过key要是枚举类型

     */

    private static void testEnumMap() {

        // 1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型

        EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(

        Light.class);

        currEnumMap.put(Light.RED, "红灯");

        currEnumMap.put(Light.GREEN, "绿灯");

        currEnumMap.put(Light.YELLOW, "黄灯");

        // 2.遍历对象

        for (Light aLight : Light.values()) {

            System.out.println("[key=" + aLight.name() + ",value="

            + currEnumMap.get(aLight) + "]");

        }

    }

    /**

     * 

     * 演示EnumSet如何使用，EnumSet是一个抽象类，获取一个类型的枚举类型内容<BR/>

     * 

     * 可以使用allOf方法

     */

    private static void testEnumSet() {

        EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);

        for (Light aLightSetElement : currEnumSet) {

            System.out.println("当前EnumSet中数据为：" + aLightSetElement);

        }

    }

}