Java 内部类

 

一般情况下，类和类之间是谁相互独立的，内部类的意思是打破这种独立，让一个类成为另一个类的内部成员，和成员变量、成员方法同等级别。

为什么要使用内部类？采用内部类这种技术，可以隐藏细节和内部结构，封装性更好，让程序的构造更加合理。

官方点的优点！
❀每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整。
❀方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
❀方便编写事件驱动程序。
❀方便编写线程代码。

1、成员内部类

成员内部类的作用就是讲内部类当做外部类的一个成员变量/成员方法来使用，所以必须依赖于外部类的 对象才能调用，用法和成员变量/方法是一致的。

public class OuterClass {
    //成员变量
    private String outerName;

    //成员方法
    public void display() {
        System.out.println("OuterClass display");
    }

    //成员内部类
    public class InnerClass {
        //成员变量
        private String innerName;

        //成员方法
        public void display() {
            System.out.println("InnerClass display");
        }
    }

    public static void main(String[] args) {
        //实例化外部类
        OuterClass outerClass = new OuterClass();
        outerClass.display();

        //实例化非静态内部类需要外部类的实例
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }
}

成员内部类可以直接访问外部类中的所有成员。但外部类如果要访问成员内部类的成员需要通过实例来取。

☄成员内部类可以使用四种权限修饰符进行修饰。
☄成员内部类中不能书写静态变量和方法。

2、局部内部类

局部内部类只能在局部作用域内使用，作用域外无法访问。

public class OuterClass {
    //成员变量
    private String outerName;

    //成员方法
    public void display() {
        System.out.println("OuterClass display");

        //局部内部类
        class InnerClass {
            //成员变量
            private String innerName;

            //成员方法
            public void display() {
                System.out.println("InnerClass display");
            }
        }
        //局部内部类只能在局部作用域内使用，作用域外无法访问。
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }

    public static void main(String[] args) {
        //实例化外部类
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}

☄局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
☄局部内部类不可使用权限修饰符 静态修饰符进行修饰 同局部变量相同
☄局部内部类可以直接访问方法中的属性
☄局部内部类 可以直接访问方法外部类中属性和方法
☄局部内部类 创建对象 要在方法内部 局部内部类的外部声明

3、静态内部类

静态内部类的构造不需要依赖外部类的对象，类中的所有静态组件都不需要依赖任何对象，可以直接通过类本身进行构造。

public class OuterClass {
    //成员变量
    private String outerName;

    //成员方法
    public void display() {
        System.out.println("OuterClass display");
    }

    //静态内部类
    public static class InnerClass {
        //成员变量
        private String innerName;

        //成员方法
        public void display() {
            System.out.println("InnerClass display");
        }
    }

    public static void main(String[] args) {
        //实例化外部类
        OuterClass outerClass = new OuterClass();
        outerClass.display();

        //实例化静态内部类
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.display();
    }
}

☄静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。
☄静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。
☄静态内部类中即能声明静态成员也可以声明非静态成员。

4、匿名内部类

不需要单独穿件距离的类文件进行实现接口的方法，使接口执行方法内容直接在当前类展示。

/**
 * 接口
 */
public interface MyInterface {
    void display();
}
/**
 * 接口实现类
 */
public class MyImplement implements MyInterface {
    @Override
    public void display() {
        System.out.println("display");
    }
}
public class OuterClass {

    public static void main(String[] args) {
        //普通实现类
        MyInterface myInterface = new MyImplement();
        myInterface.display();

        //匿名内部类
        MyInterface myInterface1 = new MyInterface() {
            @Override
            public void display() {
                System.out.println("display");
            }
        };
        myInterface1.display();

        //lambda表达式
        MyInterface myInterface2 = () -> System.out.println("display");
        myInterface2.display();
    }
}

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

 首先有一个接口，然后在使用的类中编写了一个方法（参数类型是接口对象），并使用接口中未实现的方法。
我们调用此方法直接构造一个接口对象传入，此时会自动生成一个此接口的子类（匿名内部类）实现接口中的方法。本质传入的类便是此时的匿名内部类。