JavaSE 基础(十二) 内部类

翁佳明

已于 2023-10-07 00:29:31 修改

阅读量75

点赞数 2

分类专栏： JavaSE 文章标签： java 开发语言笔记 jvm

于 2023-10-07 00:22:14 首次发布

本文链接：https://blog.csdn.net/m0_64003319/article/details/133470303

版权

JavaSE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

2.2在实例内部类当中,不能定义静态的成员变量

前言

Hi~ 你好!

欢迎点击我的博客 : )

这是我的学习总结,希望也能帮助到你

我的博客地址:hi~,我在这里~,欢迎关注哦,

三连不迷路,优质内容持续更新!

一.内部类

1.静态内部类

class OuterClass {//外部类
    public int data1 = 1;
    private int data2 = 2;//外部类的成员变量
    private static int data3 = 3;//外部类的静态成员变量
    private static final int data4 = 4;//外部类的常量

    public void func(){
        InnerClass innerClass = new InnerClass();
        System.out.println("外部类的成员方法");
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);
        System.out.println(data4);
        System.out.println(innerClass.data5);//外部类的成员方法要想访问内部类的成员变量,通过实例化内部类,用类名来引用
        System.out.println(innerClass.data6);//外部类可以访问静态内部类当中的所有成员 即使是private
        System.out.println(InnerClass.data7);//内部类静态的成员变量可以通过类名访问
        System.out.println(InnerClass.data8);
    }

    static class InnerClass {//静态内部来看
        public int data5 = 5;
        protected int data6 = 6;//内部类的成员方法
        private static int data7 = 7;//内部类的静态成员变量
        private static final int data8 = 8;//内部类的常量
        public void func(){
            System.out.println("静态内部类中的方法");
            OuterClass outerClass = new OuterClass();
           // 静态内部类当中,不能直接访问外部类的非静态成员.可以通过实例化外部类对象的引用来访问
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(this.data5);
            System.out.println(data6);
            System.out.println(data7);
            System.out.println(data8);
        }
    }

}

1.1实例化静态内部类的对象

    public static void main(String[] args) {
        OuterClass.InnerClass innerClass= new OuterClass.InnerClass();
        //实例静态内部类,因为是静态的,所以要通过外部类的引用,来调用内部类
        innerClass.func();
    }

实例静态内部类,因为是静态的,所以要通过外部类的引用,来调用内部类

1.2静态内部类中访问外部类成员

           OuterClass outerClass = new OuterClass();
           // 静态内部类当中,不能直接访问外部类的非静态成员.可以通过实例化外部类对象的引用来访问
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);

1.静态内部类当中,不能直接访问外部类的非静态成员.

可以通过实例化外部类对象的引用来访问

1.3 外部类中访问内部类的成员变量

外部类可以访问静态内部类当中的所有成员, 即使是private

(1)访问静态成员

 System.out.println(InnerClass.data7);

内部类静态的成员变量可以通过类名访问

(2) 访问非静态成员

InnerClass innerClass = new InnerClass();
System.out.println(innerClass.data5);

外部类的成员方法要想访问内部类的成员变量,通过实例化内部类,用类名来引用

2.实例内部类

2.1实例化实例内部类

        OuterClass2 outerClass2 = new OuterClass2();
        OuterClass2.InnerClass2 innerClass2 =outerClass2.new InnerClass2();

先实例化外部类的对象再实例化实例内部类,比静态内部类麻烦

2.2在实例内部类当中,不能定义静态的成员变量

         protected int data6 = 6;//内部类的成员方法
        //private static int data7 = 7;//非静态内部类不能定义静态成员,静态成员不依赖于对象

        private static final int data7 = 7;//非静态内部类不能定义静态成员,静态成员不依赖于对象,可以改为常量
        //常量在程序编译的时候,就能确定.变量是在程序运行时,才确定的

实例内部类不能定义静态成员变量,静态成员不依赖于对象,可以改为常量可以改为常量
常量在程序编译的时候,就能确定.变量是在程序运行时,才确定的

2.3 外部类访问实例内部类的成员变量

InnerClass2 innerClass2 = new InnerClass2();
System.out.println(innerClass2.data5);
System.out.println(innerClass2.data6);

先实例化实例内部类对象,再通过对象名引用

2.4实例内部类中调用外部类的成员变量

            System.out.println(new OuterClass2().data1);
            System.out.println(OuterClass2.this.data1);

实例内部类中调用外部类的成员变量,先实例化外部类,在通过类名访问

或者通过外部类类名.this来访问 ,在非静态内部类当中,包含外部类this

3.局部内部类

class OuterClass3{
    public void func(){
        class InnerClass3{
            public int data = 1;
            public void test(){
                System.out.println("局部内部类");
            }
        }
        InnerClass3 innerClass3 = new InnerClass3();
        innerClass3.test();
    }
}

1.局部内部类只能在所定义的方法体内部使用

2. 不能被 public 、 static 等修饰符修饰

4.匿名内部类

interface Itext1{
    void func();
}
class Test_1 implements Itext1{
    @Override
    public void func() {
        System.out.println("hello");
    }
}

public class Test {
    public static void main(String[] args) {
            new Itext1(){//new接口,在{}内重写方法,一个匿名类实现了接口,重写了方法
                // 等价于上面
                @Override
                public void func() {
                    System.out.println("匿名类666");
                }
            }.func();//调用重写的方法
    }