快速了解Java内部类

用代码看懂java内部类

Java内部类主要分为成员内部类，局部内部类，匿名内部类以及静态内部类

对比	成员内部类，局部内部类，匿名内部类	静态内部类
实例化	实例化前必须实例化外部类对象 Outer o = new Outer() ;Inner i = o.new Inner();或者直接new Outer().new Inner()	实例化前不需要实例化外部类对象 Inner i = new Inner()
对外部类的访问	可以访问外部类所有的属性、方法，不受访问控制符限制	只能访问外部类的静态属性、方法
访问外部类的同名变量	Outer.this.a	Outer.a
内部类的定义	不能定义static数据和字段，不能包含静态内部类	都可以

class Animal{
    public void eat(){
        System.out.println("动物要吃饭");
    }
}

public class Outer {
    //外部类的属性
    private int a = 1;
    int b = 2;
    protected int c = 3;
    public int d = 4;
    static int e = 5;
    int g = 100;

    //成员内部类
    public class MemInner{
        //成员内部类不能定义static数据和字段
        //static int e = 54;
        int g = 54;
        MemInner(){
            System.out.println("****成员内部类****");
            //成员内部类可以访问外部类所有的数据，不受访问控制符限制
            System.out.println("MemInner访问外部类的private属性 " + a);
            System.out.println("MemInner访问外部类的默认属性 " + b);
            System.out.println("MemInner访问外部类的protected属性 " + c);
            System.out.println("MemInner访问外部类的public属性 " + d);
            System.out.println("MemInner访问外部类的static属性 " + e);
            System.out.println("MemInner访问外部类的同名非静态变量 " + Outer.this.g);
        }
    }

    //局部内部类
    public void getMethodInner(){
        //方法内部类
        //方法内部类的定义不能加访问修饰符
        class MethodInner{
            //方法内部类不能定义static数据和字段
            //static int e = 54;
            int g = 54;
            MethodInner(){
                System.out.println("****方法内部类****");
                System.out.println("MethodInner访问外部类的private属性 " + a);
                System.out.println("MethodInner访问外部类的默认属性 " + b);
                System.out.println("MethodInner访问外部类的protected属性 " + c);
                System.out.println("MethodInner访问外部类的public属性 " + d);
                System.out.println("MethodInner访问外部类的static属性 " + e);
                System.out.println("MethodInner访问外部类的同名非静态变量 " + Outer.this.g);
            }
        }
        MethodInner m = new MethodInner();

        //作用域内部类
        if(a > 0){
            class ScopeInner{
                //作用域内部类不能定义static数据和字段
                //static int e = 54;
                int g = 54;
                ScopeInner(){
                    System.out.println("****作用域内部类****");
                    System.out.println("ScopeInner访问外部类的private属性 " + a);
                    System.out.println("ScopeInner访问外部类的默认属性 " + b);
                    System.out.println("ScopeInner访问外部类的protected属性 " + c);
                    System.out.println("ScopeInner访问外部类的public属性 " + d);
                    System.out.println("ScopeInner访问外部类的static属性 " + e);
                    System.out.println("ScopeInner访问外部类的同名非静态变量 " + Outer.this.g);
                }
            }
            ScopeInner s = new ScopeInner();
        }
    }

    //匿名内部类
    public Animal fun(){
        new Animal(){
            //匿名内部类不能定义static数据和字段
            //static int e = 54;
            int g = 54;
            public void eat(){
                System.out.println("****匿名内部类****");
                System.out.println("匿名内部类访问外部类的private属性 " + a);
                System.out.println("匿名内部类访问外部类的默认属性 " + b);
                System.out.println("匿名内部类访问外部类的protected属性 " + c);
                System.out.println("匿名内部类访问外部类的public属性 " + d);
                System.out.println("匿名内部类访问外部类的static属性 " + e);
                System.out.println("匿名内部类访问外部类的同名非静态变量 " + Outer.this.g);
                System.out.println("狗要吃屎");
            }
        }.eat();
        return new Animal();
    }

    //静态内部(嵌套)类
    public static class StaticInner{
        static int e = 54;
        StaticInner(){
            System.out.println("****静态内部(嵌套)类****");
            //静态内部类无法访问外部类的非静态属性，就像类的静态方法只能访问静态属性一样
            //System.out.println("StaticInner访问外部类的private属性 " + a);
            //System.out.println("StaticInner访问外部类的默认属性 " + b);
            //System.out.println("StaticInner访问外部类的protected属性 " + c);
            //System.out.println("StaticInner访问外部类的public属性 " + d);
            System.out.println("StaticInner访问外部类的同名static属性 " + Outer.e);
        }

    }

    public static void main(String[] args) {
        //成员内部类
        //必须先创建外部类对象，才能创建成员内部类 成员内部类 成员内部类对象 = 外部类对象.new 成员内部类()
        MemInner m= new Outer().new MemInner();

        //局部内部类 包括 方法内部类 + 作用域内部类
        //必须先创建外部类对象，才能创建成员内部类 成员内部类 成员内部类对象 = 外部类对象.new 成员内部类()
        new Outer().getMethodInner();

        //匿名内部类
        //必须先创建外部类对象，才能创建成员内部类 成员内部类 成员内部类对象 = 外部类对象.new 成员内部类()
        Animal a = new Outer().fun();

        //静态内部(嵌套)类
        //不需要创建外部类对象
        StaticInner s = new StaticInner();


    }
}

//输出
****成员内部类****
MemInner访问外部类的private属性 1
MemInner访问外部类的默认属性 2
MemInner访问外部类的protected属性 3
MemInner访问外部类的public属性 4
MemInner访问外部类的static属性 5
MemInner访问外部类的同名非静态变量 100
****方法内部类****
MethodInner访问外部类的private属性 1
MethodInner访问外部类的默认属性 2
MethodInner访问外部类的protected属性 3
MethodInner访问外部类的public属性 4
MethodInner访问外部类的static属性 5
MethodInner访问外部类的同名非静态变量 100
****作用域内部类****
ScopeInner访问外部类的private属性 1
ScopeInner访问外部类的默认属性 2
ScopeInner访问外部类的protected属性 3
ScopeInner访问外部类的public属性 4
ScopeInner访问外部类的static属性 5
ScopeInner访问外部类的同名非静态变量 100
****匿名内部类****
匿名内部类访问外部类的private属性 1
匿名内部类访问外部类的默认属性 2
匿名内部类访问外部类的protected属性 3
匿名内部类访问外部类的public属性 4
匿名内部类访问外部类的static属性 5
匿名内部类访问外部类的同名非静态变量 100
狗要吃屎
****静态内部(嵌套)类****
StaticInner访问外部类的同名static属性 5