定义：将一个类的定义放在另一个类的定义的内部，叫做内部类。
内部类的使用场景一：
public class Out {
class In{
private int i = 5;
}
public void say(){
In in = new In();
System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
}
public static void main(String[] args){
Out out = new Out();
out.say();
}
/**
* Console:5
*/
}
在上面的代码中，为了方便将main方法定义在Out类中，但是实际应用中main方法往往不在Out类中定义。而在该方法中使用了out对象的say()方法，该方法内部使用了In的一个对象。
同样的。我们可以利用外部类来得到一个内部类。如下：
public class Out {
class In{
private int i = 5;
public int i2 = 6;
}
public void say(){
In in = new In();
System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
}
public In getIn(){
return new In();
}
public static void main(String[] args){
Out out = new Out();
out.say();
In in = out.getIn();
System.out.println(in.i2);
}
/**
* Console:5
6
*/
}
如果将上面的代码的最后一句改为System.out.println(in.i);也是可以正确运行的。所以这里有一个问题是，既然i是一个私有的成员变量，为什么可以被main访问呢？这里的main方法定义在Out类内部，前面说到在Out类是可以访问内部类的私有属性的。我们将main方法定义在外部：
public class Out {
class In{
private int i = 5;
public int i2 = 6;
}
public void say(){
In in = new In();
System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
}
public In getIn(){
return new In();
}
}
public class Main {
public static void main(String[] args){
Out out = new Out();
out.say();
In in = out.getIn();//这里报错。
System.out.println(in.i2);
}
}
出现了一个错误：In cannot be resolved to a type。
加入import Out.In提示：The import Out cannot be resolved
所以新的问题是：
如何在外部类的外部实例化一个内部类？
按照前面说的，如果在Out类定义一个方法getIn()便可以返回一个内部类的实例。但是如果将main方法定义在外部，同样会出现In类无法解析的错误。
先说明一个问题，为什么要实例化内部类？当生成一个内部类的对象的时候，该对象于制造它的外围类的对象之间就有了一种联系，所以它能访问其外围对象的所有成员，而不需要任何特殊的条件，这与C++的嵌套类不同，在C++中只是单纯的名字隐藏机制，与外围对象没有联系，也没有隐含的访问权。（来自《Java编程思想》）
实例化的代码可以参考：
public class Out {
class In{
private int i = 5;
public int i2 = 6;
public void say2(){
System.out.println("this is from In!");
}
}
public void say(){
In in = new In();
System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
}
public In getIn(){
return new In();
}
}
public class Main {
public static void main(String[] args){
Out out = new Out();
Out.In in = out.new In();//注意Out.In 和out.new语法
in.say2();
}
}
上面的代码说明的是，在创建某个内部类的对象的时候，必须在new表达式中提供对其他外部类对象的引用。这时候需要使用.new语法。（百度百科说，内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。这将在我们下文的通过反射机制实现内部类得到体现。内部类虽然是一个独立的类，但是在一般的构造时却需要外部类的介入。）
现在有了新的问题，既然外部类可以调用内部类，那么内部类可以调用外部类吗？答案是可以的。
代码太长，就简要地说，语法上是在需要调用外部类的内部类方法中，使用以下的语句：
public Out getOut(){
return Out.this;
}
this指向的是内部类还是外部类？外部类。
除了以上的种种，内部类还有一个好处，那就是当内部类实现了某一个接口（或者继承了某一个抽象类）的时候，可以做到完全不可见，也不可用，这样能够很方便地隐藏实现的细节。比如
public interface interfaceForInner {
public void say1();
public void say2();
}
public class Out {
public String out_str = "this is from Out!";
class In implements interfaceForInner{
public void say1() {
System.out.println("this is from in.say1!");
}
public void say2() {
System.out.println("this is from in.say2!");
}
}
public In getIn(){
return new In();
}
}
public class Main {
public static void main(String[] args){
Out out = new Out();
Out.In in = out.getIn();
in.say1();
in.say2();
}
}
此外，内部类还可以在外部类的方法中定义。不过这样子一来，该内部类便只是方法的一部分，而不是外部类的一部分。在该方法的外部是不能够访问该内部类的。
public class Out {
public int value(){
class In{
public int i = 15;
}
In in = new In();
return in.i;
}
class Inn{
public int i = 155;
}
public static void main(String[] args){
Out out = new Out();
out.value();
//In in = new In();//报错
Inn inn = new Inn();//不报错
}
}
内部类有另外一种实现机制的方式，那就是——匿名内部类。比如：
public interface In {
public int value();
}
public class Out {
public In getIn(){
return new In(){
private int i = 11;
public int value(){
return i;
}
};
}
public static void main(String[] args){
Out out = new Out();
In in = out.getIn();//这里涉及了多态，new In(){}是一个实现接口的类。而不是一个接口。
System.out.println(in.value());
//In inn = new In();//报错。因为接口不可以实例化。
}
}
因为是匿名的，所以无法在外部实例化。
上面的代码其实等价于在外部类定义一个内部类比如MyIn；然后该内部类实现了接口In，然后getIn方法返回了new MyIn();。
现在又有了新的问题：外部类和内部类因为关系联系在一起，如果我不需要内部类对象和外围类对象之间有联系，该怎么办呢？答案是将内部类声明为static，这叫做嵌套类。static关键字是指，被定义的东西仅于类层面的定义者有联系，而与对象层面的定义者实例无联系。普通的内部类对象隐式地保存了一个引用，指向创建它的外围类对象（注意，是对象），但当内部类是static的时候，意味着：
1）要创建嵌套类的对象，并不需要外围类的对象
2）不能从嵌套类的对象中访问非静态的外围类的对象。
嵌套类与普通的内部类还有一个区别：普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是嵌套类可以包含所有这些东西。（《Java编程思想》）
public class Out{
static class In{
public int value = 1;
}
public static In getIn(){
return new In();
}
}
public class Main {
public static void main(String [] args){
Out out = new Out();
//Out.In in = out.new In();//这里报错。
Out.In in = Out.getIn();
System.out.println(in.value);
}
}
作为一个独立的类，还需要实现被继承的功能。如果实例化一样，如果要继承一个外部类的内部类，需要以以下的形式：
public class InheritInner extends Out.In{}
现在考虑另一个机制：多态。若有一个子类继承了父类Out.它是否拥有父类的内部类呢？且看实例分析：
public class Out{
class In{
public int value = 1;
public int getValue(){
return value_out;
}
}
public int value_out = 1;
}
public class Out2 extends Out{
public int value_out = 2;
}
public class Main {
public static void main(String [] args){
Out2 out2 = new Out2();
Out2.In in = out2.new In();
System.out.println(in.getValue());
}
}
编译的时候并没有报错。运行结果是1，内部类定义于Out类中，则与Out类的对象之间有了联系。Out2类实例化的时候也是先实例化了Out类的一个对象。
那么，子类若拥有同名的类，是否能够将其覆盖呢？其实在Java里，这样的两个内部类是完全独立的两个实体，各自在自己的命名空间里。内部类在编译的时候也会产生一个.class文件，它们的名字是外围类的名字加上“$”再加上自己的名字，所以尽管在子类和父类中同名的内部类，其实也被编译为拥有不同的命名空间的类。
如果内部类是匿名的，编译器会简单地产生一个数字作为其标识符。如果内部类是嵌套在别的内部类之中，只需直接将它们的名字加上其外围类标志与"$"的后面。
如下例子：
public class Out{
class In{
public int value = 1;
public int getValue(){
return value_out;
}
class Inn{
public int value = 8;
}
}
public int value_out = 1;
}
编译之后的文件为：若Out2有内部类In，则还有一个Out2$In.class文件
最后是通过反射机制实例化内部类的尝试。
public class Out{
class In{
public int value = 1;
public int getValue(){
return value_out;
}
}
public int value_out = 1;
}
public class Main {
public static void main(String [] args){
Out.In in = null;
try {
in = (Out.In)Class.forName("Out$In").newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(in.value);
}
}
上面程序报错：java.lang.InstantiationException: Out$In
at java.lang.Class.newInstance0(Class.java:357)
at java.lang.Class.newInstance(Class.java:325)
at Main.main(Main.java:6)
Exception in thread "main" java.lang.NullPointerException
at Main.main(Main.java:17)
内部类是与外部类在对象层次联系在一起的，如果没有实例化外部类不可以实例化内部类。所以我们将内部类定义为static提升到类层面。运行成功，代码如下：
public class Out{
static class In{
public int value = 1;
public int getValue(){
return value_out;
}
}
public static int value_out = 1;//注意static调用到value_out,所以这里应该设为静态变量。
}
以上为今天学习内部类的笔记。学习书籍为《Java编程思想》，参考了百度百科和一些博客，代码为自己写的。肯定有所遗漏和错误的地方，请帮忙指出！谢谢！