深入了解内部类，面试常问

首先，先了解一下，什么是内部类？

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内 部类本身就是类的一个 属性，与其他属性定义方式一致。

内部类的分类有哪些？

内部类可以分为四种：成员内部类；局部内部类，匿名内部类和静态内部类。

静态内部类：

定义在类内部的静态类就是静态内部类。

 public class Outer {

 private static int radius = 1;

 static class StaticInner {
     public void visit() {
         System.out.println("visit outer static variable:" + radius);
        }
    }
}

静态内部类可以访问外部类所有的静态变量，但是不可访问外部类的非静态变量；静态内部类的创建方式，new外部类.静态内部类(),如下：

Outer.StaticInner inner = new Outer.StaticInner();
inner.visit

成员内部类

定义在类内部，成员位置上的非静态类，就是成员内部类。

成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，他的创建方式外部类实例.new内部类()，如下：

package List01.Listdemo;

public class text {
    private static int radius = 1;
    private int count = 2;
    public static void main(String[] args) {
        //成员内部类的创建
        text outer = new text();
        text.Inner inner = outer.new Inner();
        inner.visit();
    }
    class Inner {
        public void visit() {
            System.out.println("visit outer static variable:" + radius);
            System.out.println("visit outer variable:" + count);
        }
    }
}

局部内部类

定义在方法中的内部类就是局部内部类

定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法 中的局部类只能访问外 部类的静态变量和方法。局部内部类的创建方式，在对应 方法内，new 内部类()，如下：

package List01.Listdemo;

public class text {
    private int out_a = 1;
    private static int STATIC_b = 2;

    public static void main(String[] args) {
        testStaticFunctionClass();
        //testFunctionClass();Non-static method 'testFunctionClass()' cannot be referenced from a static context
    }
    public void testFunctionClass() {//非静态方法主函数调用不了
        int inner_c = 3;
        class Inner {
            private void fun() {
                System.out.println(out_a);
                System.out.println(STATIC_b);
                System.out.println(inner_c);
            }
        }
        Inner inner = new Inner();
        inner.fun();
    }

    public static void testStaticFunctionClass() {
        int d = 3;
        class Inner {
            private void fun() {
                // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
                System.out.println(STATIC_b);
                System.out.println(d);
            }
        }
        Inner inner = new Inner();
        inner.fun();
    }
}

匿名内部类

匿名内部类就是没有名字的内部类，日常开发中使用的比较多。

除了没有名字，匿名内部类还有以下特点：

匿名内部类必须继承一个抽象类或者实现一个接口。

匿名内部类不能定义任何静态成员和静态方法。

当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。

匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方 法。

public class text {
    private void test(final int i) {
        //匿名类的实现方式
        new Service() {
            public void method() {
                for (int j = 0; j < i; j++) {
                    System.out.println("匿名内部类");

                }
            }
        }.method();
    }
}

//匿名内部类必须继承或实现一个已有的接口
interface Service {
    void method();
}

内部类的优点

我们为什么要使用内部类呢？因为他又以下有点：

1. 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！

2. 内部类不为同一包的其他类所见，具有很好的封装性；

3. 内部类有效的实现了“多重继承”，优化java单继承的缺陷；

4. 匿名内部类可以很方便的定义回调；

内部类有哪些应用场景

1. 一些多算法场景；

2. 解决一些非面向对象的语句块；

3. 适当使用内部类可以是代码更加灵活和富有扩展性；

4. 当某个类除了他的外部类，不能再被其他类使用的时候。

局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final?

我们先来看接下这段代码，再来分析。

public class text {
    void outMethod() {
        final int a = 10;
        class Inner {
            void innerMethod() {
                System.out.println(a);
            }
        }
    }
}

以上例子，为什么要家final呢？因为生命周期不一致，局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁了。而局部内部类堆局部变量的引用还在，如果局部内部类要用局部变量的时候，就会出去，而加上final，可以确保局部内部类使用的变量与外层的局部变量区分开，就可以解决这个问题

例题

public class text {
    private int age = 12;//外部类变量

    class Inner {
        private int age = 13;//内部类变量

        public void print() {
            int age = 14;//局部变量
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + text.this.age);
        }
    }

    public static void main(String[] args) {
        text.Inner in = new text().new Inner();
        in.print();
    }
}

运行结果：

局部变量：14 内部类变量：13 外部类变量：12

package List01.Listdemo;

public class text {
    public static void main(String[] args) {
        TFT t = new TFT();
        new TFT(){
            public void fly(){
                System.out.println("为什么不用我");
            }
        }.getNolove().show();
        int number = t.getNolove().Number;
        TFT t1=new DNF();
        t1.fly();
        DNF d = new DNF();
        new DNF(){
            public void fly(){
                System.out.println("作者太牛了!");
            }
        }.fly();

        d.fly();
        System.out.println("取出的数为:"+number);
    }
}

class TFT{

     TFT(){
         System.out.println("为什么调用我");
        }

    public void fly(){
        System.out.println("我为什么不调用");
    }

    public NoLove getNolove(){
        return new NoLove();
    }

    class NoLove {
        int Number = 30;
        public void show(){
            System.out.println("作者真帅");
        }
    }
}

class DNF extends TFT{
    public void fly(){
        System.out.println("读者比作者差点");
    }
}

输出结果