最近刚把《java编程思想》第十章内部类看完，有关类的介绍也就告一段落，而我脑子里始终萦绕的是那些继承、接口、内部类以及它们各自琐碎的语法，让我不知如何是好。我决定抛开这些细枝末节，重构一下我对对象组成的新理解，把以上那些名词编制成网，方便记忆和理解。其中若有不对的地方，欢迎指正，谢谢大家。同时这篇文章我决定换一种轻松明朗的书写风格，让大家看的愉快。
1.类的理解。
从我开始学Java时，知道类被作为一种数据类型，可以自己随意造类时，我觉得惊讶不已。因为我觉得程序中只能包含26个字母以及10个数字，加上一些运算符号，这些才是计算机所能识别的语言，要不然电脑怎么了解你要传递的信息呢。而Java通过编写一个类，往这些类里面塞变量、方法，这个类被编译执行，最终表现形式也还是转化为以上提到的那些符号，来跟虚拟机交流。所以类应该算是一个中间层的角色。它封装着我们对事物的理解，在这个层面上，我们用Java提供的语法写类，就像我们用熟悉的词语、语法写一篇文章。虚拟机会把我们的“文章”用它熟悉的语言翻译一遍，在这个过程中，我们之前的一行行代码都被拆解，最终如一个完整的n*n拼图被打乱一样。我们很难从零乱的拼图中窥见完整图形的原貌，但实际上这是虚拟机按自己的思维又重新拼的图案。虚拟机得到了信息之后它就知道自己该干什么，接下来的事我们也就无需过问了。毕竟我们最最重要的事怎么写出一个个类来准确表达信息。
通常我们用许多属性来描述一件事物。古人说：一阴一阳之谓道。如果把阴理解为“静”，阳理解为“动”，那么万事万物都具有动静两种属性。例如我们人都具备的眼睛、鼻子、手、脚，这些都属于静态属性，它成了人的特征；此外人还具有动态属性，能吃喝打闹，蹦蹦跳跳，它成了人的行为。静态属性对应的就是类的成员变量，动态属性对用的则是方法。于是按这种思想把一种事物抽象成类，就具有了实实在在的意义。
2.继承
有很多伟大的科学家取得重要成就时，总会谦虚地说：我是站在巨人的肩膀上的。说明很多成功都是利用现成的资源，没必要自己去重新走老路造轮子。我对继承的理解同此，如果一个初始类类用一个圆来表示，继承的使命就是扩展初始类，也就是让这个圆变大，可以包含更多属性。它通过在初始圆的外层再画一个圆，把旧圆包含进去，达到目的。此外还有一种常用方法（组合）来扩展类：建一个新类，将新类的成员变量为设置初始类的引用。也就是新类存着一把可以访问初始类的钥匙。类似这样的钥匙越多，这个类可以访问的属性也就越多，也达到了扩展类的目的。而这两种扩展类的方式的使用场景是怎样的呢？一言以蔽之：根据两个类的所属关系。类A -交通工具，类B表示汽车，类C表示发电机。汽车是这一种特殊的交通工具，即B is A，所以B extends A；汽车里有发电机，即B has C，所以C c可作为B的成员变量。
3.多态
因为继承，所以多态。（这里的继承也包括implements）多态给人印象最深的还是它的向上转型加动态绑定。写了这么多字，还是来一段“名言”吧：
class Pig{ public void getInfo() { } } //麦兜 class MaiDou extends Pig{ public void getInfo() { System.out.println("两情若是久长时，又岂在猪猪肉肉"); } } //佩奇 class PeiQi extends Pig{ public void getInfo() { System.out.println("小猪佩奇身上纹，掌声送给社会人"); } } public class Test { public static void show(Pig pig) { pig.getInfo(); } public static void main(String[] args) { Pig md = new MaiDou(); Pig pq = new PeiQi(); show(md); show(pq); } } //output: // 两情若是久长时，又岂在猪猪肉肉 // 小猪佩奇身上纹，掌声送给社会人
这段代码中只要理解Pig md = new MaiDou()，以及show（）的调用过程就行。首先，创建麦兜对象，将这个对象引用向上转型赋给Pig,说明麦兜是猪，就像海水是水一样合乎情理。后面show（）方法接受pig类型的参数，然后getInfo()调用了我们期盼的结果，为什么会这样。这源于Java语言的动态性。Java中有个名词：绑定。意思是：方法的调用与方法所在的类进行关联。绑定分为：静态绑定，动态绑定。静态绑定是指：在编译Java文件时就已经知道方法对应的是哪个类。常见的的私有方法、final 方法、静态方法、构造方法都是静态绑定。这四种方法的共同点就是，要么不能被继承（如私有方法、final方法、构造方法），要么被继承也不能被重写（如静态方法），于是这些方法就只和声明它的那个类文件进行了绑定。动态绑定则有趣的多。来我们分析一下pig.getInfo():
1.在编译的时候：编译器对这个方法只做一个很简单的判断：pig(及其它的父类、父父类。。)有没有getInfo()方法。没有就报错，有就通过编译。
2.在运行期，找到md实际引用的那个对象，也就是麦兜。老规矩，查看麦兜（及其它的父类、父父类。。）中的所有getInfo()方法，哪个方法参数与当前这个方法参数最相符，就调用哪个。
多态就是基于动态绑定实现的。了解了这个过程，多态运行的结果也就理所应当。
4.接口
如果你想扩展你的类，不能总是依赖继承，继承让你的对象像滚雪球一样越滚越大，其中还掺杂着你可能不需要的属性方法。例如：你想飞，那就继承鸟吧，顺便给你一层厚厚的羽毛，以及捕虫子的方法-囧。所以我们需要一种轻巧的扩充类的方法，这就是接口的意义。接口的实现其实与继承的意思相差无几，所以实现接口也可以说继承接口。一个类可以继承一个父类，但可以实现多个接口，简单的可以直接理解为多重继承。另外接口体现在多态上的范围要比继承在多态上的范围还要宽广。举个例子：当你的方法参数为一个鸟类时，你传递的参数只能是鸟类和鸟类的导出类，但如果你的方法参数为一个飞行接口，任何继承（实现）这个接口的类都可以传，那我可以传鸟类和它的导出类，还可以传飞机类和它的导出类。
关于接口，还有一点值得一提。上面说到接口作为一种更轻巧的方式扩充类，我们常见的情况是接口最常见的是只定义抽象方法，而很少定义变量，即使定义了变量，也必须把它声明为一个初始化的常量。这个原因网上很多说的比较明白，这里我简单回顾一下：接口是为了定制统一的规约，它要达到这个目的，你只能改我允许你改的部分，其余的部分你只能用我的。接口已经把方法扩展的权利拱手相让了，如果它里面的变量都还可以被实现类修改，那它个规约的所有地方都能被修改，那算什么规约！所以有了static让接口的变量被接口所公有，而不是每个实现类独占一份；有了final关闭了实现类修改的权利。还有一个原因是我自己琢磨的：多态是在方法调用上体现出来的，而成员变量并不具备多态的特征。
class Father{ int age = 45; } class Son extends Father{ int age = 21; } class Daughter extends Father{ int age = 24; } public class Test { public void showAge(Father f) { System.out.println(f.age); } public static void main(String[] args) { Son son = new Son(); Daughter daughter = new Daughter(); Test t = new Test(); t.showAge(son); t.showAge(daughter); } } // output // 45 45
f.age()并没有如我们期望那样，找到儿子、女儿对象，分别显示他们的年龄，也就是多态没有体现出来。所以接口中的变量不能在实现过程中不能表现出多态，如果继承不是为了多态，那么继承毫无意义！那还不如就声明为常量。当然这个理由，并没有前面的有力，只当自己的一种看法与大家探讨。
5.内部类
内部类作为最后的大佬总算要登场了！内部类的定义很简单，在类的里面再定义一个类，里面的那个类就是内部类。根据内部类所处的位置以及修饰符，于是有了位于成员变量同一级别的成员内部类，位于方法中（也可以说是代码块中）的局部内部类，用static修饰的嵌套类，以及大名鼎鼎的匿名内部类。在介绍在四种内部类之前，我们先看看为什么要有内部类，总得找个让人信服的理由。一句话概括就是：内部类的出现就是为了完善java的多重继承（再次重申一次，全文中的继承都可以理解为继承+实现）机制。怎么个完善法呢？先前用接口时，我们是这样扩充类的：A extends B implements C,D,E... ，这样A 的肚子了就装下了B,C,D,E。但实际运用过程中，会发现有些情况需要的继承结构更细致精确。举个例子：一个女孩觉得自己的鼻子不好看，想把鼻子整个容，这时候，没必要整个人全身上下都整，她仅仅只需要整的是她这个对象的某个成员变量（鼻子）。也就是对她的鼻子实现整容接口，而不是让她整个人实现整容接口。还有一些情况，如：太空飞船实现了航天接口，为了飞向宇宙探险，而飞船中有一个逃生舱，它也实现了航天接口，对同一接口，它的行为是为了返回地球。类与它的成员都要实现同一个接口，这种情况也只能使用内部类实现。从这两个例子可以看出使用继承多个接口的方式还是过于粗犷，内部类将继承关系拆解到类的里面，从而达到更准确更有针对性的继承。而且内部类还提供了相应的技术支持，那就是在定义内部类的时候，我们可以在内部类里面访问外部类的所有成员，不管你是方法还是成员变量，不管你是私有还是公开。外部类对它而言就是打开自家冰箱。在这里，顺便提一点我经常会犯的错误。书中提到：当生成一个内部类对象时，它能访问其外围对象的所有成员。我当时的理解是：
public class Test { private int a =10; class Father{ public int getVar() { return a; } } public Father getFather() { return new Father(); } public static void main(String[] args) { Test t = new Test(); Test.Father f = t.getFather(); f.a//f根本不能访问外围类的变量a } }
我想当然的理解为内部类对象可以直接点点点，父类的成员。后来才知道，Father与Test是两个独立的class文件，class定义的时候，压根就没有a，怎么能访问呢？书中的那句话我的理解是，它可以畅通无阻的访问外围类的所有成员是在定义class的时候，也就是我们在写Test这个类时，所有的成员都在这同一个类里，根据内能访问外的规律，所以内部类可以外围类的所有成员。而在实际运行过程中，外围对象跟内部类对象关系也很紧密，因为内部类可以访问修改外部类。只要你要编写内部类的时候，写了相应的方法就行，如上面代码中的getVar()，我用f.getVar()还是可以拿到a 的。这里注意一下：就算你外部类的所有的方法变量都是私有的，只要你的内部类里提供了访问外部类成员的方法，那么只要得到了内部类对象，也就得到了打开外部类的钥匙。这就是内部类被称作闭包的原因吧。
另外，四种不同的内部类，实际用的最多的应属匿名内部类和成员内部类了，
interface Fly{ void fly(); } public class Test { class Bird implements Fly{ @Override public void fly() { System.out.println("成员内部类实现了接口"); } } public Fly getBird() { return new Bird(); } public void show(Fly f) { f.fly(); } public static void main(String[] args) { Test t = new Test(); Fly bird = t.getBird(); t.show(bird); t.show(new Fly() { @Override public void fly() { System.out.println("匿名内部类实现了接口"); } }); } } //output //成员内部类实现了接口 //匿名内部类实现了接口
匿名内部类是浓缩版的成员内部类，它的显著特征是没有构造器。所以如果你想要继续创造内部类实现对象，那就用成员内部类好了；如果只需要一个继承接口（抽象类）的对象，那么匿名内部类更简洁。另外还有局部内部类和静态内部类，用的少我就不多讲了，而且当你理解了java方法的动态绑定特征后，理解内部类的实际调用情况简直so easy！