内部类的相关问题

内部类的分类

1. 成员静态内部类
2. 成员内部类
3. 局部内部类
4. 匿名内部类

成员静态内部类

使用static修饰类，访问权限可以是public,private,protected,缺省值，相当于静态成员变量。静态内部类可以直接访问外部类的静态变量，静态方法，但是不能直接访问外部类的成员变量和成员方法，只能通过[对象.变量或者方法]的方式访问。

public class OuterClass {
    private static String s1 = "静态变量";
    private String s2 = "成员变量";
    private static void m1() {
        System.out.println("静态方法");
    }
    public void m2() {
        System.out.println("成员方法");

    }

    static class InnerClass {
        private static void m1() {
            System.out.println(s1);
            //静态方法不能直接方法外部的非静态变量
            //System.out.println(s2);
            OuterClass.m1();
        }
        public void m2() {
            System.out.println(s1);
            //不能直接访问外部类的成员变量，但能通过创建对象的方式访问
            // System.out.println(s1);
            OuterClass outerClass = new OuterClass();
            outerClass.m2();
            System.out.println(outerClass.s2);
        }
    }

    public static void main(String[] args) {
        OuterClass.InnerClass.m1();
        InnerClass in = new InnerClass();
        in.m2();
    }
}

执行结果：

成员内部类

不使用static修饰类，访问权限可以是public,private,protected,缺省值，相当于成员变量。成员内部类可以直接访问外部类的所有变量，直接调用外部类的所有方法，但是成员内部类中不能定义static修饰的变量和方法。

public class OuterClass {
    private static String s1 = "静态变量";
    private String s2 = "成员变量";
    private static void m1() {
        System.out.println("静态方法");
    }
    public void m3() {
        System.out.println("成员方法");

    }

     class InnerClass {
     //不能定义静态方法和变量
        //static int i;
       // private static void m1() {}

        public void m2() {
            System.out.println(s1);
            System.out.println(s2);
            m1();
            m3();
        }
    }

    public static void main(String[] args) {
        InnerClass in = new OuterClass().new InnerClass();
        in.m2();
    }
}

局部内部类

局部内部类相当于局部变量，它可以直接访问外部的成员变量，静态变量，成员方法，静态方法，以及被final修饰的局部变量，但是局部内部类的访问权限只能是缺省值，且不能再有静态声明。

public class OuterClass {
    private static String s1 = "静态变量";
    private String s2 = "成员变量";
    private void m3() {
        System.out.println("外部类成员方法");
    }
    public void m1() {

        class InnerClass{   
            public void m2() {
                System.out.println(s1);
                System.out.println(s2);
                m3();
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.m2();
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.m1();
    }
}

匿名内部类

少定义一个类，直接使用接口，并实现接口中的方法。

public class OuterClass {
public static void test(CustomSerivce customSerivce) {
    customSerivce.login();
}
    public static void main(String[] args) {
        test(new CustomSerivce() {
            @Override
            public void login() {
                System.out.println("登录");
            }
        });
    }
}
interface CustomSerivce{
    void login();
}