《day11---内部类&匿名内部类》

 //79-80-面向对象-内部类-体现
 /*
 当A类中的内容要被B类直接访问，而A类还需要去创建B类的对象，访问B的内容时，
 这时可以将B类定义到A类的内部，这样访问更为便捷。

 将B类称之为内部类（内置类，嵌套类）.

 访问方式总结：
 内部类可以直接访问外部类中的所有成员，包含私有的。
 而外部类要想访问内部类中的成员，必须创建内部类对象。

 当描述事物时，事物的内部还有事物时，而这个内部的事物还在访问外部事物中的内容。
 这时就将这个事物通过内部类来体现。

 【内部类被访问的方式】
 情况一：内部类在成员位置上的被访问方式。
         成员是可以被指定的修饰符所修饰的。
         public :不多见，因为更多的时候，内部类已经被封装到了外部类中，不直接
                         对外提供。
         static:
 */

 class Outer//外部类
 {
     private static int num = 4;

     public class Inner//内部类
     {
 //        static final int x = 3;
         void show()
         {
             System.out.println("num="+num);
         }
         static void show1(){}//非静态内部类中不允许定义静态成员。仅允许在
                              //非静态内部类中定义常量。（final）
                              //如果想要在内部类中定义静态成员，那么内部类也必须
                              //别静态修饰。
     }

     /*
     内部类被静态修饰后，随着Outer的加载而加载，可以把一个静态内部类理解为就是一个外部类。
     */
     static class Inner2
     {
         void show2()
         {
             System.out.println("Inner2 show2 run..."+num);
         }
         static void staticShow()
         {
             System.out.println("Inner2 staticShow run");
         }
     }
     void method()
     {
         //Outer.Inner in = new Outer.Inner();//这样写也是可以的。
         Inner in = new Inner();
         in.show();
     }
 }

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

         //测试情况一：直接访问Outer类中的内部类的非静态成员。

         //创建内部类的对象就可以了,内部类作为成员，应该先有外部类对象，再有内部类对象。
 //        Outer.Inner in = new Outer().new Inner();
 //        in.show();

         //测试二：对静态内部类中的非静态成员进行调用，如何弄？
         //因为内部类是静态，所以不需要创建Outer的对象，直接创建内部类对象就行了。
 //        Outer.Inner2 in = new Outer.Inner2();
 //        in.show2();

         //如果静态内部类中有静态成员该如何访问呢？既然静态内部类已随外部类加载，而且
         //静态成员随着类的加载而加载，这时就不需要对象，直接用类名调用即可。
         Outer.Inner2.staticShow();

     }
 }

 //81-面向对象内部类访问外部类的原因。
 /*
 为什么内部类就能直接访问外部类中的成员呢？
 那是因为内部类持有了外部类的引用 外部类.this

 对于静态内部类不持有 外部类.this 而是直接使用外部类名。
 */
 class Outer
 {
     int num = 3;

     class Inner
     {
         int num = 4;
         void show()
         {
             int num = 5;
             System.out.println("num="+num);
             System.out.println("num="+this.num);
             System.out.println("num="+Outer.this.num);
         }
     }
     void method()
     {
         //System.out.println(/*Outer.this.*/num);
         new Inner().show();
     }
 }
 class  InnerClassDemo2
 {
     public static void main(String[] args)
     {
         Outer out = new Outer();
         out.method();
     }
 }

 /*
 内部类其实也可以定义在外部类的局部变量位置上。

 内部类定义在局部时，只能访问被final修饰的局部变量。
 为啥呢？因为编译生成的class中直接操作那个最终的数值了。
 所以可以访问final，因为其值不会变化。

 为什么不能访问非最终的局部变量呢？
 */
 class Outer
 {
     int num = 3;
 //    Object obj;

     void method()
     {
          int x = 5;//局部变量。省略的final修饰符。
 //         x = 4;       //编译失败，因为x默认为final的。
          int y = 3;
         class Inner//局部内部类。不能被成员修饰符修饰。
         {
             void show()
             {
                 System.out.println("x="+x);
                 System.out.println("x="+y);//若y没有加默认的final修饰符，则
                                             //访问失败，因为y的声明周期太短了。
                 System.out.println("Inner show run..."+num);
             }
         }
         new Inner.show();
 //        obj = new Inner();
     }
 }

 class Outer2
 {
     Object obj;
     public void method()
     {
         int y = 9;
         class Inner//extends Object
         {
             //覆盖了toString方法
             public String toString()
             {
                 return "tostring"+y;//假设可以访问。
             }
         }
         obj = new Inner();//给obj赋一个Inner对象。
     }
     public void function()
     {
         System.out.println(obj.toString());
     }
 }

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

 //83-84内部类-内部类的继承或者实现&匿名内部类。
 /*
 看API,发现类名或者接口的名称中有 . 说明是内部类，或者内部接口。

 内部了的延伸。
 内部类是可以继承或者实现外部其他的类或者接口的。

 好处在于，通过内部类的方式对类进行继承重写，或者接口进行实现。
 通过公共的方式对其内部类对象进行访问，因为通常内部类很有可能被外部类封装其中。
 我们就可以通过接口的方式访问到内部类。

 对以下代码进行简化。
 匿名内部类，其实就是一个带有内容的子类对象。
 格式： new 父类or接口()(子类内容。)

 匿名内部类就是内部类的简化形式。
 别忘了，凡是简化的都有局限性。匿名内部类有前提，
 匿名内部类必须继承父类或者实现接口。
 */

 //定义一个抽象的外部类。
 abstract class AbsDemo
 {
     abstract void show();
 }

 class Outer
 {
     int num = 3;
     /*
      class Inner extends AbsDemo
     {
         //重写抽象方法show。
         void show()
         {
             System.out.println("num="+num);
         }
     }

     //获取内部类的对象。
     public AbsDemo getObject()//多态：AbsDemo abs = new Inner();
     {
         return new Inner();
     }
     */
     public void method()
     {
 //        new Inner().show();
         /*
         不想创建具体的子类型，还想创建AbsDemo的子类对象。
         怎么实现呢？没有子类型，干脆直接使用父类型就可以了。
         可是在该例子中是抽象类，怎么可以new对象呢？
         抽象类之所以不能new对象，是因为抽象方法没有被覆盖。只要
         重写不就可以了吗？
         */
         new AbsDemo()//这就是一个AbsDemo的子类对象。只不过这个对象有点胖。
                     //这是一个带着内容的子类对象。
                     //这种写法有一个称呼，叫做【匿名内部类】。
         {
             //直接就重写抽象的show方法。
             void show()
             {
                 System.out.println("num==="+num);
             }
         }.show();
     }
 }

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

         //如果Inner对外提供，可以如此获取。
         //Outer.Inner in = out.getObject();
         //in.show();

         //如果Inner被private，可以通过父类型获取。
         //AbsDemo a = out.getObject();
         //a.show();

         Outer out = new Outer();
         out.method();
     }
 }

 //86-内部类-匿名内部类的使用。
 interface Inter
 {
     void show1();
     void show2();
     //方法超过两个，建议不要写成匿名内部类。
 }

 class Outer
 {
     int num = 4;

     //在一个类中使用一个接口，可以通过内部类来实现。
     /*
     class Inner implements Inter
     {
         public void show1(){}
         public void show2(){}
     }
     */
     public void method()
     {
         /*
         Inner in = new Inner();
         in.show1();
         in.show2();
         */

         //对其简化，写成匿名内部类的形式。
         Inter in = new Inner()//多态，父类的引用指向了子类对象。
         {
             public void show1(){}
             public void show2(){}
         };
         in.show1();
         in.show2();
     }
 }
 class  InnerClassDemo5
 {
     public static void main(String[] args)
     {
         System.out.println("Hello World!");
     }
 }

 //87-匿名内部类练习。
 interface Inter
 {
     public void show();
 }

 class Outer
 {
     //代码补足。要求使用匿名内部类。
     public static Inter method()
     {
         //既然在Outer类中使用到了Inter对象，可以使用内部类来完成。
         //需要子类型，只要简化形式即可，因为接口中就只有一个方法。

         /*
         return new Inter()
         {
             public void show()
             {
                 code...;
             }
         };
         */
 //        return this.new Inter();
 //    }

     //还原成内部类。当静态方法访问内部类时，内部类必须是静态的。
 /*    static class Inner implements Inter
     {
         public void show(){}
     }
 */
     }
 }

 //面试题：
 class Outer2
 {
     public void method()
     {
         //以下两个对象有区别吗？
         new Object()//当new Object();时，是创建Object对象，而写成new Object(){}时，创建
                     //的是Object的子类对象。
         {
             public void show(){}
         }.show();//这个可以编译通过

         Object obj = new Object()
         {
             public void show(){}
         };
         obj.show();//编译失败。为啥呢？因为匿名内部类是子类对象，当Object obj指向
                     //时，就被提升了，而Object类中没有定义show()方法。编译失败。

     }
     /*
         //写一个内部类。
         class Inner extends Object//有父类，可以简化成匿名内部类。
         {
             public void show(){}
         }
     */
 }

 class InnerClassDemo7
 {
     public static void main(String[] args)
     {
         Outer.method().show();
         /*
         Outer.method():Outer类中有一个method方法，这个方法时静态的。
         Outer.method().show():能调用show()的必然是对象。说明method方法运算完应
                               该放回一个对象，而且能调用Inner中的方法，说明
                               这个对象类型是Inner的。
         */
     }
 }