黑马程序员：java中的枚举（总结张老师的讲解内容）

 

----------------------- android培训、java培训、期待与您交流！ --------------------

黑马程序员：java中的枚举（总结张老师的讲解内容）

本文是根据枚举授课内容进行的总结，代码注释，和提出了一些问题。代码进行了修改，而非完全和课程中的一致，希望和大家相互交流，也希望大家多提建议。

 

/*什么是枚举？为什么要有枚举？
 * 枚举就是要让某个类型的变量的取值只能为若干固定值的一个，否则，编译期就回报错。枚举可以让
 * 编译器在编译时就回控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这个目标
 * */
public class Enumerate {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  WeekDay weekday=WeekDay.THU;
  System.out.println(weekday.nextDay().toString());  
  WeekDay2 weekday2=WeekDay2.FRI;
  System.out.println(weekday2);               //枚举类自动实现了toString方法
  System.out.println(weekday2.name());
  System.out.println(weekday2.ordinal());
  System.out.println(weekday2.getClass());
  //以上为枚举对象的方法，下面为枚举类中的静态方法
  System.out.println(WeekDay2.valueOf("SUN"));
  System.out.println(WeekDay2.valueOf("SUN").toString());
  //比如网页中用户在文本框中输入了SUN，服务器需要将这个字符串 转换成java中的WeekDay的对象
  //此处的valueof方法就可以将一个字符串转换成一个枚举元素。
  System.out.println(WeekDay2.values().length);
  //将数组中的每个元素存入一个数组中，当需要遍历或迭代这个数组中的元素时，不可以直接
  //遍历这个枚举类，而是应该先将所有元素存入一个数组，然后对数组进行遍历。采用values()
  WeekDay3 weekday3=WeekDay3.SUN;
 
 }
 

 //通过内部类和子类对抽象方法的实现来实现枚举 
 public abstract static class WeekDay{
  //首先定义一个私有的构造方法，外部不可见；
  private WeekDay(){}
  /*七个静态变量的定义。每个成员是WeedDay这个类的一个对象。为了避免在普通类定义方式中
   的nextDay方法中使用多次if-else语句，故将nextDay申明为抽象的方法。那么就不可以直接
   利用WeekDay这个类来实例化对象，而是需要利用他的子类来实例化。也因此需要在WeekDay
   的子类中进行实现其中的抽象方法。下面这种对七个成员定义方式就是使用匿名的子类（首先
   是一个内部类，这个内部类没有名称，但是WeekDay的一个子类，并用这个子类定义了一个对象
   ）来定义的。子类的实现代码即大括号中的代码，即对父类中抽象方法的实现（覆盖）。*/
  
  //public final static WeekDay SUN = new WeekDay();普通的定义方式
  
  public final static WeekDay SUN = new/*此处为利用子类定义了一个对象*/ WeekDay(){
   //下面是子类的代码，即覆盖父类的方法
   public WeekDay nextDay(){
    return MON;
   }
   public String toString(){
    if (this==SUN){
     return "SUN";
    }
    return null;
     
   }  
  };

  public final static WeekDay MON = new WeekDay(){
   public WeekDay nextDay(){
    return TUE;
   } 
   public String toString(){
    if (this==MON){
     return "MON";
    }
    return null;
   }
  };
  public final static WeekDay TUE = new WeekDay(){
   public WeekDay nextDay(){
    return WED;
   } 
   public String toString(){
    if (this==TUE){
     return "TUE";
    }
    return null;
   }   
  };
  public final static WeekDay WED = new WeekDay(){
   public WeekDay nextDay(){
    return THU;
   } 
   public String toString(){
    if (this==WED){
     return "WED";
    }
    return null;
   }   
  };
  public final static WeekDay THU = new WeekDay(){
   public WeekDay nextDay(){
    return FRI;
   } 
   public String toString(){
    if (this==THU){
     return "THU";
    }
    return null;
   }   
  };
  public final static WeekDay FRI = new WeekDay(){
   public WeekDay nextDay(){
    return SAT;
   } 
   public String toString(){
    if (this==FRI){
     return "FRI";
    }
    return null;
   }   
  };
  public final static WeekDay SAT = new WeekDay(){
   public WeekDay nextDay(){
    return SUN;
   } 
   public String toString(){
    if (this==SAT){
     return "SAT";
    }
    return null;
   }   
  };  
  public abstract WeekDay nextDay();
  public abstract String toString();

  //采用抽象方法定义nextDay和toString就将大量的if...else语句转变成了若干个独立的类 

 }
 
 
 
 //java中枚举的使用，利用enum类实现
 //下面的WeekDay2是最简单的枚举，没有构造方法。
 public enum WeekDay2{
  SUN,MON,TUE,WED,THU,FRI,SAT;//枚举中的每个元素相当于类的一个对象。
 }
 
 
 //带具有参数的构造方法的枚举类
 public enum WeekDay3{
  SUN,MON,TUE,WED,THU,FRI,SAT;//元素列表必须位于枚举类中所有的成分之前,这是7个静态变量
  private WeekDay3(){         //枚举的构造方法，只有private类型才可以。上面的静态变量
   System.out.println("first");//在WeekDay3被加载时会默认调用这个构造方法。
  }
  private WeekDay3(int day){         //枚举的构造方法，只有private类型才可以
   System.out.println("second");  //要调用第二个构造方法需要使用类似Sun(1)的方式给出
  }          //枚举对象，即传给Sun元素一个参数。二如果是Sun(),还是调用第一种构造方法。  
 }
 
 
 
 //带有抽象方法的枚举类。     交通灯的实现。     最复杂的枚举。
 public enum TrafficLamp{
  //RED,GREEN,YELLOW; 当类中有抽象方法时，元素对象就不可以使用类直接实例化，而是需要利用
  //该类的子类来实例化
  
  RED(30)/*首先，RED是由子类定义的，传递一个参数，表示子类调用父类带参数的构造方法。*/{
   public TrafficLamp nextLamp(){
    return GREEN; 
   }
  },      //这种写法表示RED是由TrafficLamp的子类来实例化的。匿名子类代码即大括号中内容。
  
  
  //问题：为什么子类可以调用父类私有的构造方法？？？？？
  
  
  GREEN(45){
   public TrafficLamp nextLamp(){ 
    return YELLOW;
   }
  },
  YELLOW(5){
   public TrafficLamp nextLamp(){
    return RED;
   }
  };
  
  /*打开本源文件所对应的的字节码文件所在的目录，会看到名为Enumerate$TrafficLamp$1,
   * Enumerate$TrafficLamp$2和Enumerate$TrafficLamp$3的三个class文件，这就代表这
   * 三个枚举元素是由枚举类的三个匿名子类来定义的。*/
  //实现步骤：先定义三个元素，每个元素后面带三个大括号，表示这些元素是由类的子类实现的
  //然后在大括号中编写子类的代码。
  
  public abstract TrafficLamp nextLamp();   //类的方法的返回值还是这个类的类型
  private int time;//要为每个灯指定相应的时间。通过构造方法来实现。
  private TrafficLamp(int time){
   this.time=time;
  } 
 }
 
 
 /*总结：
  * 枚举是一种特殊的类，其中每个元素都是类的一个实例对象。
  * 类中的方法的返回值可以只自己的这种类型
  * 类中可以定义静态常量，常量指向的结果就是这种类的类型的实例对象
  * 枚举就是一个类，其中可以定义构造方法、成员变量、普通方法和抽象方法
  * 枚举元素必须位于枚举体中最开始的地方，列表后要加分号与其他成员分开。
  * 带构造方法的枚举中，构造方法必须定义为私有的
  * 带抽象方法的枚举，每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式定义
  * 枚举只有一个元素时，可以作为一种单例的实现方式*/ 
}