前言

如果在一个文件中创建了两个类，那么这两个类是并列关系，不存在哪一个类包含哪一个类的情况。如果在类中再定义一个类，那么这个在类中被定义的类叫做内部类。

一、内部类是什么？

内部类：内部类是在一个类内部定义的类。

作用：可以访问外部类的成员，并提供更好的封装和组织代码的能力。

二、如何使用？

1.成员内部类

语法：

public class OuterClass{	//外部类
	private class InnerClass{	//成员内部类
	    //…
    }
}

规则1：内部类可以随意使用外部类的成员方法和成员变量，即使有 private 权限关键字修饰，也可以使用。

class OuterClassa{	//外部类
    private int a = 0;    //外部类成员变量
    
    private void b(){
        //外部类成员方法
    }

	private class InnerClass{	//内部类
        
	    void c() {   //内部类的成员方法
			
            a++;

            b();
            //在内部类方法中，调用了外部类的成员方法和成员变量
		}
    }
}

规则2：内部类的成员只有在内部类的范围之内是可知的，不能被外部类使用。外部类中可以使用内部类对象引用调用内部类的成员变量。

规则3：如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类的对象上。内部类的初始化方式也是使用new关键字,在外部类和外部类非静态方法中直接实例化。

interClass in = new interClass();

规则4：如果是在静态方法中实例化内部类对象，需要调用外部类对象。内部类的形式指定该对象的类型

//在main方法中：
OuterClass out = new OuterClass();    //外部类实例化
OuterClass.innterClass in =out.new interClass();    //外部类对象实例化内部类对象

另一种方法：在方法中返回值实例化内部类对象：通过方法返回值实现成员内部类的实例化

public OutInterface doit() {	
    //定义一个方法，返回值类型为 OutInterface接口
	return new InnerClass("访问内部类构造方法");
    //return new 关键字，实现实例化内部类对象
	}

实例：

interface OutInterface{
	// 创建接口，方法通过接口实现 new实例化 内部类对象
}

class OuterClass2{
	//定义一个内部类实现OutInterface接口
	private class InnerClass implements OutInterface{
		InnerClass(String s){	//内部类构造方法
			System.out.println(s);
		}
	}

	public OutInterface doit() {	//定义一个方法，返回值类型为 OutInterface接口
			return new InnerClass("访问内部类构造方法");
	}
}

public class InterfaceInner {
	public static void main(String[] args) {
		OuterClass2 out = new OuterClass2();
		//调用 doit()方法，返回一个OuterInterface接口
		OutInterface outinter = out.doit();
        //通过外部对象 out 调用 doit()方法，new关键字 实例化内部类对象
		
	}
}

输出结果：

解析：

1.创建了一个接口。用于外部类doit()方法，返回值类型为接口，实现内部类的实例化。

2.创建了一个外部类。外部类中写了一个 doit()方法，用于在静态方法中创建内部类对象。

3.创建了一个内部类。内部类实现了接口，并且写了一个构造方法。

4.创建了一个静态方法。静态方法中创建了外部类对象。通过外部类对象，调用外部类方法doit()方法，实现内部类的实例化（尽管赋值的对象是一个接口）。

2.局部内部类

局部内部类：在类的方法或任意的作用域中定义的内部类。

语法：

public OutInterface action(String x) {
        //这是一个方法
		class innerClass implements OutInterface{
			//这是写在方法里的一个局部内部类
		}
	}

实例：

package package5;

public class Demo2 {
	
	interface OutInterface{
		
	}
	
	public OutInterface action(String x) {
		class innerClass implements OutInterface{
			//这是写在方法里的一个局部内部类
			public innerClass(String s) {
				//局部内部类的构造方法
				s = x;
				System.out.println(s);
			}
		}
		//方法返回值为实例化局部内部类，括号中赋值了局部内部类的构造方法，通过实现一个接口，
		return new innerClass("");
	}

	public static void main(String[] args) {
		Demo2 de = new Demo2();
		de.action("这里是局部内部类");
	}
}

输出结果：