Java内部类
本文将通过 WHAT、WHY、HOW 三个方面来展开 Java 内部类的相关知识。
一、什么是内部类？
可以将一个类的定义放在里另一个类的内部，这就是内部类。广义上我们将内部类分为四种：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。
/**
* 我是一个外部类（外部是相对内部而言）
*/
public class Outer{
/**
* 我是一个内部类
*/
class Inner{
//...
}
}
二、为什么要用内部类？
使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。——《Think in java》
也就是说内部类拥有类的基本特征。(eg：可以继承父类，实现接口。) 在实际问题中我们会遇到一些接口无法解决或难以解决的问题，此时我们可以使用内部类继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。（注：内部类可以嵌套内部类，但是这极大的破坏了代码的结构，这里不推荐使用。）
/**
1. Outer类继承了ClassA，实现了IFunctionA
*/
public class Outer extends ClassA implements IFunctionA{
/**
* Inner类继承了ClassB，实现了IFunctionB
*/
public class Inner extends ClassB implements IfunctionB{
//
}
}
除了上面的优点之外还有如下四点：
1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
2、内部类并没有令人迷惑的 “is-a” 关系，他就是一个独立的实体。
3、内部类提供了更好的封装，除了该外围类，其他类都不能访问。
4、创建内部类对象的时刻并不依赖于外围类对象的创建。
具体来说，内部类信息（属性、方法）可以和外部类重名；内部类是具有类的基本特征的独立实体；可以利用访问修饰符隐藏内部类的实施细节，提供了更好的封装；静态内部类使用时可直接使用，不需先创造外部类。
三、如何使用内部类
简单的总结如下（暂时不太理解也没有关系，我们下面会通过例子依此演示）：
我们通过一些 demo 来理解如何使用内部类
（一）成员内部类
1、外部类、内部类
/**
* 外部类、成员内部类的定义
*/
public class Outer {
private int outerVariable = 1;
private int commonVariable = 2;
private static int outerStaticVariable = 3;
//省略getter/setter
/**
* 成员方法
*/
public void outerMethod() {
System.out.println("我是外部类的outerMethod方法");
}
/**
* 静态方法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态方法");
}
/**
* 内部类
*/
public class Inner {
private int commonVariable = 20;
/**
* 构造方法
*/
public Inner() {
}
/**
* 成员方法，访问外部类信息（属性、方法）
*/
public void innerShow() {
//当和外部类冲突时，直接引用属性名，是内部类的成员属性
System.out.println("内部的commonVariable:" + commonVariable);
//内部类访问外部属性
System.out.println("outerVariable:" + outerVariable);
//当和外部类属性名重叠时，可通过外部类名.this.属性名
System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
System.out.println("outerStaticVariable:" + outerStaticVariable);
//访问外部类的方法
outerMethod();
outerStaticMethod();
}
}
/**
* 外部类访问内部类信息
*/
public void outerShow() {
Inner inner = new Inner();
inner.innerShow();
}
}
2、其他类使用成员内部类
/*
* 其他类使用成员内部类
*/
public class Other {
public static void main(String[] args) {
//外部类对象
Outer outer = new Outer();
//创造内部类对象
Outer.Inner inner = outer.new Inner();
inner.innerShow();
/*
* 可在Outer中定义get方法，获得Inner对象,那么使用时，只需outer.getInnerInstance()即可。
* public Inner getInnerInstance(Inner类的构造方法参数){
* return new Inner(参数);
* }
*/
}
}
3、运行结果（和 innerShow() 方法对照）：
4、小结：【成员内部类当成 Outer 的成员信息存在 】
- 可以是任何的访问修饰符。
- 内部类的内部不能有静态信息。
- 内部类也是类, 该继承继承，该重写重写，该重载重载，this 和 super 随便用。
- 外部类如何访问内部类信息，必须 new 之后打点访问。
- 内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类. this. 属性或者方法。
- 其它类如何访问内部类：
Outer outer=new Outer();
//创造内部类对象
Outer.Inner inner=outer.new Inner();
inner.inner_show();
（二）静态内部类
1、外部类、内部类
/**
* 外部类、内部类定义
*/
public class Outer {
private int outerVariable = 1;
/**
* 外部类定义的属性(重名)
*/
private int commonVariable = 2;
private static int outerStaticVariable = 3;
static {
System.out.println("Outer的静态块被执行了……");
}
/**
* 成员方法
*/
public void outerMothod() {
System.out.println("我是外部类的outerMethod方法");
}
/*
* 静态方法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态方法");
}
/**
* 静态内部类
*/
public static class Inner {
/**
* 成员信息
*/
private int innerVariable = 10;
private int commonVariable = 20;
static {
System.out.println("Outer.Inner的静态块执行了……");
}
private static int innerStaticVariable = 30;
/**
* 成员方法
*/
public void innerShow() {
System.out.println("innerVariable:" + innerVariable);
System.out.println("内部的commonVariable:" + commonVariable);
System.out.println("outerStaticVariable:"+outerStaticVariable);
outerStaticMethod();
}
/**
* 静态方法
*/
public static void innerStaticShow() {
//被调用时会先加载Outer类
outerStaticMethod();
System.out.println("outerStaticVariable"+outerStaticVariable);
}
}
/**
* 外部类的内部如何和内部类打交道
*/
public static void callInner() {
System.out.println(Inner.innerStaticVariable);
Inner.innerStaticShow();
}
}
2、其他类使用成员内部类
public class Other {
public static void main(String[] args) {
//访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。
Outer.Inner.innerStaticShow();
//访问静态内部类的成员方法
Outer.Inner oi = new Outer.Inner();
oi.innerShow();
}
}
3、运行结果（注意加载顺序）
4、小结【和成员内部类对比理解（区别异同）】
- 内部可以包含任意的信息。
- 静态内部类的方法只能访问外部类的 static 关联的信息。
- 利用 外部类. 内部类 引用 = new 外部类. 内部类 (); 然后利用引用. 成员信息(属性、方法) 调用。
- 访问内部类的静态信息，直接外部类. 内部类. 静态信息就可以了。
- 静态内部类可以独立存在，不依赖于其他外围类。
（三）局部内部类
1、外部类、内部类
/**
* 外部类、内部类
*/
public class Outer {
/**
* 属性和方法
*/
private int outerVariable = 1;
/**
* 外部类定义的属性
*/
private int commonVariable = 2;
/**
* 静态的信息
*/
private static int outerStaticVariable = 3;
/**
* 成员外部方法
*/
public void outerMethod() {
System.out.println("我是外部类的outerMethod方法");
}
/**
* 静态外部方法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态方法");
}
/**
* 程序的入口
*/
public static void main(String[] args) {
Outer outer = new Outer();
outer.outerCreatMethod(100);
}
/**
* 成员方法，内部定义局部内部类
*/
public void outerCreatMethod(int value) {
/**
* 女性
*/
boolean sex = false;
/**
* 局部内部类，类前不能有访问修饰符
*/
class Inner {
private int innerVariable = 10;
private int commonVariable = 20;
/**
* 局部内部类方法
*/
public void innerShow() {
System.out.println("innerVariable:" + innerVariable);
//局部变量
System.out.println("是否男性:" + sex);
System.out.println("参数value:" + value);
//调用外部类的信息
System.out.println("outerVariable:" + outerVariable);
System.out.println("内部的commonVariable:" + commonVariable);
System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
System.out.println("outerStaticVariable:" + outerStaticVariable);
outerMethod();
outerStaticMethod();
}
}
//局部内部类只能在方法内使用
Inner inner = new Inner();
inner.innerShow();
}
}
2、运行结果
3、小结【局部内有很多局限，应注意作用域】
- 类前不能有访问修饰符。
- 仅在此方法内使用。
- 无法创造静态信息。
- 可以直接访问方法内的局部变量和参数（有限制，下面详谈），但是不能更改。
- 可以随意的访问外部类的任何信息。
4、局部内部类访问局部变量的限制
Variable ‘xxx’ is accessed from within inner class, needs to be final or effectively final
它的意思是：变量’xxx’从内部类中访问，需要 final 或有效的 final
具体限制如下：
-
直接被 final 修饰的变量。
-
已被赋值且始终未改变的变量（有且仅有赋值一次）, 引用指向不能改变。JDK8 以前（不包括 8）只能访问被 final 修饰的变量。eg:
就会产生如下错误：传入局部内部类所在方法的参数同理，如果一直不变则可使用，反之则会报错。
（四）匿名内部类
1、定义接口
/**
* 接口中方法默认为public
*/
public interface IAnimal{
void speak();
}
2、匿名内部类使用
/**
* 外部内、内部类
*/
public class Outer {
public static IAnimal getInnerInstance(String speak){
return new IAnimal(){
@Override
public void speak(){
System.out.println(speak);
}};
//注意上一行的分号必须有
}
public static void main(String[] args){
//调用的speak()是重写后的speak方法。
Outer.getInnerInstance("小狗汪汪汪！").speak();
}
}
3、结果
小狗汪汪汪！
4、小结【匿名内部类常常被用来重写某个或某些方法】
- 匿名内部类是没有访问修饰符的。
- 使用匿名内部类时，这个 new 之后的类首先是要存在的，其次我们要重写 new 后的类的某个或某些方法。
- 匿名内部类访问方法参数时也有和局部内部类同样的限制。
- 匿名内部类没有构造方法。
PS: 限于篇幅，本文只讲一些基本语法，随后会更新深入理解内部类，这些语法为什么要这样规定。第一次写博文，请大家多多包容。如有错误，欢迎联系本人。
————特别鸣谢授课恩师司老师。