java 判断枚举是否 包含 java判断枚举相等

JAVA枚举

很多编程语言都提供了枚举的概念，但是java直到1.5之后才提出了枚举的概念，出现比这个语言本身晚10年。

主要作用是用于定义有限个数对象的一种结构（多例设计），枚举就属于多例设计并且其结构要比多例设计要更加的简单。

1，枚举的基本定义

从JDK1.5之后在程序中提供了enum的关键字，利用此关键字可以实现枚举的定义。

范例：定义一个枚举

1 enum Color {
 2     RED,GREEN,BLUE;
 3 }
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7         Color color=Color.RED;
 8         System.out.println(color);
 9         System.out.println("Hello World!");
10     }
11 }

 在进行枚举处理的时候还可以利用values()方法获取所有的枚举对象进行输出。如果此时使用多例设计模式来进行设计，那么需要编写很多的程序代码，这样对于开发的复杂度是比较高的，因为里面牵扯到构造方法的私有化以及静态方法。多例设计与枚举设计可以实现相同的功能，但是枚举可以在程序编译的时候就判断所使用的实例化对象是否存在。

范例：获取所有的枚举对象

1 enum Color {
 2     RED,GREEN,BLUE;
 3 }
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7         for (Color color:Color.values()){
 8             System.out.println(color);
 9         }
10         System.out.println("Hello World!");
11     }
12 }

 从JDK1.5追加了枚举结构之后，就可以在switch之中进行枚举项的判断。如果此时通过多例设计来实现同样的功能，那么就需要使用对象数组了。

范例：观察枚举和switch处理

1 enum Color {
 2     RED,GREEN,BLUE;
 3 }
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7         Color color=Color.GREEN;
 8         switch (color){//直接支持枚举
 9             case RED:System.out.println("红色");break;
10             case GREEN:System.out.println("绿色");break;
11             case BLUE:System.out.println("蓝色");break;
12         }
13         System.out.println("Hello World!");
14     }
15 }

  多例上是无法实现这种与switch直接连接的，多例要想实现它就需要编写大量的if判断。 

2，enum类

严格意义上讲枚举并不属于一种新的结构，它的本质相当于一个类，但是这个类会默认继承Enum类，首先观察一下Enum类的基本定义。

public abstract class Enum<E extends Enum<E>> extends Object implements Comparable<E>, Serializable

现在定义的枚举类的类型就是Enum中所使用的E类型。下面我们观察Enum类中定义的方法：

No.	方法名称	类型
01	protected Enum(String name, int ordinal)	构造	传入名字和序号
02	public final String name()	普通	获得对象的名字
03	public final int ordinal()	普通	获得对象的序号

范例：检验上面方法

1 enum Color {
 2     RED,GREEN,BLUE;
 3 }
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7         for (Color color:Color.values()){
 8             System.out.println(color.ordinal()+"-"+color.name());
 9         }
10         System.out.println("Hello World!");
11     }
12 }

 面试题：请解释enum和Enum的区别？在枚举中每一个对象的序号都是根据枚举对象的定义顺序决定的。

l enum是从JDK1.5之后提供的一个关键字，用于定义枚举类；

l Enum是一个抽象类，所有使用enum关键字定义的类就默认继承此类；

 3，定义枚举结构

一直在强调枚举本身就是一个多例设计模式，那么既然是多例设计模式，那么在一个类之中可以定义的结构很多，例如：构造方法、普通方法、属性等，那么这些内容也可以在枚举类中直接定义，但是需要注意的是：枚举类中定义的构造方法不能采用非私有化定义（public无法使用）

范例：在美居类中定义其他的结构

1 enum Color {
 2     RED("红色"),GREEN("绿色"),BLUE("蓝色");
 3 
 4     //枚举对象要写在第一行
 5 
 6     //多例设计中每个对象都是一个static 的final常量，所以命名全部大写
 7     private String title;
 8     private Color(String title){
 9         this.title=title;
10     }
11     @Override
12     public String toString(){
13         return this.title;
14     }
15 }
16 
17 public class Main {
18     public static void main(String[] args) {
19         for (Color color:Color.values()){
20             System.out.println(color.ordinal()+"-"+color.name()+"-"+color);
21         }
22         System.out.println("Hello World!");
23     }
24 }

范例：让枚举实现接口本程序在简化程度上远远高于多例设计模式，除了这种基本的结构之外，在枚举类中也可以实现接口类的继承。

1 interface IMessage{
 2     public String getMessage();
 3 }
 4 enum Color implements IMessage{
 5     RED("红色"),GREEN("绿色"),BLUE("蓝色");//枚举对象要写在第一行,多例设计中每个对象都是一个static 的final常量
 6     private String title;
 7     private Color(String title){
 8         this.title=title;
 9     }
10     @Override
11     public String getMessage() {
12         return this.title;
13     }
14 }
15 
16 public class Main {
17     public static void main(String[] args) {
18         IMessage msg=Color.GREEN;
19         System.out.println(msg.getMessage());
20         System.out.println("Hello World!");
21     }
22 }

 范例：观察枚举中定义抽象方法枚举类中最有意思的是它可以直接定义抽象方法，并且要求每一个枚举对象都要独立覆写此抽象方法实现 

1 enum Color {
 2     RED("红色"){
 3         public String getMessage(){
 4             return this.toString();
 5         }
 6     },GREEN("绿色"){
 7         public String getMessage(){
 8             return this.toString();
 9         }
10     },BLUE("蓝色"){
11         public String getMessage(){
12             return this.toString();
13         }
14     };//枚举对象要写在第一行,多例设计中每个对象都是一个static 的final常量
15     private String title;
16     private Color(String title){
17         this.title=title;
18     }
19     public String toString(){
20         return this.title;
21     }
22     public abstract String getMessage();
23 }
24 
25 public class Main {
26     public static void main(String[] args) {
27         System.out.println(Color.GREEN.getMessage());
28         System.out.println("Hello World!");
29     }
30 }

 枚举的定义是非常灵活的，但是在实际使用过程中，枚举更多情况下还是建议使用它的正确用法，就是定义一个实例对象即可。

4，枚举的实际使用

现在定义一个Person类，性别肯定不希望用户随便输入，所以使用枚举类最合适

范例：

1 enum Sex{
 2     MALE("男"),FEMALE("女");
 3     private String title;
 4     private Sex(String title){
 5         this.title=title;
 6     }
 7 
 8     public String toString(){
 9         return this.title;
10     }
11 }
12 
13 class Person{
14     private String name;
15     private int age;
16     private Sex sex;
17 
18     public Person(String name, int age, Sex sex) {
19         this.name = name;
20         this.age = age;
21         this.sex = sex;
22     }
23     public String toString(){
24         return "姓名:"+this.name+"、年龄："+this.age+"、性别："+this.sex;
25     }
26 }
27 
28 public class Main {
29     public static void main(String[] args) {
30         System.out.println(new Person("万雨",25,Sex.MALE));
31         System.out.println("Hello World!");
32     }
33 }

 这个程序不使用枚举也可以正常实现，追加几个判断即可，所以对于枚举的使用全凭自愿。