01.public abstract class WeekDay{

02.          private WeekDay(){

03.          }

04.          public abstract WeekDay nextDay();

05.

06.         public final static WeekDay SUN = new WeekDay(){ //这讲到了大括号就是子类，有点忘记了，该去怎么理解，请分解代码

07.                public WeekgDay nextDay(){

08.                     return MON；

09.                }

10.         public final static WeekDay MON= new WeekDay(){ //这讲到了大括号就是子类，有点忘记了，该去怎么理解，请分解代码

11.                public WeekgDay nextDay(){

12.                     return SUN；

13.                }

这是普通类模拟的枚举类，因为这个类是一个抽象类，有一个抽象的nextDay方法，由于类是抽象的，不能直接new对象，所以new的是子类对象，既然子类就必须实现抽象方法。所以在new一个对象时要实现其中的抽象方法。由于手机发帖不方便所以不上代码了。

其实是使用到了匿名内部类，如果这部分不熟悉的话，建议去看看老毕的视频，面向对象那里讲到了匿名内部类，很详细

实际上是调用了枚举类的无参构造，而枚举里是可以有抽象方法的，那么生成枚举对象的话，抽象方法必须被覆盖，这样就要写大括号了。贴一个我之前的代码。。也是获取下一个灯的。

1. public class Test2 {
   
2.         public static void main(String[] args) {
   
3.                 System.out.println("测试方法演示:");
   
4.                 //设置当前灯为红灯
   
5.                 Lamp currentLamp = Lamp.RED;
   
6.                 int i = 1;
   
7.                 //循环输出三次，测试下一个灯的方法是否正常
   
8.                 while(i<4){
   
9.                         System.out.println(currentLamp+"的下一个灯是"+(currentLamp=currentLamp.getNextLamp()));
   
10.                         i++;
    
11.                 }
    
12.         }
    
13. }
    
14. //定义的交通灯枚举
    
15. enum Lamp{
    
16.         //包含红灯、绿灯、黄灯，三个元素。
    
17.         RED(){
    
18.                 public String toString() {
    
19.                         return "红灯";
    
20.                 }
    
21.                 public Lamp getNextLamp() {
    
22.                         return GREEN;
    
23.                 }
    
24.         },GREEN(){
    
25.                 public String toString() {
    
26.                         return "绿灯";
    
27.                 }
    
28.                 public Lamp getNextLamp() {
    
29.                         return YELLOW;
    
30.                 }
    
31.         },YELLOW(){
    
32.                 public String toString() {
    
33.                         return "黄灯";
    
34.                 }
    
35.                 public Lamp getNextLamp() {
    
36.                         return RED;
    
37.                 }
    
38.         };
    
39.         //覆盖toString方法，方便测试打印
    
40.         @Override
    
41.         public abstract String toString();
    
42.         //获取下个灯的方法
    
43.         public abstract Lamp getNextLamp();
    
44. }

复制代码

这里用到的是匿名内部类，是类的多态的应用。格式是new 父类(){子类的实现方式}，既然是用父类的引用指向子类对象，那么子类特有的方法是不能直接调用的，除非new 父类(){子类的实现方式}.方法名来使用。