Java 内部类

Java 内部类

从种类上说，内部类可以分为四类：普通内部类、静态内部类、匿名内部类、局部内部类。

普通内部类

定义：在一个类里面作为类的一个字段直接定义就可以了，例：

public class InnerClassTest {

    public class InnerClassA {

    }
}

在这里 InnerClassA 类为 InnerClassTest 类的普通内部类，在这种定义方式下，普通内部类对象依赖外部类对象而存在，即在创建一个普通内部类对象时需要创建其外部类对象，我们在创建上面代码中的 InnerClassA 对象时先要创建 InnerClassTest 对象，例：

public class InnerClassTest{
    public int outField1 = 1;
    protected int outField2 = 2;
    int outField3 = 3;
    private int outField4 = 4;
    
    public InnerClassTest(){
        //在外部类对象内部，直接通过 new InnerClass();创建内部类对象
        InnerClassA innerObj = new InnerClassA();
        System.out.println("创建"+ this.getClass().getSimpleName() + "对象");
        System.out.println("其内部类的 field1 字段值为："+innerObj.field1);
        System.out.println("其内部类的 field2 字段值为："+innerObj.field2);
        System.out.println("其内部类的 field3 字段值为："+innerObj.field3);
        System.out.println("其内部类的 field4 字段值为："+innerObj.field4);
    }
    
    public class InnerClassA{
        public int field1 =5;
        protected int field2 =6;
        int field3 =7;
        private int field4 =8;
        //static int field5 = 5; //编译错误！普通内部类中不能定义 static 属性
        
        public InnerClassA(){
            System.out.println("创建"+this.getClass().getSimpleName()+"对象");
            System.out.println("其外部类的 outField1 字段的值为："+ outField1);
            System.out.println("其外部类的 outField2 字段的值为："+ outField2);
            System.out.println("其外部类的 outField3 字段的值为："+ outField3);
            System.out.println("其外部类的 outField4 字段的值为："+ outField4);
        }
    }
    
    public static void main(String[] args){
        InnerClassTest outerObj = new InnerClassTest();
        //不在外部类内部，使用：外部类对象.new 内部类构造器（）；的方式创建内部类对象
// 		  InnerClassA innerObj = outerObj.new InnerClassA()；
    }
}

这里的内部类就像外部类声明的一个属性字段一样，因此其的对象是依附于外部类对象而存在的，我们来看一下结果：

创建 InnerClassA 对象
其外部类的 outField1 字段的值为：1
其外部类的 outField2 字段的值为：2
其外部类的 outField3 字段的值为：3
其外部类的 outField4 字段的值为：4
创建InnerClassTest 对象
其内部类的 field1 字段的值为：5
其内部类的 field1 字段的值为：6
其内部类的 field1 字段的值为：7
其内部类的 field1 字段的值为：8

我们注意到，内部类对象可以访问外部类中所有访问权限的字段，同时，外部类对象也可以通过内部类的对象引用来访问内部类中定义的所有访问权限的字段，后面我们将从源码里面分析具体原因。

静态内部类

我们知道，一个类的静态成员独立于这个类的任何一个对象存在，只要在具有访问权限的地方，我们就可以通过 类名.静态成员名 的形式来访问这个静态成员，同样的，静态内部类也是作为一个内部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖其外部类对象。例：

public class InnerClassTest{
	public int field =1;
	
	public InnerClassTest(){
		System.out.println("创建 " + this.getClass().getSimpleName() + " 对象");
		//创建静态内部类对象
        StaticClass innerObj = new StaticClass();
        
	}
    
    static class StaticClass{
        
        public int field1 = 1;
        protected int field2 = 2;
        int field3 = 3;
        private int field4 = 4;
        //静态内部类中可以定义 static 属性
        static int field5 = 5;
        
        public StaticClass(){
            System.out.println("创建 " + StaticClass.class.getSimpleName() + " 对象");
//           System.out.println("其外部类的 field1 字段的值为: " + field1); // 编译错误！！
        }
    }
    	
    public static void main(String[] args){
        // 无需依赖外部类对象，直接创建内部类对象
//        InnerClassTest.StaticClass staticClassObj = new InnerClassTest.StaticClass();
        InnerClassTest outerObj = new InnerClassTest();
    }
}

结果：

创建 InnerClassTest 对象
创建 StaticClass 对象
其内部的 field1 字段的值为：1
其内部的 field2 字段的值为：2
其内部的 field3 字段的值为：3
其内部的 field4 字段的值为：4

可以看到，静态内部类就像外部类的一个静态成员一样，创建其对象无需依赖外部类对象（访问一个类的静态成员也无需依赖这个类的对象，因为它是独立于所有类的对象的）。但是于此同时，静态内部类中也无法访问外部类的非静态成员，因为外部类的非静态成员是属于每一个外部类对象的，而本身静态内部类就是独立外部类对象存在的，所以静态内部类不能访问外部类的非静态成员，而外部类依然可以访问静态内部类对象的所有访问权限的成员，这一点和普通内部类无异。

匿名内部类

匿名内部类有多种形式，其中最常见的一种形式莫过于在方法参数中新建一个接口对象/类对象，并且实现这个接口声明/类中原有的方法了：

public class InnerClassTest{
    public int field1 = 1;
    protected int field2 = 2;
    int field3 = 3;
    private int field4 = 4;
    
