【java系列】内部类之四大内部类详解

什么是内部类？

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

内部类的分类有哪些 4`

分别有以下几种：
静态内部类，成员内部类，局部内部类，匿名内部类

静态内部类

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

package objectOrientedTest.innerClass;

public class ClassDemo {
    /**
    * 静态内部类
    */
    static class StaticInner{
        void test(){
            System.out.println("静态内部类");
        }
    }

}

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；

静态内部类的创建方式，new 外部类.静态内部类()，如下：

package objectOrientedTest.innerClass;

public class Test {

    public static void main(String[] args) {
        /**
         * 获取静态内部类
         */
        ClassDemo.StaticInner staticInner = new ClassDemo.StaticInner();
        staticInner.test();

    }
}

成员内部类

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

package objectOrientedTest.innerClass;

public class ClassDemo {
    /**
    * 成员内部类
    */
    class MemberInnerClass{
        void test(){
            System.out.println("成员内部类");
        }
    }

}

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

package objectOrientedTest.innerClass;

public class Test {

    public static void main(String[] args) {
        /**
         * 获取成员内部类
         */
        ClassDemo classDemo = new ClassDemo();
        ClassDemo.MemberInnerClass memberInnerClass = classDemo.new MemberInnerClass();
        memberInnerClass.test();
    }
}

局部内部类

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

package objectOrientedTest.innerClass;

public class ClassDemo {
    public void test(){

        /**
         * 局部内部类
         */
        class LocalInner{
            void test(){
                System.out.println("局部内部类");
            }
        }

        /**
        * 方法里面是无法使用static的,所以没有局部静态内部类的说法
        */
//        static class StaticLocalInner{}

        /**
        * 局部内部类实例化
        */
        LocalInner localInner = new LocalInner();
        localInner.test();
    }

}

package objectOrientedTest.innerClass;

public class Test {

    public static void main(String[] args) {
        /**
        * 调用方法
        */
        classDemo.test();
    }
}

匿名内部类

匿名内部类就是没有名字的内部类，日常开发中使用的比较多。
实现方式一般分为两种，一种是继承抽象类，一种是实现一个接口

格式如下：

new 父类类名(参数){
	重写父类中相关功能
}

new 接口名(){ 
    重写接口的抽象方法 
}

方式一：实现接口

package objectOrientedTest.innerClass;

public class ClassDemo {
    /**
    * 如果有参数需要被匿名内部类使用，需要设置成final
    */
    public void testAnonymousInner(final String name){
        /**
         * 匿名内部类
         * new 接口（）.方法
         * 然后里面重写接口的方法
         */
        new MyService(){
            @Override
            public void method() {
                System.out.println("执行匿名内部类");
                System.out.println(name);
            }
        }.method();
    }


    /**
    * 定义接口和方法
    */
    interface MyService{
        void method();
    }


}

方式二：继承抽象类

package objectOrientedTest.innerClass;

public class ClassDemo {
    /**
    * 继承抽象类实现匿名内部类
    */
    public void testAnonymousInner2(final String name){
        new MyAbstractCls(){
        }.method(name);
    }

    abstract class MyAbstractCls{
        void method(final String name){
            System.out.println("执行匿名内部类");
            System.out.println(name);
        }
    }

}

匿名内部类特点

1、匿名内部类必须继承一个抽象类或者实现一个接口。
2、匿名内部类不能定义任何静态成员和静态方法。
3、当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
4、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

内部类的优点

• 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
• 内部类不为同一包的其他类所见，具有很好的封装性；
• 内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
• 匿名内部类可以很方便的定义回调。

内部类有哪些应用场景 4·

1. 一些多算法场合
2. 解决一些非面向对象的语句块。
3. 适当使用内部类，使得代码更加灵活和富有扩展性。
4. 当某个类除了它的外部类，不再被其他的类使用时。

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

局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final呢？它内部原理是什么呢？
先看这段代码：

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

• 因为生命周期不一致，
• 局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁。
• 而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。
• 加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题。

内部类相关，看程序说出运行结果

public class Outer {
    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("外部类变量：" + Outer.this.age);
        }
    }
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner();
        in.print();
    }
}
运行结果：
局部变量：14
内部类变量：13
外部类变量：12