【JavaSE】内部类

flmz_Kk

已于 2024-05-23 02:39:15 修改

阅读量953

点赞数 17

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

于 2024-03-30 21:06:16 首次发布

本文链接：https://blog.csdn.net/flmz_kk/article/details/137131657

版权

JavaSE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

前言

内部类是我们前面学习遗留下来的知识点，在学完接口后才能更好的理解它，因此等到现在才讲

内部类

在Java中，我们可以将A类定义在B类或者一个方法的内部，这时A类就叫做内部类，B类就叫做外部类。内部类其实也是封装的一种体现。

class B {
    //...
    class A {
        //...
    }
}

内部类和外部类是共用一个Java源文件的，但是在编译后，内部类会形成单独的字节码文件（文件名为：外部类类名$内部类类名.class）

内部类的种类

实例内部类：非static修饰的成员内部类
静态内部类：static修饰的成员内部类
匿名内部类：与接口相关的内部类
局部内部类：定义在外部类的方法或{ }中

相比较于其他三种内部类，局部内部类用的很少，下面我们来一一认识这些内部类

1. 实例内部类

定义在类里面，方法外面，且不被static修饰。在实例内部类中，我们也可以正常定义成员变量和成员方法，静态的也可以

class OuterClass {
    public int O1;
    private int O2;
    public static int O3;

    /**
     * 实例内部类：定义在类里面，方法外面
     */
    class InnerClass {
        public int I1;
        private int I2;
        public static int I3;

        public void testI() {
            System.out.println("InnerClass::testI()");
        }
    }

    public void testO() {
        System.out.println("OuterClass::testO()");
    }
}

接着我们来实例化内部类对象，它的语法格式如下：

方法一：外部类类名.内部类类名变量名 = new 外部类类名( ).new 内部类类名( )

方法二：先外部类类名.变量名1 = new 外部类类名( )；

再外部类类名.内部类类名变量名2 = 变量名1.new 内部类类名( )

public class Test {
    public static void main(String[] args) {
        //方法一：
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        //方法二：
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass1 = outerClass.new InnerClass();
    }
}

总而言之，我们必须得通过外部类对象的引用再. new一个内部类对象

创建好内部类对象后，我们就可以使用它来调用各种成员

        System.out.println(innerClass.I1);//调用内部类的成员
        innerClass.testI();//调用内部类的方法

其实我们也可以在内部类方法中直接调用外部类的任何成员

        public void testI() {
            System.out.println("InnerClass::testI()");
            System.out.println(I1);
            System.out.println(O1);
        }

当内部类和外部类存在同名成员变量时，内部类方法中调用时会优先访问内部类的成员，
那如果我们想要精准的访问（同名）内部类成员和（同名）外部类成员要怎么做呢
答案就是：this.同名变量和外部类名.this.同名变量

class OuterClass {
    public int same = 100;

    class InnerClass {
        public int same = 10;

        public void testI() {
            System.out.println("内部类"+this.same);
            System.out.println("外部类"+OuterClass.this.same);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        innerClass.testI();
    }
}

运行结果如下

或者我们也可以在内部类中创建一个外部类的对象，再用外部类的对象去调用外部类的成员

外部类中，不能直接访问内部类中的成员，如果像访问就必须得先创建内部类的成员

2 静态内部类

定义在类里面，方法外面，且被static修饰。在静态内部类中，我们也可以正常定义成员变量和成员方法，静态的也可以

class OuterClass {
    public int O1;
    private int O2;
    public static int O3;

    /**
     * 静态内部类：定义在类里面，方法外面，且有static修饰
     */
    static class InnerClass {
        public int I1;
        private int I2;
        public static int I3;

        public void testI() {
            System.out.println("InnerClass::testI()");
        }
    }

    public void testO() {
        System.out.println("OuterClass::testO()");
    }
}

接着我们来实例化内部类对象，它的语法格式如下：

外部类类名.内部类类名变量名 = new 外部类类名.内部类类名( )

（创建静态内部类对象时，不需要先创建外部类对象）

public class Test {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
    }
}

其他的东西跟实例内部类非常相似，但是在静态内部类中调用外部类非静态成员变量时，我们需要先创建外部类对象，用该对象才能引用

class OuterClass {
    public int O1;

    static class InnerClass {
        public int I1;

        public void testI() {
            OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.O1);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
    }
}

3 匿名内部类

在将匿名内部类前，我们先来看一下什么叫做匿名对象

//方法1：
        OuterClass outerClass = new OuterClass();
        outerClass.testO();
        System.out.println(outerClass.O1);
//方法2：
        new OuterClass().testO();
        System.out.println(new OuterClass().O1);
在方法1中，我们使用OuterClass引用创建了一个outerClass对象，打印O1和调用testO( )方法

在方法2中，我们使用new OuterClass( )直接打印O1和调用testO( )方法

方法2中每次都会创建一个新的对象，它没有用变量去承接对象的地址，此时这个对象就叫做匿名对象

匿名内部类跟接口有关，我们都知道，接口不能直接创建对象。我们通常会用一个类去实现接口，重写方法，这样才能实例化类的对象，从而使用接口。而匿名内部类就这个过程有点相似

interface ITest {
    void test();
}

public class Test {
    public static void main(String[] args) {
        new ITest() {
            @Override
            public void test() {
                System.out.println("重写后的test()");
            }
        };
    }
}

其中，这部分就叫做匿名内部类

它并没有真正实例化接口对象；它等同于一个类实现了这个接口，同时重写了test方法，但是这个类我们并不知道它叫什么，这就是匿名内部类

那如果我们想要调用test方法，要怎么做呢？

方法一：可以直接在匿名内部类后面. test( )

        new ITest() {
            @Override
            public void test() {
                System.out.println("重写后的test()");
            }
        }.test();

方法二：创建一个匿名内部类对象，再用对象去调用test方法

        ITest iTest = new ITest() {
            @Override
            public void test() {
                System.out.println("重写后的test()");
            }
        };
        iTest.test();

4 局部内部类

定义在方法里的类，即为局部的局部，只能在当前方法里使用，出了方法后就没用了，局限性很大

class OuterClass {
    public int O1;

    public void testO() {
        class InnerClass {
            public int I1;

            public void testI() {
                System.out.println("InnerClass::testI()");
            }
        }
    }
}

它不能被public、static修饰；它也有自己独立的字节码文件，格式为：外部类类名$数字+内部类类名.class