Java之——“内部类”

一、理解内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部类事物提供服务，那么这个内部的完整结构最好使用内部类。在Java中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

代码如下

class Outclass{
    class Innerclass{
        
    }
}
//Outclass为外部类
//Innerlcass为内部类

【注意事项】

1. 定义在class类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

class A{
    
}
class B{

}
//A和B是两个独立的类，彼此之间没有关系

2. 内部类和外部类共用一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

二、内部类的分类

（1）实例内部类

1. 实例内部类：未被static修饰的内部类
2. 在实例内部类中可直接访问外部类任意访问限定符修饰的成员

class Outclass{
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        System.out.println(b);
    }

    //实例内部类
    class Interclass{
        int c;
        public static final int d = 6;
        public void methodInner(){
            //在实例内部类中可以直接访问外部类中任意访问修饰符的成员
            a = 100;
            b = 200;
            methodA();
            methodB();

3. 如果外部类和实例内部类中具有相同成员时，优先访问的是内部类自己的，如果要访问外部类同名成员的时候，必须：外部类名称.this.同名成员名字

            //如果外部类和实例内部类中具有相同名称的成员时，有限访问的是内部类自己的
            c = 300;
            System.out.println(c);

            //如果要访问外部类同名成员的时候，必须：外部类名称.this.同名成员名字
            Outclass.this.c = 400;
            System.out.println(Outclass.this.c);

4. 外部类对象创建以及成员访问

public class demo {
    public static void main(String[] args) {
        Outclass outclass = new Outclass();
        System.out.println(outclass.b);
        outclass.methodA();
        Outclass.methodB();

5. 创建实例内部类对象
   要访问实例内部类中的成员，必须要创建实例内部类的对象，而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类

        Outclass.Interclass interclass1 = new Outclass().new Interclass();
        
        //也可以先将外部类对象先创建出来，然后再创建实例内部类对象
        Outclass.Interclass interclass2 = outclass.new Interclass();

【注意事项】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问
2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问
4. 实例内部类对象必须在先有外部类对象前提下才能创建
5. 实例内部类的非静态方法中包含了一个只想外部类对象的引用
6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先创建内部类的对象

（2）静态内部类（用的多）

1. 定义外部类

class OutClass{
    private int a;
    static int b;
    static int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        System.out.println(b);
    }

2. 被static修饰的内部类成员称为静态内部类，在内部类中只能访问内部类的静态成员，如果想访问外部类静态成员，那么：实例化外部类对象，用外部类对象.成员

//静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            //在内部类中只能访问外部类的静态成员
            b = 200;
            methodB();


            OutClass outClass1 = new OutClass();
            outClass1.b = 10;
            System.out.println("b = "+ b );
        }
    }

3. 静态内部类创建对象以及成员访问，创建静态内部类对象时，不需要先创建外部类对象

public class demo1 {
    public static void main(String[] args) {
        OutClass.InnerClass innerClass1 = new OutClass.InnerClass();
        innerClass1.methodInner();
    }
}

（3）局部内部类（几乎不会使用）

定义在外部类的方法或者{}中，该种内部类只能在其定义的位置使用，一般用的非常少

class outclass{
    int a = 10;
    public void method(){
        int b = 10;
        
        //局部内部类：定义在方法内部
        //不能被public、static等访问限定符修饰
        class innerclass{
            public void innerclassmethod(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        
        //只能在该方法体内部使用，其他位置都不能用
        innerclass innerclass1 = new innerclass();
        innerclass1.innerclassmethod();
    }
}

【注意事项】

1. 不能被public、static等访问限定符修饰
2. 只能在该方法体内部使用，其他位置都不能用

（4）匿名内部类

在匿名内部类当中，能够访问的是没有被修改过的数据->实质上是变量的捕获

默认在匿名内部类中访问的是被final修饰的

以下代码可以认为有一个类实现了A接口，并且重写了A接口的方法

interface A{
    void testA();
}
public class demo3 {
    public static void main(String[] args) {
        new A(){
            @Override
            public void testA() {
                System.out.println("123");
            }
        }.testA();

        //或
        A a = new A() {
            @Override
            public void testA() {
                System.out.println("123");
            }
        };
        a.testA();
    }
}
//输出结果
123
123

Process finished with exit code 0