前言
将一个类的定义放在另外一个类定义的内部，里面的就叫做内部类。内部类是一种非常有用的特性，它允许你把一些逻辑相关的类组织在一起，并控制内部的类的可视性。内部类看起来像是一种代码隐藏机制：将类的实现定义在了其他类中。但是，内部类的优点远不止于此，它可以访问外围类的任何成员并与之通信、让一个类实现多继承等。本篇博客先介绍内部类的基础语法，然后介绍内部类的一些特性。
内部类的创建及使用
public class Parcel {
//内部类
class Contents{
private int i = 1;
public int value() {return i;}
}
//内部类
class Destination{
private String label;
Destination(String whereTo){
label = whereTo;
}
String readLabel() {return label;}
}
public void ship(String dest) {
Contents c = new Contents();
Destination d = new Destination(dest);
System.out.println(d.readLabel());
}
//获取内部类对象
public Contents contents() {return new Contents();}
public Destination to(String dest) {return new Destination(dest);}
public static void main(String[] args) {
Parcel p = new Parcel();
p.ship("Bermuda");
//获取内部类对象
Parcel.Contents c = p.contents();
Parcel.Destination d = p.to("Borneo");
}
}
/*
output:
Bermuda
*/
若是想在除外围类的非静态方法之外的其他位置创建内部类对象，就需要具体指明这个对象的类型：OuterClassName.InnerClassName
内部类访问外围类
当生成一个内部类对象时，此对象与制造它的外围类对象之间就有了某种联系，它可以访问外围类对象的所有成员，而不需要任何特殊权限。此外，内部类还拥有外围类的所有元素的访问权限。
interface Selector{
boolean end();
Object current();
void next();
}
public class Sequence {
private Object[] items;
private int next = 0;
public Sequence(int size) {items = new Object[size];}
public void add(Object x) {
if(next < items.length) {
items[next++] = x;
}
}
//一个迭代器的实现
private class SequenceSelector implements Selector{
private int i = 0;
//访问外围类中的数组
public boolean end() {return i == items.length;} //检查是否到了末尾
public Object current() {return items[i];} //返回当前对象
public void next() {if(i < items.length) i++;} //移到序列中的下一个
}
public Selector selector() {return new SequenceSelector();}
public static void main(String[] args) {
Sequence sequence = new Sequence(10);
for(int i=0; i<10; i++)
sequence.add(Integer.toString(i));
//获取一个内部类对象
Selector selector = sequence.selector();
while(!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
}
}
/*
output:
0 1 2 3 4 5 6 7 8 9
*/
上面的例子是一个迭代器设计模式的例子，从例子中可以看出，内部类是可以访问到外围类的数据成员。当然内部类也是可以访问外围类的方法的，就像自己拥有它们，会使编程十分便利。
那么，内部类自动拥有对外围类所有成员的访问权限这是如何实现的呢？
当某个外围类对象创建了一个内部类对象时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。然后，在你访问此外围类的成员时，就是使用那个引用来选择外围类的成员。这些实现，编译器会处理，我们需要注意的就是：内部类的对象只有在与其外围类对象相关联的情况下才能被创建（此时的内部类是非static的）。
需要注意：一个内部类被嵌套多少层不重要，它仍旧可以透明地访问所有它所嵌入的外围类的所有成员。
使用.this和.new
前面我们获取内部类对象时，是使用外围类对象调用它的创建内部类的方法，那么有没有其他方式来创建内部类对象呢？还是有的。使用.new语法。举例如下，没有任何实际意义。
class A{
class B{
// ...
}
//...
public static void main(String args[]){
A a = new A();
A.B b = a.new B(); //错误的做法是 A.B b = new B();
}
}
我们必须使用外部类对象来创建内部类对象，这样也解决了内部类名字作用域问题，不必去声明a.new A.B()，但是需要注意a.new A.B()是错误的。最简单的理由便是内部类对象不能获取到外部类对象的引用。若是创建的是静态内部类，则不需要对外部类对象的引用，后面会介绍静态内部类。
关于.this的使用，是用于生成对外部类对象的引用：外部类的名字后面紧跟圆点和this。这样产生的引用自动地拥有正确的类型，这一点在编译期便可以被知晓并受到检查，因此没有任何运行时开销。
class A{
public void f(){
//...
}
class B{
public A getA(){
return A.this;
}
}
public static void main(String args[]){
A a = new A();
A.B b = a.new B();
b.getA().f();
}
}
private内部类
继续以前面的内部类访问外部类的代码说明。SequenceSelector是private的，在外部不能直接被创建，于是在Sequence中使用了一个创建方法获取该类对象。使用接口Selector引用指向该内部类对象操纵其内部方法。我们可以看出，在外部我们只是使用接口引用去操作，对内部类的具体实现是一无所知，甚至内部类的名称我们也不知道。这真的是很方便的隐藏了实现细节。private内部类给类的设计者提供了一种途径，通过这种方式可以完全阻止任何依赖于类型的编码，并且完全隐藏了实现的细节。
以上介绍了内部类的基本使用，看起来和使用普通的类并无两样，但是这只是内部类的简单使用，下面介绍内部类中的一些复杂的技术。
在方法和作用域内的内部类
不仅可以在类里面定义内部类，也可以在一个方法或者任意的作用域内定义内部类。
在方法的作用域内创建一个完整的类叫做局部内部类 。
class A{
int i = 0；
public void fun(){
class B{
i = 10; //可以访问外围类的成员
//...
}
}
//...
}
在任意作用域内嵌入一个内部类
class A{
public void fun(boolean b){
if(b){
class B{
...
}
//...
}
}
//...
}
B类被嵌入在if语句的作用域中，不是说明该类的创建时由条件的。其实，B类与其他类都一同编译过了，只是它将在if这个作用域内使用。
匿名内部类
interface Destination{
String readLabel();
}
interface Contents{
int value();
}
public class Parcel2 {
public Contents contents() {
//创建匿名内部类
return new Contents() {
private int i = 1;
@Override
public int value() { return i;}
};
}
public static void main(String[] args) {
Parcel2 p2 = new Parcel2();
Contents c = p2.contents();
}
}
contents()方法将返回值的创建与表示这个返回值的类的定义结合在了一起，并且这个类是匿名没有名字。这种语法指出的是：创建一个继承自Contents的匿名内部类的对象。通过new表达式返回的引用被自动向上转型为对Contents的引用。上述匿名内部类的语法是下述形式的简化：
public class Parcel2b{
class MyContents implements Contents{
private int i = 1;
public int value() { return i; }
}
public Contents contents() { return new MyContents();}
public static void main(String[] args) {
Parcel2b p2b = new Parcel2b();
Contents c = p2b.contents();
}
}
在匿名内部类中使用的是默认构造器生成Contents。但是，若基类需要一个有参数的构造器怎么办？
public class Wrapping {
private int i;
public Wrapping(int ii) { i = ii;}
public int value() {return i;}
}
使用普通的具体类作为基类。
public class Parcel3 {
public Wrapping wrapping(int ii) {
//将参数传给基类带参数的构造器
return new Wrapping(ii) {
@Override
public int value() {
return super.value() * 31;
}
};
}
public static void main(String[] args) {
Parcel3 p = new Parcel3();
Wrapping w = p.wrapping(21);
}
}
若是基类构造器带参数，则简单地将合适的参数传递给基类的构造器即可。在匿名内部类末尾的分号不是用来标记内部类结束标志的。实际上，是表达式的结束。
为匿名内部类创建一个构造器
在匿名内部类中定义字段时，可以使用形参为其进行初始化，但是使用的参数引用必须使用final修饰。
class A{
public void fun(final String str){
return new Destination(){
private String label = str;
public String readLabel { return label;}
}
}
}
我们可以使用此方法为匿名内部类中的字段进行初始化，那么有没有可能为匿名内部类创建一个构造器，使用构造器为字段进行初始化呢？我们要知道，匿名类是没有名字的，所以不可能创建一个有名字的构造器。但是，我们可以通过实例初始化的方式，达到构造器的效果。
abstract class Base{
public Base(int i) {
System.out.println("Base 构造器, i="+i);
}
public abstract void f();
}
public class AnonymousConstructor {
//变量i不要是final的，因为是给匿名内部类的基类使用，不会再匿名内部类的内部直接被使用
public static Base getBase(int i) {
return new Base(i) {
//实现构造器效果
{
System.out.println("内部类初始化");
}
@Override
public void f() {
System.out.println("匿名内部类f()");
}
};
}
public static void main(String[] args) {
Base base = getBase(31);
base.f();
}
}
/*
output:
Base 构造器, i=31
内部类初始化
匿名内部类f()
*/
对于匿名内部类而言，实例初始化的效果就是构造器。这也受到了限制，不能重载实例初始化方法。匿名内部类与正常的类的继承也有一些限制：匿名内部类可以扩展类也可以实现接口，但是一次只能选一个。
使用匿名内部类实现工厂方法
使用匿名内部类改善上篇博客中的工厂方法的模板。
interface Service{
void method1();
void method2();
}
interface ServiceFactory{
Service getService();
}
class Implementation1 implements Service{
Implementation1(){}
public void method1(){System.out.println("Implementation1 method1");}
public void method2(){System.out.println("Implementation1 method2");}
//使用匿名内部类
public static ServiceFactory factory = new ServiceFactory() {
@Override
public Service getService() {
return new Implementation1();
}
};
}
class Implementation2 implements Service{
Implementation2(){}
public void method1(){System.out.println("Implementation2 method1");}
public void method2(){System.out.println("Implementation2 method2");}
public static ServiceFactory factory = new ServiceFactory() {
@Override
public Service getService() {
return new Implementation2();
}
};
}
public class Factories{
public static void serviceConsumer(ServiceFactory fact){
Service s = fact.getService();
s.method1();
s.method2();
}
public static void main(String args[]){
serviceConsumer(Implementation1.factory);
serviceConsumer(Implementation2.factory);
}
}
/*
output:
Implementation1 method1
Implementation1 method2
Implementation2 method1
Implementation2 method2
*/
嵌套类
如果需要内部类对象与其外围类对象之间有联系，那么就可以将内部类声明为static。这通常称为嵌套类。
嵌套类与普通内部类的不同在于：
- 创建嵌套类对象不需要外围类对象。嵌套类对象没有外围类对象的隐式引用。
- 不能从嵌套类对象访问非静态的外围类对象。
普通的内部类不能含有static数据和static方法，也不可以包含嵌套类。但是嵌套类可以包含这些东西。
public class Parcel4 {
//嵌套类
public static class PContents implements Contents{
private int i = 1;
public int value() {return i;}
}
//嵌套类
protected static class PDestination implements Destination{
private String label;
private PDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {return label;}
//包含其他的嵌套类
public static void f() {}
static int x = 10;
static class AnotherLevel{
public static void f() {}
static int x = 10;
}
}
public static Destination destination(String s) { return new PDestination(s);}
public static Contents contents() {return new PContents();}
public static void main(String[] args) {
Contents c = contents();
Destination d = destination("Bermuda");
}
}
接口内的类
正常情况下，不能在接口中防止任何代码，但是嵌套类可以是接口的一部分。放置到接口中的任何类自动的都是public和static的。可以在接口的内部类中实现该外围接口。
public interface ClassInInterface {
void howdy();
//内部类实现外围接口
class Test implements ClassInInterface{
public void howdy() { System.out.println("Howdy!"); }
}
public static void main(String[] args) {
new Test().howdy();
}
}
/*
output:
Howdy!
*/
为什么需要内部类
使用内部类最吸引人的原因在于:
每个内部类都能独立地继承自一个接口的实现，无论外围类是否已经继承了某个接口的实现，对于内部类都没有影响。
内部类可以提供继承多个具体或抽象类的能力，使得一个类可以实现多继承。前面交给接口也实现了类的多继承问题，而内部类更有效地实现了“多重继承”。一个类可以使用内部类可以继承多个非接口类型（具体类或者抽象类）。如果拥有的是抽象类或具体类，而不是接口，那么只能使用内部类才能实现多重继承。
内部类除了可以解决“多重继承”，还有一些其他特性：
- 内部类可以有多个实例，每个实例都有自己的状态信息，与外围类对象的信息相互独立。
- 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
- 内部类没有令人迷惑的“is-a”关系，它就是一个独立的实体。
内部类的继承
内部类对象会隐式拥有外部类对象的引用，但是内部类的导出类却不会隐式拥有外部类的引用，所以需要在导出类的构造器中显式传递外部类的引用。
class Outer{
class Inner{}
}
public class InheritInner extends Outer.Inner{
public InheritInner(Outer o) {
//使用enclosingClassReference.super()语法提供必要的引用
o.super();
}
public static void main(String[] args) {
Outer outer = new Outer();
InheritInner ii = new InheritInner(outer);
}
}
内部类可以被覆盖吗？
如果创建了一个内部类，然后继承其外围类并又定义了一个与此内部类同名的内部类，会覆盖掉原来的内部类吗？答案是不会的。两个内部类是完全独立的两个实体，在自己的命名空间内。
内部类标识符
每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息（此信息产生一个“meta-class”，叫做Class对象），当然，内部类也会生成一个.class文件已包含它们的Class对象信息。这些文件的命名有严格的规则：外围类的名字，加上$，在加上内部的名字。若内部类是匿名的，编译器则会简单地产生一个数组作为其标识符。
如下代码生成的.class文件为
class A{
class B{}
}
class C{}
class D{
public C getC() {
return new C() {
};
}
public static class E{}
}
public class ClassFile {
public static void main(String[] args) {
new D().getC();
}
}
小结
本篇博文主要讲了内部类的定义以及一些特殊的用途，其实在Java的GUI编程中也经常使用内部类，博主没有过多介绍，感兴趣的看官可以去搜搜了解。内部类的如何使用，还是要根据实际的设计情况去安排，先了解有这些用法，用时再取也不迟。不再做过多总结了，有问题的地方望各位看官指出。
参考：
《Java编程思想》第四版
来源：https://www.cnblogs.com/myworld7/p/10414401.html