内部类

1.定义

在一个类中进行其他类结构的嵌套

2.内部类的分类

3.成员内部类

一方面，作为类的成员：

• 调用外部类的结构
• 可以被static修饰
• 可以被4种不同的权限修饰符修饰

另一方面，作为一个类：

• 类内可以定义属性、方法、构造器等
• 可以被final修饰，表示此类不能被继承。言外之意，不使用final就可以被继承
• 可以被abstract修饰

package 内部类;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 内部类
 * @Author: mcc
 * @CreateTime: 2020-09-02 08:08
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.display();
    }
}

class Outer {
    private String name = "张三";
    private int age = 18;

    public void display() {
        //外部类不可以直接访问内部类的数据，需要通过内部类的引用间接来访问
        //fun();
        Inner inner = new Inner();
        inner.fun();
    }

    class Inner {
        public void fun() {
            System.out.println(name);
            System.out.println(Outer.this.age);
            //在调用外部类的结构时，省略了Outer.this
        }
    }
}

注：

• 对于非静态内部类而言，内部类的创建需要依赖外部类的实例化对象，在没有外部类对象之前是无法创建内部类的
• 内部类是一个相对独立的个体，与外部类不是is-a关系

4.如何实例化成员内部类

①实例化非静态内部类

Outter.Inner in = new Outter().new Inner();

②实例化静态内部类

Outter.Inner in = new Outter.Inner();

5.成员内部类中调用外部类的结构

package 内部类;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 内部类
 * @Author: mcc
 * @CreateTime: 2020-09-02 08:08
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.display("王五");
    }
}

class Outer {
    String name = "张三";

    class Inner {
        String name = "李四";

        public void display(String name) {
            System.out.println(name);//方法形参
            System.out.println(this.name);//内部类属性
            System.out.println(Outer.this.name);//外部类属性
        }
    }
}

6.匿名内部类

①定义：没有名字的方法内部类
②它符合方法内部类的所有约束.除此之外，还有一些地方需要注意：

• 匿名内部类是没有访问修饰符的。
• 匿名内部类必须继承一个抽象类或者实现一个接口
• 匿名内部类中不能存在任何静态成员或方法
• 匿名内部类是没有构造方法的，因为它没有类名
• 与局部内部相同匿名内部类也可以引用方法形参。此形参也必须声明为final

interface MyInterface {
    void test();
}

class Outter {
    private int num;

    public void display(int para) {
        // 匿名内部类，实现了MyInterface接口
        new MyInterface() {
            @Override
            public void test() {
                System.out.println("匿名内部类" + para);
            }
        }.test();
    }
}

public class Test {
    public static void main(String[] args) {
        Outter outter = new Outter();
        outter.display(20);//匿名内部类20
    }
}

7.内部类的优缺点：

优点：

• 内部类与外部类可以互相访问彼此的私有域
• 内部类可以实现Java的单继承局限
• 内部类可以对同一包中的其他类隐藏，仅供外部类使用

缺点：

• 结构复杂

8.对成员内部类不能存在任何Static变量或方法的解析

首先假设成员内部类中可以存在静态变量或方法，内部类的变量或方法是随着类加载的，但是内部类的实例是创建后才存在的，也就是静态属性优先存在于他的实例的存在，这样显然是矛盾的，因为两者的生命周期不同。
如果内部类没有static的话，就需要实例化内部类才能调用，说明非static的内部类不是自动跟随主类加载的，而是被实例化的时候才会加载。而static的语义，就是主类直接通过内部类名来访问内部类中的static方法，而非static的内部类又是不会自动加载的，所以这个时候内部类也要static，否则会前后冲突。