Java——内部类

内部类概念

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

class OutClass {
    class InnerClass{
    }
}

// OutClass是外部类
// InnerClass是内部类

tips：

定义在class类名{}外部的，即使是在同一个文件里，也不能称为内部类

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

---

内部类的分类

静态内部类：被static修饰的内部成员类

实例化一个静态内部类对象

静态内部类的成员访问

结论：

1、静态内部类中只能访问外部类中的静态成员

若想访问，应创建外部类对象，如下：

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

---

实例内部类：未被static所修饰的内部成员类

实例化一个实例内部类

实例内部类的成员访问

当实例内部类的成员变量与外部类出现重复时，优先访问自己的成员变量

若想访问外部类的相同名称的成员变量，方法有二

运行结果：

结论：

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

---

局部内部类

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

    public void testMethod(){
        //局部内部类
        class Inner{
            public int data1 = 1;
            
            public void func(){
                System.out.println("func方法被执行...");
            }
        }
        
        Inner inner = new Inner();
        inner.func();
    }

结论：

• 局部内部类只能在所定义的方法体内部使用
• 不能被public、static等修饰符修饰

---

匿名内部类

不可用类对象接收，如下：

用接口演示：

也可用接口对象接收，实例接口对象，如下：

 

---

本章演示代码如下：

package demo3;

//class OutClass {
//    public int data1 = 1;
//    private int data2 = 2;
//    public static int data3 = 3;
//
//    //静态内部类
//    static class InnerClass{
//        public int data4 = 4;
//        private int data5 = 5;
//        public static int data6 = 6;
//
//        public void test(){
//            OutClass outClass = new OutClass();
//            System.out.println(outClass.data1);
//            System.out.println(data3);
//            System.out.println(data4);
//            System.out.println(data5);
//            System.out.println(data6);
//            System.out.println("test方法被执行...");
//        }
//    }
//}

class OutClass {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    //实例内部类
    class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;

        public int data1 = 100;//与外部类同名


        public void test(){
            //访问外部类同名成员变量
            //方法一：创建外部类对象
            OutClass outClass = new OutClass();
            System.out.println(outClass.data1);
            //方法二：外部类名.this.同名变量
            System.out.println(OutClass.this.data1);

            System.out.println(data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("test方法被执行...");
        }
    }
}

class Out{
    public void test(){
        System.out.println("test方法被执行...");
    }
}

interface IA{
    public void test();
}
public class Test {
    public static void main(String[] args) {
        IA a = new IA(){
            @Override
            public void test(){
                System.out.println("重写 test方法被执行...");
            }
        };
        a.test();
    }

    public static void main3(String[] args) {
        //匿名内部类
        Out out =  Out(){

        };
    }

    public void testMethod(){
        //局部内部类
        class Inner{
            public int data1 = 1;

            public void func(){
                System.out.println("func方法被执行...");
            }
        }

        Inner inner = new Inner();
        inner.func();
    }

    public static void main2(String[] args) {
        //实例化一个实例内部类
        OutClass outClass = new OutClass();
        OutClass.InnerClass innerClass = outClass.new InnerClass();
        innerClass.test();
    }

    public static void main1(String[] args) {
        //实例化一个静态内部类
        //InnerClass innerClass = new InnerClass();//错误示范
        //OutClass.InnerClass innerClass = new OutClass.InnerClass();//正确示范
        //innerClass.test();
    }
}