内部类的调用

内部类

内部类分为4种：静态内部类，成员内部类、匿名内部类和方法内部类，以下进行demo的演示。

package InnerJava

/**
 * 内部类
 * 1. 静态内部类: 建造者模式
 * 2. 成员内部类: 非常常用
 * 3. 方法内部类：特别少用
 * 4. 匿名内部类: 如果某个局部类你只需要用一次，那么你就可以使用匿名内部类
 */
class Test {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            // 测试 静态内部类的调用
            StaticInner.helloWorld() // StaticInner helloWorld

            // 测试 成员内部类的调用
            val memberInner = MemberInner()
            memberInner.helloWorld() // MemberInner helloWorld

            // 测试 方法内部类
            val local = Local()
            local.localMethod() // LocalInner helloWorld

            // 测试 匿名内部类
            /**
             * 匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。
             * Anonymous mAnonymous = new Anonymous() {
             *    @Override
             *    public void helloWorld() {
             *
             *    }
             * };
             */
            val mAnonymous: Anonymous = object : Anonymous {
                override fun helloWorld() {
                    println("AnonymousInner helloWorld")
                }
            }
            mAnonymous.helloWorld() // AnonymousInner helloWorld
        }
    }

    /**
     * 静态内部类
     * 1. 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问[简单地说，就是这个类被编译（？）的时候，static变量会被初始化有且只有一次。但非静态的变量是对象被创建的时候（即new的时候）才存在的，所以static在第一次初始化的时候，这些非静态变量根本不存在，所以也就引用不了了。]
     * 2. 外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员
     * 3. 创建静态内部类的对象时，不需要通过外部类的对象，可以直接创建 内部类 对象名= new 内部类();
     * static class StaticInner {
     *     static void helloWorld() {
     *        System.out.println("StaticInner helloWorld");
     *     }
     * }
    }
     */
    internal object StaticInner {
        fun helloWorld() {
            println("StaticInner helloWorld")
        }
    }

    /**
     * 成员内部类
     * 1. 当内部类访问外部类时，可以不受访问控制符的影响，直接访问属性与方法
     * 2. 当外部类变量与方法和内部类同名，内部类默认访问自己的成员变量或方法，引用外部变量使用时加类名.this：类名.this.变量名、类名.this.方法名（）
     * 3. 在其他类创建一类中的内部类：内部类 对象名 = new 外部类对象( ).new 内部类( )
     * 4. 外部类不能直接使用内部类的成员和方法,可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
     * public class MemberInner{
     *     public void helloWorld() {
     *         System.out.println("MemberInner helloWorld");
     *     }
     * }
     */
    class MemberInner {
        fun helloWorld() {
            println("MemberInner helloWorld")
        }
    }

    /**
     * 方法内部类
     * 1. 在类的方法中定义，只能在同一个作用域使用，不存在外部可见性
     * 2. 没有访问修饰符，但可以使用final 或 abstract修饰。
     * 3. 不能在方法内部类中创建可变的局部变量。
     * 4. 可以访问外围类的成员变量。如果是static方法，则只能访问static修饰的成员变量。
     *
     * public class Local {
     *    public void localMethod() {
     *        class LocalInner {
     *            public void helloWorld() {
     *                System.out.println("LocalInner helloWorld");
     *        }
     *    }
     *
     *        LocalInner localInner = new LocalInner();
     *        localInner.helloWorld();
     *    }
     * }
     */
    class Local {
        fun localMethod() {
            class LocalInner {
                fun helloWorld() {
                    println("LocalInner helloWorld")
                }
            }

            val localInner = LocalInner()
            localInner.helloWorld()
        }
    }

    /**
     * 匿名内部类调用的接口（实现接口的匿名类用途）
     */
    internal interface Anonymous {
        fun helloWorld()
    }
}