快速了解Java内部类

用代码看懂java内部类

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

对比成员内部类,局部内部类,匿名内部类静态内部类
实例化实例化前必须实例化外部类对象 Outer o = new Outer() ;Inner i = o.new Inner();或者直接new Outer().new Inner()实例化前不需要实例化外部类对象 Inner i = new Inner()
对外部类的访问可以访问外部类所有的属性、方法,不受访问控制符限制只能访问外部类的静态属性、方法
访问外部类的同名变量Outer.this.aOuter.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

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值