java基础--笔记10



非静态内部类中不可以定义静态成员。

1，匿名内部类其实就是内部类的简写格式

2，定义匿名内部类的前提：

     内部类必须继承一个类类或者实现接口

3，匿名内部类的格式： new 父类或者接口（）{定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象，而且这儿对象有点胖，也可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

abstract class Abs
{
     abstract void show();
}
class Outer
{
     void method()
     {
         
          /*
          new Abs(); 这里无法创建Abs的对象，为什么呢？原因它是个抽象类。
          只有一个类继承了这个抽象类，并且把它里面的所有
          抽象方法都复写了，这时我们就可以创建抽象类的子类对象。
         
          发现子类仅仅就是为复写父类中的方法，并且就是为了创建一个对象，而让
          Inner继承Abs。这个Inner显得很孤独。

          我们不想写任何类，继承Abs，直接创建Abs对象，调用方法，可是这个和抽象类不能创建对象矛盾

          为了解决这个问题，Java给提供匿名内部类来解决。
          什么是匿名内部类呢？没有名字的类，就为匿名类。把没名字类写了其他类的内部。

          匿名对象的书写格式：
          new 父类名(接口名)
          {
         
          };
          只要看到上面的这种格式，这个对象就是父类的子类对象，或者实现了接口的子类对象。


          匿名内部类是内部的简化形式，它的可读性相当差的。在开发中，不建议使用匿名内部类 。

          */

          /*
          class Inner extends Abs
          {
               void show()
               {
                    System.out.println("Inner show run");
               }
          }
          Abs in = new Inner();
          in.show();
          */
         
          new Abs()//它就是匿名内部类。这个类就是Abs子类对象。
          { 
               void show()
               {
                    System.out.println("匿名内部类");
               }
          }.show();
     }


}


class InnerDemo4
{
     public static void main(String[] args)
     {
          Outer out = new Outer();
          out.method();
     }
}

//面试题
class Outer2
{
     void method()
     {
          class Inner extends Object
          {
               void show()
               {
                    System.out.println("show");
               }
          }
          Inner in = new Inner();
          in.show();

          new Object(){
               void show()
               {
                    System.out.println("new Object() show");
               }
          }.show();  // 编译运行都没有问题

          Object obj = new Object(){
               void show()
               {
                    System.out.println("new Object() show");
               }
          };
          obj.show();//编译失败。
          /*
               为什么？
               new Object(){};这样是一个Object的子类对象，把这个子类对象赋给了Object的引用。这时将发生类型提升。多态
               这时只能调用父类中的方法。

          */


     }
}


class InnerDemo5
{
     public static void main(String[] args)
     {
          Outer2 out = new Outer2();
          out.method();
     }
}

练习

interface Inter
{
     public void show();
}
class Outer
{
     //代码补足。要求使用匿名内部类。
     public static Inter method() // 分析，返回值类型为接口的引用
     {                        接口不能创建对象，找个子类实现
          /*
         可以： class InterImpl implements Inter
          {
               public void show()
               {
               }
          }
          InterImpl t = new InterImpl();
          return t;

       或   Inter t = new Inter()
          {
               public void show()
               {
               }
          };
          return t;
         
        或   return new Inter()
          {
               public void show()
               {
               }
          };
          */

//          return new InterImpl(); 报错
    }
     class InterImpl implements Inter
     {
          public void show()
          {
               System.out.println("hhahahah");
          }
     }
}
class InnerTest
{
     public static void main(String[] args)
     {
          Outer out = new Outer();
          Inter in = out.method();
          in.show();
         
     }
}