    public InnerClassTest(){
        System.out.println("创建"+this.getClass().getSimpleName()+"对象")；
    }
    //自定义接口
    interface OnClickListener{
        void onClick(Object obj);
    }
    
    private void anonymousClassTest(){
        //在这个过程中会新建一个匿名内部类对象，
        //这个匿名内部类实现了OnClickListener接口并重写onClick 方法
        OnClickListener clickListener = new OnClickListener（）{
            //可以在内部类中定义属性，但是只能在当前内部类中使用，
            //无法在外部类中使用，因为外部类无法获取当前匿名内部类的类名，
            //也就无法创建匿名内部类对象
            int field =1;
            
            @Override
            public void onClick(Object obj){
                System.out.println("对象"+obj+"被点击");
                System.out.println("其外部类的 field1 字段的值为："+ field1);
                System.out.println("其外部类的 field2 字段的值为："+ field2);
                System.out.println("其外部类的 field3 字段的值为："+ field3);
                System.out.println("其外部类的 field4 字段的值为："+ field4);
            }
        };
        //new Object() 过程会创建一个匿名内部类，继承于Object类；
        //并重写了toString()方法
        clickListener.onClick(new Object(){
            @Override
            public String toString(){
                return "obj1";
            }
        });
    }
    
    public static void main(String[] args){
        InnerClassTest outObj = new InnerClassTest();
        outObj.anonymousClassTest();
    }
}

来看看结果：

创建 InnerClassTest 对象
对象 obj1 被点击
其外部类的 field1 字段的值为：1
其外部类的 field2 字段的值为：2
其外部类的 field3 字段的值为：3
其外部类的 field4 字段的值为：4

上面的代码中展现了常见的两种使用匿名内部类的情况：

1、直接new 一个接口，并实现这个接口声明的方法，在这个过程其实会创建一个匿名内部类实现这个接口，并重写接口声明的方法，然后再创建一个这个匿名内部类的对象并赋值给前面的 OnclickListenner 类型的引用；

2、new一个已经存在的类/抽象类，并且选择性的实现这个类中的一个或者多个非 final 的方法，这个过程会创建一个匿名内部类对象继承对应的类/抽象类，并且重写对应的方法。

同样的，在匿名内部类中可以使用外部类的属性，但是外部类却不能使用匿名内部类中定义的属性，因为是匿名内部类，因此在外部类中无法获取这个类的类名，也就无法得到属性信息。

局部内部类

局部内部类使用的比较少，其声明在一个方法体/一段代码块的内部，而且不在定义类的定义域之内便无法使用，其提供的功能使用匿名内部类都可以实现，而本身匿名内部类可以写得比它更简洁，因此局部内部类用的比较少。来看一个局部内部类的小例子：

public class InnerClassTest{
    
    public int field1 = 1;
        protected int field2 = 2;
        int field3 = 3;
        private int field4 = 4;
    
    public InnerClassTest() {
        System.out.println("创建 " + this.getClass().getSimpleName() + " 对象");
    }
    
    private void localInnerClassTest(){
        //局部内部类A，只能在当前方法中使用
        class A{
            //static int field = 1;//编译错误！局部内部类中不能定义static 字段
            public A(){
                System.out.println("创建"+A.class.getSimpleName() + " 对象");
                System.out.println("其外部类的 field1 字段的值为: " + field1);
                System.out.println("其外部类的 field2 字段的值为: " + field2);
                System.out.println("其外部类的 field3 字段的值为: " + field3);
                System.out.println("其外部类的 field4 字段的值为: " + field4);
            }
        }
        A a =new A();
        if(true){
            //局部内部类 B，只能在当前代码块中使用
            class B{
                public B(){
                    System.out.println("创建 " + B.class.getSimpleName() + " 对象");
                    System.out.println("其外部类的 field1 字段的值为: " + field1);
                    System.out.println("其外部类的 field2 字段的值为: " + field2);
                    System.out.println("其外部类的 field3 字段的值为: " + field3);
                    System.out.println("其外部类的 field4 字段的值为: " + field4);
                }
            }
            B b = new B();
        }
 //        B b1 = new B(); // 编译错误！不在类 B 的定义域内，找不到类 B，
    }
    
    public static void main(String[] args) {
        InnerClassTest outObj = new InnerClassTest();
        outObj.localInnerClassTest();
    }
}

同样的，在局部内部类里面可以访问外部类对象的所有访问权限的字段，而外部类却不能访问局部内部类中定义的字段，因为局部内部类的定义只在其特定的方法体 / 代码块中有效，一旦出了这个定义域，那么其定义就失效了，就像代码注释中描述的那样，即外部类不能获取局部内部类的对象，因而无法访问局部内部类的字段。最后看看运行结果：

创建 InnerClassTest 对象
创建 A 对象
其外部类的 field1 字段的值为：1
其外部类的 field2 字段的值为：2
其外部类的 field3 字段的值为：3
其外部类的 field4 字段的值为：4
创建 B对象
其外部类的 field1 字段的值为：1
其外部类的 field2 字段的值为：2
其外部类的 field3 字段的值为：3
其外部类的 field4 字段的值为：4

Java 内部类

原文：https://www.cnblogs.com/lezai0514/p/14852846.html