JAVA 内部类

       内部类是指在一个外部类的类体里面还定义（包含）一个类，内部类作为外部类的一个成员，依附于外部类而存在。
       根据内部类所处的位置的不同，java中的内部类分为四种：静态内部类、成员内部类、 局部内部类、匿名内部类。
       静态内部类：1）使用static修饰，声明在外部类的类体之中
                             2）在静态内部类的类体中可以访问外部类的静态成员，不可以访问外部类的非静态成员。
       成员内部类：1）声明在外部类的类体之中，不使用static修饰，具有类的成员特征，即必须有类的实例才能创建内部类的实例。
                             2）内部类的实例可以访问和共享外部类的成员变量（此经常使用）。
                             3）如：链表的节点就可以定义为内部类。  
       局部内部类：1）将类声明在方法之中，就是局部内部类 ，类似于局部变量（此很少见）。
       匿名内部类：1）匿名内部类非常常见，可以声明（定义）在任何地方，就像一般的语句一样。
                             2）语法极其像是在创建对象：Date  date = new Date(){//.........};
                             3）匿名内部类是对原类的一种继承，同时创建了实例，{ } 就是继承以后的类体，类体中可以使用所有类的语法。
                             4）匿名内部类不能写构造器（构造方法）。
                             5）匿名内部类可以从抽象类或者接口继承，但是必须提供抽象方法的实现。
      任何的内部类在编译时都编译成独立的class文件。内部类最大的作用------->封装！匿名内部类可以封装内部概念，如情侣间的“土豆”和菜市场的“土豆”是不一样的。

案例：
        1）静态内部类的创建与调用
         package com.lifubo.inner1;

         public class Demo1 {
             public static void main(String[] args) {
                  Foo1.Koo1 koo1 = new Foo1.Koo1();
                  System.out.println(koo1.add());
                }

           }

           class Foo1{
                     int num1;//默认num1=0;
                     static int num2;
                     static class Koo1{
                               int add(){
                               //return num1+1;静态内部类不能访问外界的非静态变量
                                 return num2+2;//静态内部类可以访问外界的静态变量
                                }
                     }
               }
      运行结果：2
  
2）成员内部类的创建与调用
        package com.lifubo.inner1;
        //import inner2.Foo.Koo;
        public class Demo2 {
             public static void main(String[] args) {
                  Foo foo = new Foo();
                  Foo.Koo koo = foo.new Koo();//foo.new : 特别记忆
                  System.out.println(koo.add());
                   }

          }
         class Foo{
                  int a = 12;
                  static int b = 15;
                   class Koo{
                          int add(){
                           return a+b;//成员内部类可以访问外界的任意属性*
                          }
                     }
           }
        运行结果：27
 
3）局部内部类的创建与访问
        package com.lifubo.inner1; 
        import java.util.Arrays;
        import java.util.Comparator;

        public class Demo3{
                 public static void main(String[] args) {
                          final int a = 13;
                          class Koo1{
                                   int b = 3;
                                   int add(){
                                   return a+b;//局部内部类使用外界变量的时候，必须使用final来修饰该变量
                                   }
                           }
                  Koo1 koo1 = new Koo1();
                  System.out.println(koo1.add());
  
                  String[] strs = {"aaaaa","bb","z","ccc"};
                  Arrays.sort(strs);//排序
                  System.out.println(Arrays.toString(strs));
                  class ByLength implements Comparator<String>{ //制定比较的规则
                           public int compare(String arg0, String arg1) {
                                    return arg0.length()-arg1.length();
                           }
   
                      }
                  Arrays.sort(strs,new ByLength());//根据既定规则进行排序
                  System.out.println(Arrays.toString(strs));
              }

        }
  运行结果：16
                   [aaaaa, bb, ccc, z]
                   [z, bb, ccc, aaaaa]
 
4）匿名内部类的创建与访问
        package com.lifubo.inner1; 
        public class Demo4 {
             public static void main(String[] args) {
                     final int num1 = 12;
                     final int num2 = 12;
                     Person person = new Person(){//先继承，然后实例化
                    //在匿名内部类中，可以new抽象类的构造方法，但是在{}内部要重写该抽象方法
                   //匿名内部类使用外界的变量，该变量必须使用final修饰
                               void add() {
                                         System.out.println(num1+num2);    
                                 }   
                       };
                      person.add();
  
                      final int num3=23,num4=32;
                      Person2 person2 = new Person2(){
                                public void add() {
                                        System.out.println(num3+num4);   
                                 }  
                       };
                      person2.add();
                 }

        }
        abstract class Person{
               abstract void add();
        }
        interface Person2{
                void add();
         }
   运行结果：24
                    55