《Java编程思想》之为什么需要内部类？

上接《Java编程思想》之内部类——深奥而复杂

13、为什么需要内部类？

1).内部类最吸引人注意的原因是：每个内部类都能独立的继承自一个（接口的）实现，所以无论外围类是否已经继承了某个就（接口的）实现，对于内部类都没有影响。

2).一个类中以某种方式实现两个接口。由于接口的灵活性，你有两种选择：使用单一类，或者使用内部类。从实现观点看，以下俩种方式没什么区别。

interface A{} interface B{} class X implements A, B{} class Y implements A{ B makeB(){ return new B(){ }; } } public class MultiInterfaces{ static void takesA(A a){} static void takesB(B b){} public static void main(String[] args){ X x = new X(); Y y = new Y(); takesA(x); takesA(y); takesB(x); takesB(y.makeB()); } }

3).如果拥有的是抽象类或具体的类，而不是接口，那就只能使用内部类才能实现多重继承。

4).内部类还可以获得其他一些特性（不是很理解！！）：

·内部类可以有多个实例，每个实例都有自己的状态信息，并且与外围类对象的信息相互独立。

·在单个的外围类中，可以让多个内部类以不用的方式实现同一接口，或继承同一个类。

·创建内部类对象的时刻并不依赖外围类对象的创建。

·内部类并没有令人迷惑的“is-a”关系；它就是一个独立的实体。

请看下面例子：

interface Selector{ boolean end(); Object current(); void next(); } public class Sequence{ private Object[] objects; private int next = 0; public Sequence(int size){ objects = new Object[size]; } public void add(Object x){ if(next < objects.length) objects[next++] = x; } private class SSelector implements Selector{ private int i = 0; public boolean end(){ return i == objects.length; } public Object current(){ return objects[i]; } public void next(){ if(i < objects.length) i++; } } public Selector getSelector(){ return new SSelector(); } public static void main(String[] args){ Sequence sequence = new Sequence(10); for(int i = 0; i < 10; i++) sequence.add(Integer.toString(i)); Selector selector = sequence.getSelector(); while(!selector.end()){ System.out.println(selector.current()); selector.next(); } } }

如果Sequence不适用内部类，就必须声明“Sequence是一个Selector”,对于某个特定的Sequence只能又一个Selector。同时，使用内部类很容易就能拥有另一个方法getRSelector(),用它来生成一个反方向遍历的Selector。只有内部类才有这种灵活性。

14、闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。内部类是面向对象的闭包。因为它不仅包含外围类对象（“创建内部类的作用域”）的信息，还自动拥有一个指向此外围对象的引用，在此作用域内，内部类操作所有成员，包括“private”成员。

15、Java最具有争议的问题之一就是，人们认为Java应该包含某种类似指针的机制，以允许回调。通过回调，对象能够携带一些信息，这些信息允许它在稍后的某个时刻调用初始的对象。

通过内部类提供闭包的功能是完美的解决方案，它比指针更灵活、更安全。见下例：

interface Incrementable{ void increment(); } //外部类实现接口 class Callee1 implements Incrementable{ private int i = 0; public void increment(){ i++; System.out.println(i); } } class MyIncrement{ void increment(){ System.out.println("MyIncrement.increment()"); } static void func(MyIncrement myIncrement){ myIncrement.increment(); } } class Callee2 extends MyIncrement{ private int i = 0; private void incr(){ i++; System.out.println(i); } //内部类实现接口 public class Closureimplements Incrementable{ public void increment(){ incr(); } } Incrementable getCallBackReference(){ return new Closure();//向上转型 } } class Caller{ private Incrementable callBackReference; Caller(Incrementable callBackReference){ this.callBackReference = callBackReference; } void go(){ callBackReference.increment(); } } public class Callbacks{ public static void main(String[] args){ Callee1 c1 = new Callee1(); Callee2 c2 = new Callee2(); MyIncrement.func(c2); Caller caller1 = new Caller(c1); Caller caller2 = new Caller(c2.getCallBackReference()); caller1.go(); caller1.go(); caller2.go(); caller2.go(); } }

   Callee2继承自MyIncrement,有一个与Incrementable接口相同名字的increment()方法,但是两者的Increment()方法行为不同。所以如果Callee2继承了MyIncrement，就不能为了Incrementable的用途而覆盖increment()方法，于是只能使用内部类独立的实现Incrementable。还要注意，当创建了一个内部类时，并没有在外围类的接口中添加东西，也没有修改外围类的接口。

   Callee2中内部类Closure 里的getCallBackReference()方法，返回一个Incrementable的引用，无论谁获得此引用，都只能调用increment()，除此之外没有其他功能（不像指针那样，允许你做很多事情）。

       回调的价值在于它的灵活性——可以在运行时动态决定需要调用什么方法。

16、

1). 应用程序框架(applicationframeword)就是被设计用来解决某类特定问题的一个类或一组类。

2).要运行某个应用程序框架，通常是继承一个或多个类，并覆盖某个方法。

3).控制框架是一类特殊的应用程序框架，它用来解决响应事件的需求。

4).主要用来响应事件的系统被称作事件驱动系统。

点击请看一例子，能更好了解内部类的价值。

以上内容整理自《Java编程思想》，若有遗漏，请您不吝指出！

转载于:https://www.cnblogs.com/myittec/archive/2012/01/29/2392769.html