一般来说，内部类继承自某个类或实现了某个接口，内部类代码操作创建它的外部类的对象，可以说，内部类提供了某种进入外部类的窗口，而且内部类自己本身实现了有效的代码隐藏。 内部类必须要回答的一个问题是：如果只是需要一个接口的引用，为什么外部类不直接实现接口呢。答案是：如果这能满足需求，就应该这么做！那么内部类实现一个接口于外部类实现这个接口有什么区别呢？答案是：后者并不总能享受接口带来的便利，有时候需要接口的实现。使用内部类最吸引人的地方在于： 外部类可以有多个内部类，每个内部类都能够独自实现一个接口（继承一个类），且无论外围类是否实现该接口（继承该类）都不会对内部类产生影响。
我们考虑这样一种情况，在一个类中需要以某种方式实现两个接口A和B。这两个接口相互独立，彼此直接没有任何联系。那么有两种方式：
直接实现两个接口该类实现接口A，另外构建一个内部类实现接口B 一般情况下两种方式都可以，但对于第二种方式来说，它把两个接口的实现完全分离，并且可以隐藏B接口实现的细节。 拿HashMap举例，就是通过内部类来实现Iterator接口的，既实现了hashmap的遍历功能，又保证了得到的遍历器能够访问原来的map对象并且对外部来说完全隐藏了遍历器的实现细节。如果现在需要hashmap实现另一个反向遍历接口ReIterator，那么只需要再定义一个内部类实现反向遍历接口，通过方法返回内部类实例就可以，并不需要修改外部类的实现接口。另一种情况：如果好巧不巧的，A、B两个接口有一个相同的方法（虽然方法名相同，但完全独立，是两个互不关联的方法），那么第一种方式就不可行了，因为你只能在类中定义一个该方法，无法区分属于哪个接口。
另外一点：可以定义多个内部类，并且这些内部类相互独立。考虑这样一种情况，在一个类中需要以某种方式实现多个接口（5个以上并且每个接口的方法很多)那么，如果直接实现这些接口，那么类中的方法数量将会很多，类会变得很庞大，这也不符合代码分离的理念。 从某种程度上来说，内部类完善了java的多继承
在单个外部类中，可以让多个内部类以不同的方式实现同一个接口或继承同一个类。就像HashMap，我们可以以多种方式实现遍历操作。
回调用于层间协作。例如一个驱动，是一个地层。但有数据传给它时，它不仅要处理自己本层的工作，还要进行回调，将数据传给它的上层供上层处理。 回调跟API有点相似，都是跨层级调用的。不过与API不同的是，API是下层提供给上层去调用的，那么上层主动去调用下层API，这叫Call，上层是知道所调用的下层方法的。但回调不同，回调是上层提供给下层去调用的，而且具体方法下层是不知道的，下层只知道自己需要在某些条件下调用这个方法。上层向下层注入自己的程序（比如一个对象），然后下层通过这段程序（这个对象）来反过来调用上层的方法，这叫回调。
而Java的回调呢，就是通过接口和内部类来实现的。通常是别人提供一个接口，我用内部类实现这个接口并将内部类的一个实例注入到（传递给）别人的程序，别人的程序再通过我传入的示例来调用方法。 举例说明: //
/** ICallBack接口和Print类就好比是别人提供的程序 **/ //接口类 public interface ICallBack { public void execute(); } public class Printer { ICallBack icb; public Printer(ICallBack icb){ this.icb = icb; } //提供给外部去调用的。即提供一个接口，我不去具体实现它，由外部程序来实现。再在想要的时候去回调外部的方法。我没有实现接口，但我拥有一个是实现了接口的外部对象，我通过外部对象去调用外部的方法。 public void print(){ System.out.println("print start ========");//固定部分 icb.execute(); //抽象部分，由外界去实现 System.out.println("print end ========");//固定部分 } } /PrintHandle相当于外部类 public class PrintHandle { public void printf(){ System.out.println("printHandle print"); } public void go(){//创建了一个匿名类对象并传递给Printer，通过内部类Printer也可以调用我的printf()方法了，这叫回调 Printer print = new Printer(new ICallBack() { @Override public void execute() { printf(); } }); print.print(); } public static void main(String[] args) { PrintHandle printHandle = new PrintHandle(); printHandle.go(); } }另外再写一个测试方法运行时间的类
public class TestTime { public Long getTime(ICallBack icb){ long start = System.currentTimeMillis(); icb.execute(); long end = System.currentTimeMillis(); return end-start; } } //现在我要测试运行一遍test()方法需要多长时间 public class TestTimeMain { public void test() {//需要测试的方法 List<Map<String,String>> list = new ArrayList<>(); for (int i = 0; i < 10000; i++){ HashMap map = new HashMap<String,String>(); list.add(map); } } public static void main(String[] args) { TestTimeMain main = new TestTimeMain(); TestTime testTime = new TestTime(); //测试test()方法运行的时间，只要将这个方法放到匿名内部类的execute()里面就可以了 long time = testTime.getTime(new ICallBack() { @Override public void execute() { main.test(); } }); System.out.println(time); } }回调的另一种方式：我称之为自身回调。 有两个接口worker(工人)和programmer(程序员)，这两个接口都有一个work()方法，现有一个员工，要求它以某种方式实现这两个接口。这只能通过内部类来实现
Interface Worker{ void work(); } Interface Programmer{ void work(); } class Employee implements Worker{ public void work(){//作为工人在工作 System.out.println("worker is working"); } public void code(){//作为程序员在编程 System.out.println("programmer is programming"); } class Clousure implements Programmer{ public void work(){ code(); } } private class Clousure implements Programmer{ public void work(){ code(); } } public Programmer getCallBack(){ return new Clousure(); } public static void main(String[] args) { Employee employee = new Employee(); employee.work(); employee.getCallBack().work(); } }