先来理解2个概念：闭包和回调
- 什么是闭包？
闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建他的作用域。通过这个定义，可以看出内部类是面向对象的闭包，因为他不仅包含了外部类对象的信息，还自动拥有一个指向外部类对象的引用，在此作用域里，内部类有权操作所有的成员，包括外部类的private修饰的成员。
- 什么是回调？
回调就是对象携带一些信息，这些信息允许它在稍后的某个时刻调用初始化的对象。说白了就是说：某个方法一旦获得了内部类对象的引用，就可以在合适的时候反过来调用外部类实例的方法。非静态内部类，可以很方便的实现回调。
- 值得说明的是：内部类最大的作用就是实现了多继承。java是单继承的，使用内部类可以使得编程更加的灵活。
看下面3种情形：
1，必须在同一个类中以某种方式实现2个接口？
public class Linkin implements A,B{
@Override
public void testB() {
}
@Override
public void testA() {
}
}
interface A{
public void testA();
}
interface B{
public void testB();
}
上面的情形很简单，但是举一个例子，说这2个方法同名呢？ 那要怎么办呢？我们可以在实现类里面直接实现那个方法，但是这样子肯定是不好的。一个接口规范了一个功能，怎么好意思讲同一个实现类同一个实现来实现2个不同规范的功能呢？ 有解决办法：使用内部类。
public class Linkin implements A{
//定义一个方法，返回一个实现了B的匿名内部类，去实现B
B makeB(){
return new B(){
@Override
public void test() {
System.out.println("实现接口B...");
}
};
}
//这里是外部类，直接实现了接口A
@Override
public void test() {
System.out.println("实现接口A...");
}
}
interface A{
public void test();
}
interface B{
public void test();
}
2，还是上面一样的情形，但是一个是普通的类，一个是抽象类呢？ 这个时候就只能使用内部类了。
public class Linkin extends A{
//使用内部类，可以很好实现多继承
B makeB(){
return new B(){
@Override
public void test() {
System.out.println("这里来实现下面那个抽象类B的方法。。。");
}
};
}
}
class A{
public void test(){
System.out.println("这里是A类的一个方法。。。");
}
}
abstract class B{
abstract public void test();
}
3，还是上面的情形，现在一个是普通的类，一个是接口，里面都包含一个同名的方法，要如何实现写一个新的class来实现上面2个功能呢？如何正常一个直接继承，一个实现，代码是这样子的：
public class Linkin extends A implements Binger{
@Override
public void test(){
System.out.println("这里是B类的一个方法。。。");
}
public static void main(String[] args) {
Linkin linkin = new Linkin();
linkin.test();
}
}
class A{
public void test(){
System.out.println("这里是A类的一个方法。。。");
}
}
interface Binger{
//以后再写接口的时候，就不要再罗里吧嗦的写什么public了 默认都是public abstract的
void test();
}
很明显的不符合需求，那么要怎么办呢？内部类。
public class Linkin extends A {
public Binger getBinger(){
return new Binger(){
@Override
public void test() {
System.out.println("这里是B接口的实现。。。");
}
};
}
public static void main(String[] args) {
Linkin linkin = new Linkin();
linkin.test();
linkin.getBinger().test();
}
}
class A{
public void test(){
System.out.println("这里是A类的一个方法。。。");
}
}
interface Binger{
//以后再写接口的时候，就不要再罗里吧嗦的写什么public了 默认都是public abstract的
void test();
}
上面的代码呢？符合需求了，但是如果我想有的时候直接在外部类就使用到binger这个接口里面的那个规范方法呢？有没有稍微高深点的方法呢？回调。
/**
*
* @version 1L
* @author LinkinPark
* @since 2014-11-6
* @motto 梦似烟花心似水，同学少年不言情
* @desc ^现在的代码就有点NB了，我们既可以直接使用外部类2个不同名的方法，来调用A和BInger里面那2个方法，又可以调用一个方法，得到内部类，使用同名的方法
*/
public class Linkin extends A {
//A类里面的Test方法通过继承得到
//这里的这个方法其实就是接口Binger的Test实现方法
public void otherTest(){
System.out.println("这里是B接口的实现。。。");
} private class BingerImpl implements Binger{
@Override
public void test() {
otherTest();
}
} //这里返回上面那个内部类的引用，在以后使用的时候就不用来每次new内部类了
public Binger getBinger(){
return new BingerImpl();
} public static void main(String[] args) {
Linkin linkin = new Linkin();
linkin.test();
//下面2行代码功能一样
linkin.otherTest();
linkin.getBinger().test();
} } class A{
public void test(){
System.out.println("这里是A类的一个方法。。。");
}
} interface Binger{
//以后再写接口的时候，就不要再罗里吧嗦的写什么public了 默认都是public abstract的
void test();
}