在看高新技术视频。张老师在：13_用普通类模拟枚举类的实现原理.avi  中
在EnumTest.java中这样写的，这没有什么疑惑。

1. package cn.itheima.day1;
   
2. 
   
3. public class EnumTest {
   
4.         public static void main(String[] args) {
   
5.                 WeekDay wk1 = WeekDay.SUN;
   
6.                 System.out.println(wk1.nextDay());
   
7.         }
   
8. }
   

复制代码

然后第一次在WeekDay.java中是这样写，也没什么疑惑

1. package cn.itheima.day1;
   
2. 
   
3. public class WeekDay {
   
4.         private WeekDay(){}
   
5.         
   
6.         public static final WeekDay SUN = new WeekDay();
   
7.         public static final WeekDay MON = new WeekDay();
   
8.         public static final WeekDay TUE = new WeekDay();
   
9. 
   
10.         
    
11.         public WeekDay nextDay()
    
12.         {
    
13.                 if(this==SUN)
    
14.                 {
    
15.                         return MON;
    
16.                 }else if(this==MON)
    
17.                 {
    
18.                         return TUE;
    
19.                 }else
    
20.                 {
    
21.                         return SUN;
    
22.                 }
    
23.         }
    
24.         public String toString()
    
25.         {
    
26.                 if(this==SUN)
    
27.                         return "SUN";
    
28.                 if(this==MON)
    
29.                         return "MON";
    
30.                 if(this==TUE)
    
31.                         return "TUE";
    
32.                 return null;
    
33.         }
    
34. }
    

复制代码

可是第二次在WeekDay.java中是这样写的，我就不懂了。

1. package cn.itheima.day1;
   
2. 
   
3. public abstract class WeekDay {
   
4.         private WeekDay(){}
   
5.         
   
6.         public static final WeekDay SUN = new WeekDay(){
   
7.                 public WeekDay nextDay()
   
8.                 {
   
9.                         return MON;
   
10.                 }
    
11.         };
    
12.         public static final WeekDay MON = new WeekDay(){
    
13.                 public WeekDay nextDay()
    
14.                 {
    
15.                         return TUE;
    
16.                 }
    
17.         };
    
18.         public static final WeekDay TUE = new WeekDay(){
    
19.                 public WeekDay nextDay()
    
20.                 {
    
21.                         return SUN;
    
22.                 }
    
23.         };
    
24.         
    
25.         public abstract WeekDay nextDay();
    
26. /*
    
27.         
    
28.         public WeekDay nextDay()
    
29.         {
    
30.                 if(this==SUN)
    
31.                 {
    
32.                         return MON;
    
33.                 }else if(this==MON)
    
34.                 {
    
35.                         return TUE;
    
36.                 }else
    
37.                 {
    
38.                         return SUN;
    
39.                 }
    
40.         }
    
41. */        
    
42.         public String toString()
    
43.         {
    
44.                 if(this==SUN)
    
45.                         return "SUN";
    
46.                 if(this==MON)
    
47.                         return "MON";
    
48.                 if(this==TUE)
    
49.                         return "TUE";
    
50.                 return null;
    
51.         }
    
52. }
    

复制代码

在这种方法中，用的匿名内部类。匿名内部类，我也知道，毕老师的视频中有讲。但是好像没讲这种形式。不是说匿名内部有个前提条件：必须继承一个父类或实现一个接口吗？？  可是这里没有继承啊或者实现啊！！
第二：为什么要在类中定义一个  public abstract WeekDay nextDay();    ？？？
第三：张老师说public static final WeekDay SUN = new WeekDay(){   ...        }; 中的new WeekDay(){}; 是WeekDay的子类。为什么是子类呢？=================================================================
PS:刚把毕老师的匿名内部类的视频又看了一遍，明白了:lol:lol:lol

大神哪里有？

new WeekDay(){}这个创建子类方式记住就行了，刚开始也不能接受，后来也就习惯了

Nullifier 发表于 2014-10-12 20:31
new WeekDay(){}这个创建子类方式记住就行了，刚开始也不能接受，后来也就习惯了 ...

嗯，现在明白 了，谢谢。

我们从最后一个问题开始解决， WeekDay是一个抽象类对吧——“public abstract class WeekDay”最开始的定义
“抽象类是不能实例化的 换句话说抽象类是不能创建对象的”  这个你知道吧
那么为什么可以new WeekDay呢，因为这里new的不是说WeekDay的实例化对象 而是WeekDay的一个子类 ，这不过这个子类没有名字，只有一个方法，而且这个方法覆盖了父类方法，如果觉得复杂我给你举个例子吧，我简单些，不那么规范了
第一步 class FU
{  fangfa（）{} }
class ZI_1 extends FU
{ fangfa（）{ daima1 }  }class ZI_2 extends FU
{ fangfa（）{ daima2 } }
...很多个子类  FU类里面只有一个抽象方法，引用时没有任何意义的，子类方法覆盖父类方法，
如果主函数里面要引用子类的方法，由于父类不能实例化，所以只能创建子类对象


FU obj = new ZI_1（）；obj.fangfa（）这里懂了那么
第二步 这个子类可以写到FU类里面 作为内部类 这没有任何问题吧
class FU
{    class ZI_1    /* extends FU */内部类会隐示的继承外部类
         { fangfa() { daima1 } }
      fangfa(){}
}
第三步 如果只引用一次子类的方法 那么还要单独写一个类是不是很麻烦 这样就产生了匿名内部类
class FU
{  
      new FU(){ fangfa() { daima1 } }  若前面有变量名字 那么这个名字是这个（匿名子类的对象）的名字，也就是说子类没名字，但它的对象有名字
      fangfa(){}
}