黑马程序员技术交流社区

标题: 匿名内部类的问题 [打印本页]
作者: 小黑子    时间: 2014-10-12 17:38
标题: 匿名内部类的问题
本帖最后由 小黑子 于 2014-10-12 20:37 编辑

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

  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;

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

  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;

  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



作者: 小黑子    时间: 2014-10-12 19:00
大神哪里有？
作者: Nullifier    时间: 2014-10-12 20:31
new WeekDay(){}这个创建子类方式记住就行了，刚开始也不能接受，后来也就习惯了
作者: 小黑子    时间: 2014-10-12 20:38
Nullifier 发表于 2014-10-12 20:31
new WeekDay(){}这个创建子类方式记住就行了，刚开始也不能接受，后来也就习惯了 ...

嗯，现在明白 了，谢谢。
作者: 英雄传说ER    时间: 2014-10-12 20:52
我们从最后一个问题开始解决， 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(){}
}





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2