内部类：非静态内部类，静态内部类，局部内部类，匿名内部类详解

大部分时候，类被定义成一个独立的成簇单元。在某些情况下，也会把一个类放在另一个类的内部定义，这个定义在其他内部的类被称为内部类（有的地方也叫嵌套类），包含内部类的类也被称为外部类（有的地方也叫宿主类）；
内部类主要作用如下：
1. 内部类提供更好的封装，可以把内部类隐藏在外部类之内，不允许同一包中的其他类访问该类。
2. 内部类成员可以直接访问外部类的私有数据，应为内部类被当成其外部类的成员，同一个类的成员之间可以互相访问。
3. 匿名内部类适合用于创建那些仅需要一次使用的类。
内部类大致分为：非静态内部类，静态内部类，局部内部类和匿名内部类；
**

1.非静态内部类

**
（1）.可直接访问外部类的所有数据；
（2）访问内部类，必须创建对象
①外部类访问，直接创建对象
②其他类访问，外部类名.内部类名 对象名 = 外部类对象.内部类对象；
（3）当变量名与外部类重名时，用引用区分
（4）私有内部类，在外部类创建get（）方法创建内部类对象
（5）非静态内部类不能有静态成员
例1： 调用内部类，访问外部类成员

public class Test {    public static void main(String[] args) {        //外部类名.内部类名  对象名 = 外部类对象.内部类对象        A.B ab = new A().new B();             ab.print();    }}class A{    private int n =10;     //外部类成员变量    int m = 10;    private void method() {        System.out.println("method");    }    class B {        //static int a=10;        //非静态内部类不能有静态成员        public void print() {     //内部类随意访问外部类成员            System.out.println("输出结果：");            System.out.println(n);            System.out.println(m);            method();        }    }}输出结果：1010method

例2：私有内部类

class A{    private class B {        public void print() {            System.out.println("输出结果：");            System.out.println("私有内部类");        }    }    public void getB() {        //创建get（）方法        B b = new B();          //方法中生成内部类对象        b.print();    }}public class Test {    public static void main(String[] args) {        A a = new A();        a.getB();    }}输出结果：私有内部类

例3：变量名重名，引用区分

class A{    int m = 30;    class B {        int m = 20;        public void print() {            int m = 10;            System.out.println("输出结果：");            System.out.println(m);          //局部变量            System.out.println(this.m);     //内部类成员变量            System.out.println(A.this.m);   //外部类成员变量        }    }}public class Test {    public static void main(String[] args) {        A.B ab = new A().new B();        ab.print();    }}输出结果：102030

2.静态内部类

  （1）访问内部类      ①外部类访问，直接（类名.）调用      ②其他类访问，外部类名.内部类名  对象名 = 外部类名.内部类对象； （2）静态内部类不可以直接访问外部类的非静态数据

class A{    int m = 30;    static class B {        public void print() {            System.out.println("输出结果：");            //System.out.println(m);       //无法访问            System.out.println("静态内部类");        }    }}public class Test {    public static void main(String[] args) {        A.B ab = new A.B();        //A.B ab = A.new B();        ab.print();                //两者等效，前者更符合书写习惯；    }}输出结果：静态内部类

3.局部内部类

     定义在方法体中，相当于局部变量     局部内部类访问所在方法的变量必须用final修饰     为什么？     答：当调用这个方法时，不修饰则随方法共存亡；如果用fianl修饰，会在类加载的时候进入常量池，即使方法贪占消失，常量池仍可使用。

class A{    int m = 30;    public void method() {        final int n = 10;        class B {            public void print(){                System.out.println("输出结果：");                System.out.println(n);                System.out.println(m);            }        }        B b = new B();        b.print();    }}public class Test {    public static void main(String[] args) {        A a = new A();                          a.method();                         }}输出结果：1030

4.匿名内部类（局部内部类的一种）

     前提：存在一个类或者接口     本质：匿名内部类当做参数传递（本质把匿名内部类作为一个对象）     作用：适合创建那种只需要一次使用的类

例1：

interface C {    public void print();}class A{    public void method(){        new C() {          //实现该接口，创建接口的子类对象            public void print() {                System.out.println("输出结果：");                System.out.println("匿名内部类1");            }        }.print();       //编译看父类，运行看子类    }}   public class Test {    public static void main(String[] args) {    A a = new A();    a.method();    }}输出结果：匿名内部类1

**例2：
理解更清晰，多态，父类引用指向子类对象**

interface C {    public void print();}class A{    public C method(){        C c = new C() {            public void print() {                System.out.println("输出结果：");                System.out.println("匿名内部类2");            }        };        return c;    }}   public class Test {    public static void main(String[] args) {    A a = new A();    a.method().print();    }}输出结果：匿名内部类2