版权声明：学习内容均为本人笔记，代码均为本人依据课本所写或改编，笔记均为个人心得或书中摘抄
引言：内部类，即将一个类的定义放在另一个类的定义内部。内部类与组合是完全不同的概念。内部类看似是一种代码的隐藏机制，其实，它能够了解外部类，并且与之通信，这为我们的编程提供了极大的方便。
1.9内部类的继承
如何继承一个内部类？根据前面的内容，内部类中会有一个捕获自创建它外部类对象的引用，如果继承该内部类，这个外部类的引用也要被连接初始化，内部类中也不存在可连接的默认对象。
//212页
class WithInner{
class Inner{}
}
public class InheritInner extends WithInner.Inner{
//public InheritInner(){} 不能使用该构造器，因为没有获取父类外部类的引用
public InheritInner(WithInner wi) {
wi.super();//通过父类外部类的引用初始化继承的内部类
}
public static void main(String[] args){
WithInner wi=new WithInner();
InheritInner i1=new InheritInner(wi);
}
}
在继承内部类的类中，必须获取一个创建内部类的外部类对象的引用，通过这个引用调用内部类父类进行初始化操作。
注意：这里Inner内部类我们使用的是一个默认构造函数，是没有参数的。如果有参数又该如何呢：
class WithInner{
class Inner{
public Inner(int i) {}//带有参数的构造函数
}
}
public class InheritInner extends WithInner.Inner{
//public InheritInner(){} 不能使用该构造器，因为没有获取父类外部类的引用
public InheritInner(WithInner wi) {
wi.super(1);//调用父类构造器时，需要一个符合父类构造器的参数
}
public static void main(String[] args){
WithInner wi=new WithInner();
InheritInner i1=new InheritInner(wi);
}
}
此时内部类Inner中有一个带有参数的构造器，此时我们在继承内部类的InheritInner类中，调用父类时应该添加相应的参数。
1.10内部类可以被覆盖吗
如果有一个类，并且该类有一个内部类，那么创建一个新类继承该外部类，然后在新类中重新创建此内部类会覆盖父类中的内部类吗？
//212页
class Egg{
private Yolk y;
protected class Yolk{
public Yolk(){
System.out.println("Egg.Yolk()");
}
}
public Egg(){
System.out.println("New Egg()");
y=new Yolk();
}
}
public class BigEgg extends Egg{//继承了一个外部类
public class Yolk{//重写继承外部类中的内部类
public Yolk(){
System.out.println("BigEgg.Yolk()");
}
}
public static void main(String[] args){
new BigEgg();
}
}/*Output:
New Egg()
Egg.Yolk()*/
创建自身对象时，会调用父类构造器，然后父类构造器中顶一起了内部类，然后输出的结果并不是子类中的内部类，也就是说父类并没有获取子类内部类的对象，也就不存在转型。两个内部类没有什么关系，它们各自在自己的命名空间内。
当BigEgg中的内部类明确继承了BigEgg父类Egg外部类中的内部类Yolk类。
//213页
class Egg2{
private Yolk y=new Yolk();//先与构造器前初始化，调用内部类构造器
protected class Yolk{
public Yolk(){//内部类构造函数
System.out.println("Egg2.Yolk()");
}
public void f() {//内部类f()方法
System.out.println("Egg2.Yolk().f()");
}
}
public Egg2(){//初始化之前，先初始化字段
System.out.println("New Egg2()");
}
public void insertYolk(Yolk yy){//获取一个Yolk类或子类的引用
y=yy;
}
public void g(){
y.f();//调用y引用指向的类的f()方法
}
}
public class BigEgg2 extends Egg2{
public class Yolk extends Egg2.Yolk{
public Yolk(){
System.out.println("BigEgg2.Yolk()");
}
public void f(){
System.out.println("BigEgg2.Yolk().f()");
}
}
public BigEgg2(){
insertYolk(new Yolk());//首先初始化父类BigEgg，然后调用本类中的Yolk类的构造函数，然后调用inserYolk()方法
}
public static void main(String[] args){
Egg2 e2=new BigEgg2();//调用BigEgg2()构造器，向上转型为Egg2类
e2.g();
}
}/*Output:
Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk().f()
*/
BigEgg2.Yolk2明确的继承了Egg2类中的内部类Yolk，并且覆盖了f()方法。insertYolk()方法，将子类BigEgg2中的内部类对象转型为父类Egg中的内部类，当g()调用f()方法时，覆盖的f()方法被执行。
可能很多人第一次看不懂这个输出的结果，我分析了程序的执行步骤：
1、main()方法中new BigEgg2()调用了BigEgg2()构造器，由于BigEgg2()继承自Egg2，所以首先初始化父类Egg2类
2、父类Egg2初始化时，首先对字段进行初始化，所以初始化了Yolk对象的y，new Yolk()时就当用了内部类Yolk的构造函数
3、执行Egg2.Yolk的构造函数，第一次输出产生“Egg2.Yolk()”
4、执行Egg2的构造函数，第二次输出产生“New Egg2()”
5、返回到子类BigEgg2中，执行insertYolk(new Yolk()，首先执行方法中的new Yolk()，调用BigEgg2.Yolk的构造函数
6、由于BigEgg2.Yolk继承自Egg2.Yolk，所以先调用Egg.Yolk中的构造函数，第三次输出产生”Egg2.Yolk()“
7、返回到子类BigEgg2.Yolk中，执行构造函数，第四次输出产生”BigEgg2.Yolk()“
8、此时BigEgg2的构造全部结束，返回到main中向上转型为Egg2
9、执行e2.g()方法，调用y.f()方法，由于Egg2中Egg2.Yolk的引用y存入的是子类BigEgg2.Yolk的引用，所以会调用BigEgg2.Yolk中的f()方法
10、执行BigEgg2.Yolk中的f()方法，第五次输出产生”BigEgg2.Yolk().f()“
1.11局部内部类
可以在类中创建匿名内部类，静态内部类，普通内部类，也可以在代码块里创建内部类，典型的方式就是在一个方法体的内部里面创建。局部内部类不能有访问说明符，因为它不是外部类的一部分，但是它可以方位当前代码块内的常量（Java8中传入到内部类的值不一定是final类型的，只要初始化后不被修改即可），以及此外围类的所有成员。
创建局部内部类和创建匿名内部类比较
//214页
interface Counter{
int next();//用于返回序列中的下一个值
}
public class LocalInnerClass {
private int count=0;
Counter getCounter(final String name){
class LocalCounter implements Counter{//局部内部类，定义在方法中
public LocalCounter(){
System.out.println("LocalCounter()");
}
public int next(){
System.out.print(name);
return count++;
}
}
return new LocalCounter();
}
Counter getCounter2(final String name){
return new Counter(){//匿名内部类
{
System.out.println("Counter()");
}
public int next(){
System.out.print(name);
return count++;
}
};
}
public static void main(String[] args){
LocalInnerClass lic=new LocalInnerClass();//创建外部类对象
Counter c1=lic.getCounter("Local inner");//通过外部类对象调用方法创建局部内部类
Counter c2=lic.getCounter2("Anonymous inner");//通过外部类对象创建匿名内部类
for(int i=0;i<5;i++)
System.out.println(c1.next());
for(int i=0;i<5;i++)
System.out.println(c2.next());
}
}/*Output:
LocalCounter()
Counter()
Local inner0
Local inner1
Local inner2
Local inner3
Local inner4
Anonymous inner5
Anonymous inner6
Anonymous inner7
Anonymous inner8
Anonymous inner9*/
分别创建了局部内部类LocalCounter类和匿名内部类实现了Counter接口，该接口用于返回序列中的下一个值，这两个内部类具有了相同行为和能力。
局部内部类和匿名内部类的区别：局部内部类的名字在方法外是不可见的，局部内部类可以重载构造器，而匿名内部类只能用于实例初始化，没有构造器。
所以当我们需要不止一个内部类的对象时，应该选择局部内部类而不是匿名内部类。
1.12内部类标识符
由于每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息（此信息产生一个”meta-class“，叫做Class对象），内部类也会生成一个.class文件以包含它们的Class对象信息。这些类的命名有严格的规则：外围类的名字，加上”$“，再加上内部类的名字。例如，LocalInnerClass.java生成的.class文件包括：
Counter,class
LocalInnerClass$1.class
LocalInnerClass$1LocalCounter.class
LocalInnerClass.class
如果是匿名内部类，编译器会简单的产生一个数字作为其标识符。如果内部类嵌套在别的内部类中，只需将它们的名字加在其外部类标识符与$的后面。
1.13总结
在内部类章节中，我们了解到了一个普通内部类必须要通过外部类对象来创建，并且它会获得一个外部类对象的引用，这样它就能访问外部类对象中的所有成员了。然而对于一个嵌套类也就是静态内部类来说，它不需要外部类对象就能创建对象，因为它是静态的属于类本身，不过这也限制了它的操作，静态内部类不能访问非静态的外部类对象。除此之外，普通的内部类也不能包含static的字段和数据，我把它想象成属于外部类对象的某个”方法“，显然，普通内部类只能通过外部类对象创建，static数据和字段不属于对象，所以会同类一起编译存储在静态区，那么这个静态区属于哪个类其实是未知的。
在本章中，我们也发现了，JAVA相对本书版本已经更新了，在JAVA8的版本中，内部类接收的参数已经不必必须声明为final常量了（现在你也可以这么做），但是如果不声明为final，编译器要求这个值初始化后不能被修改，否则会报错，这是因为在Java中的传值操作，如果这个值在外部类中被修改，那么内部类得到的数值可能已经发生改变，得到了不是期望的值，这会带来很大的问题。
作用域中的类与其它类共同编译，但只在作用域内可用，在其他作用于使用相同的域名不会有命名冲突。同时，如果一个类继承了一个外部类，并且创建了相同的内部类时，其实并不会被覆盖，只有当这个继承的类创建了继承自父类中内部类的一个类时，才会出现覆盖的可能。
Java内部类完美的实现了多重继承，虽然我们可以通过实现多个接口来实现多重继承，但是如果拥有的是抽象的类或者具体的类时，那只能用内部类才能实现多重继承。
通过学习，我们也发现了内部类强大的功能。我们编写了控制温室的案例，用一个外部类继承控制框架，用多个内部类来继承各种事件，我们将控制与行为进行了分离，不仅利于代码的维护，还为开发提供了极大的方便。
温馨提示：如果有什么错误，或者有什么意见（对于排版、知识块内容选取、讲述方式等），烦请评论或私聊，也许您的一个建议和一点指点能使我更加完善自己，也能让您感受到帮助他人的乐趣。祝您的编程之路一帆风顺！
