改章节朋友在上海逛街的时候突然想到的...最近就有想写几篇关于内部类类的条记，所以回家到之后就奋笔疾书的写出来发布了
定义：将一个类的定义放在另一个类的定义的内部，叫做内部类。
内部类的使用场景一：
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编程思想》，参考了百度百科和一些博客，代码为自己写的。确定有所漏掉和错误的地方，请帮助指出！感谢！
文章结束给大家分享下程序员的一些笑话语录： 一个程序员对自己的未来很迷茫，于是去问上帝。
"万能的上帝呀，请你告诉我，我的未来会怎样？"
上帝说"我的孩子，你去问Lippman，他现在领导的程序员的队伍可能是地球上最大的"
于是他去问Lippman。
Lippman说"程序员的未来就是驾驭程序员"
这个程序员对这个未来不满意，于是他又去问上帝。
"万能的上帝呀，请你告诉我，我的未来会怎样？"
上帝说"我的孩子，你去问Gates，他现在所拥有的财产可能是地球上最多的"
于是他去问Gates。
Gates说"程序员的未来就是榨取程序员"
这个程序员对这个未来不满意，于是他又去问上帝。
"万能的上帝呀，请你告诉我，我的未来会怎样？"
上帝说"我的孩子，你去问侯捷，他写的计算机书的读者可能是地球上最多的"
于是他去问侯捷。
侯捷说"程序员的未来就是诱惑程序员"
这个程序员对这个未来不满意，于是他又去问上帝。
"万能的上帝呀，请你告诉我，我的未来会怎样？"
上帝摇摇头"唉，我的孩子，你还是别当程序员了"）