将一个类的定义放到另一个类定义的内部——内部类。用java写Android的朋友经常用的Listener的东西，里面就是内部类。而且，不要单纯地以为就java才能开发Android。
1)简单的内部类
内部类的功能看似隐藏了代码，其实不然。
public class Ticket {
class Destination{
private String content;
Destination(String s){
content = s;
}
String showContent(){
return content;
}
}
public void show(String dest){
Destination d = new Destination(dest);
System.out.println(d.showContent());
}
public static void main(String[] args) {
Ticket t = new Ticket();
t.show("BeiJing");
}
}
一个简单的内部类，就是一个普通类嵌套在内部。
public Destination getDestination(){
return new Destination("ShangHai");
}
public static void main(String[] args) {
Ticket t = new Ticket();
Ticket.Destination dest = t.getDestination();
Destination d = t.new Destination("GuangZhou");
t.show("BeiJing");
}
如果从静态方法中创建内部类对象，如果是直接new的话要用上面的写法，而用了返回值为对象的方法的需要指明对象的类型。
2)链接到外部类
内部类拥有其外围类(enclosing class，enclosing是封闭的意思，书上翻译成外围类对象)的所有元素的访问权。直接用书上的例子。
public class Sequence {
private Object[] item;
private int next = 0;
public Sequence(int size){
item = new Object[size];
}
public void add(Object x){
if(next<item.length){
item[next++]=x;
}
}
private class SimpleItertor implements MyIterator{
private int index = 0;
/*public boolean end() {
if(next == item.length){
return true ;
}
return false;
}代码冗余 其实可以写的更简洁
*/
public boolean end() {
return index == item.length;
}
public Object current() {
return item[index];
}
public void next() {
if(index<item.length){
index ++;
}
}
}
public MyIterator iterator(){
return new SimpleItertor();
}
public static void main(String[] args) {
Sequence s = new Sequence(10);
for(int i = 0; i < 10 ; i++){
s.add(i);
}
MyIterator i = s.iterator();
while(!i.end()){
System.out.println(i.current());
i.next();
}
}
}
为什么把这个例子写进来呢，一个是这个类似我们经常使用容器的Iterator，其实也应用了设计模式——迭代器模式。还有内部类中用了外围类的私有成员进行操作。
3)使用.this和.new
public class Outer {
class Inner{
Outer getOuter(){
return Outer.this;
}
}
}
如果是单纯的this的话，this指向的是Outer.Inner，如果返回Outer对象，还是需要Outer.this。
.new的话在第一个知识点的时候提到了。需要
Destination d = t.new Destination("GuangZhou");
内部类对象会偷偷地连接到外部类对象，所以在创建外部类对象之前是不能创建内部类的，当时如果为静态内部类（嵌套类）就不需要外部类对象的引用。
public class Outer {
static class Inner{
}
public static void main(String[] args) {
Inner i = new Inner();
}
}
4)内部类用处——向上转型
更高深的隐藏代码。其实书上再举例子。不过回头再看发现已经用过一次了。
private class SimpleItertor implements MyIterator{}
public MyIterator iterator(){ return new SimpleItertor(); }
其实我们在代码已经隐藏了这个实现类的实现细节，属性为私有，返回的时候是将SimpleIterator向上转型为通用的接口。
5)方法和作用域中的内部类。
public class Outer {
public void get(){
class Inner{
}
}
}
方法内部，称为局部内部类。
作用域方面，如果内部类声明在if条件语句下作用域中，那超出这个域也是不可用的。
6)匿名内部类
public class Outer {
public Sequence get() {
return new Sequence(1) {};
}
}
虽然返回Sequence对象，但是却是你可以在花括号里面定义自己的东西。这对于外面来说就是匿名的。
如果匿名内部类使用其外部定义对象,参数要有final。
class Inner{}
public class Outer {
public Inner get(final String s){
return new Inner(){
String type = s;
};
}
}
Cannot refer to a non-final variable s inside an inner class defined in a different method.不能把内部类里面非final变量s放进一个不同的方法中定义。
7)嵌套类
上面提到的静态内部类。和静态方法的特点类似。创建嵌套类对象不需要外部类对象引用，不能从嵌套类对象访问非静态外围类对象（静态方法的是不能在静态方法中使用非静态方法）。
8)为什么需要内部类
这东西设计来干啥，要知道其实语言是人设计的，特性也是自己设计的，没用的是不会专门设计出来的。
内部类实现接口和外围类实现接口是不同的，每个内部类都能继承接口，外围类继承了谁并不会对内部类造成影响。在使用GUI的时候，更能感受到内部类的价值。
9)闭包和回调
闭包，closure，指的是可调用对象记录一些信息，信息来自创建他的作用域。其实内部类就是。
10)内部类标识符
在没有使用IDE之前的那段时间，纯粹在dos窗口编译的时候，经常会去看编译后的文件是什么样子的。有时会看到Outer$Inner.class文件的存在，其实这就是编译器编译的结果，外围类加上$再加上内部类的名字。
接口和内部类这两章真的很复杂很深奥，内部类这里还有一个控制框架是我没写出来的。C++没有这些东西，接口和内部类的结合可以解决C++多重继承的问题。写的还不多，接触到这两者还比较少，以后接触到再来看就知道价值所在了。
可以将一个类的定义放在另一个类的内部，这就是内部类。
1.可以实现隐藏
2.内部类了解外围类，并能与之通信，很多时候可以写出更加优雅和清晰的代码
10.1创建内部类
public class Outer{
class Inner{
}
}
如果想从外部类的"非静态方法之外"的任意位置创建某个内部类对象，那么必须具体指明这个对象的类型：OuterClassName.InnerClassName
10.2链接到外部类
内部类自动拥有对外围类所有成员的访问权，这是如何做到的呢？当外围类对象创建了一个内部类对象时，此内部类对象必定会秘密的捕获一个指向那个外围类对象的引用，在访问外部类对象成员时，就是用这个引用来访问。编译器会帮助我们处理这些细节，而我们使用时，就像是内部类本身带有的一样。所以非static内部类在创建时候必须要由外部类对象来创建。
10.3使用.this与.new
如果要使用外部类对象的引用，OuterClassName.this来获取，编译器会检查类型是否正确，无运行时开销。
创建内部类对象：要先有外部类对象Outer o = new Outer();然后用外部类对象创建内部类对象Outer.Inner i = o.new Inner();不可以用o.new Outer.Inner();
10.4内部类向上转型
当把private内部类向上转型成基类，尤其是接口的时候，内部类就有了用武之地：这个接口的实现可以完全隐藏，完全不可见，因为返回的是接口引用
参考java源码AbstractList类:
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
...
}
当我们外界使用迭代器的时候
Iterator iter = arrayList.iterator();
只能拿到接口的引用，完全不知道里面是一个private内部类,因为Itr是private的，也不能创建它。
10.5在方法和作用域内的内部类
局部内部类：定义在方法体或者某一作用域里，超出作用域不能使用。
注意：不能使用意味着在外部不能被访问到类型，但是该类型在JVM里是实际存在的，即使这个作用域已经结束。
10.6匿名内部类
没有名字的内部类，可以有带参构造器，可以添加并初始化域。
如果在内部类的内部要使用外部的一个对象，这个对象的引用需要是final的。构造器中使用的参数不需要是final的。
匿名内部类里不能自己添加构造器(因为不能被访问到，而且没名字)，需要做一些初始化的时候，可以用代码块来实现。
匿名内部类与正规的继承相比，要么扩展类，要么实现接口，不能二者都有，并且只能实现一个接口。
10.6.1再访工厂方法
可以把工厂方法改成匿名内部类。
interface Game{boolean move();}
interface GameFactory{Game getGame();}
class Checkers implements Game{
private Checkers(){}
private int moves = 0;
private static final int MOVES = 3;
public static GameFactory factory = new GameFactory(){
public Game getGame(){return new Checkers();}
};
public boolean move(){
return ++moves != MOVES;
}
}
10.7嵌套类-静态内部类
1)创建静态内部类对象不需要外部类对象
2)不能从静态内部类对象访问外围内的非静态成员
普通内部类不可以有static字段，静态可以有
10.7.1接口内部的类
正常情况下，接口内部是不能放任何代码的，但是嵌套类可以放。放入接口中的任何类都是public static的。
用途：如果你想创建某些公共代码，使得它们可以被这个接口的所有实现使用，那么接口中嵌套内部类就会非常方便。
10.7.2在多层嵌套类中访问外部类成员
一个内部类被嵌套多少层并不重要，它可以透明的访问所有外围类的所有成员。
class MMA{
private void f(){}
class A{
private void g(){}
public class B{
void h(){
f();//直接调用 没有问题
g();
}
}
}
}
10.8为什么需要内部类
一般来说，内部类继承某个类或实现某个接口，并且可以操作外围类对象。
核心原因：内部类可以提供多重继承的能力。
比如： AbstractList里有Itr和ListItr两种迭代器，如果我们只是让AbstractList实现Iterator接口，那么只能写出一个迭代器，通过使用内部类方式可以添加多个迭代器。
10.8.1闭包与回调
如果有一个类需要实现一个接口来提供某个方法，但是发现这个方法已经被另外一个接口使用了，那么可以用内部类代替这个类去实现接口。
回调的价值在于它的灵活性---可以在运行时动态决定需要调用什么方法。
10.8.2内部类与控制框架
设计一个控制框架，要求到了设定时间就执行相应的事件：
//创建一个抽象事件类，有执行时间和延迟时间，在产生新事件的时候用延迟时间计算出执行时间，action方法由实现类实现。
public abstract class Event{
private long eventTime;
protected final long delayTime;
public Event(long delay){
this.delayTime = delay;
start();
}
public void start(){
eventTime = System.nanoTime() + delayTime;
}
public boolean ready(){
return System.nanoTime >= eventTime;
}
public abstract void action();
}
//创建一个控制类，循环遍历所有事件，如果事件时间到了就执行action
public class Controller{
private List<Event> eventList = new ArrayList<>();
public void addEvent(Event e){eventList.add(e);}
public void run(){
while(eventlist.size()>0){
for(Event e : eventList){
if(e.ready){
e.action();
eventlist.remove();
}
}
}
}
}
从上面这2个类的设计来看，我们完全不知道event具体做什么，但是我们整个控制框架的核心功能："把变化的事物(event具体实现)，与不变的事物(时间发生过程)"分开。而我们只需要创建不同的变化的Event，这正是内部类要做的事情：
1)控制框架里的实现是由单个类创建的，从而使得实现细节被封装起来。内部类用来表示解决问题所必须的不同action。
2)内部类可以很容易访问外部类成员，这种实现不会显得很笨拙。
控制框架：
public class GreenhouseControls extend Controller{
private boolean light = false;
public class LightOn extends Event{
public LightOn(long delay){super(delay);}
public void action(){
//hardware control code to turn on light
light = true;
}
}
public class LightOff extends Event{..}
private boolean water = false;
public class WaterOn extends Event{
public WaterOn(long delay){super(delay);}
public void action(){
//..
water = true;
}
}
//...其他内部类
}
控制框架中用内部类把实现细节都隐藏起来了。
那么如何使用这个框架并执行需要的事件呢：
public static void main(String[] args){
GreenhouseControls gc = new GreenhouseControls();
gc.addEvent(gc.new LightOn(100));
gc.addEvent(gc.new LightOff(200));
...
gc.run();
}
控制框架可以体现出内部类的价值，图形界面设计里更是让人信服。
10.9内部类的继承
内部类的构造器必须连接到外围类对象的引用，如果一个类继承了内部类，那么如何保证外围类对象存在呢？需要使用特殊语法：
1.在导出类添加一个带外围类参数的构造器
2.构造器里用outer.super()来提供外围类引用
例如：
class Outer{
class Inner{}
}
public class InheritInner extends Outer.Inner{
InheritInner(Outer o){
o.super();
}
}
10.10内部类可以被覆盖吗
class Outer{
class Inner{}
}
class Outer2 extends Outer{
class Inner{}
}
在Outer里调用Inner并不会被Outer2里的Inner覆盖，即不会产生多态特性。
10.11局部内部类
在方法体里使用局部内部类和使用匿名内部类有什么区别呢？
唯一的区别在于：局部内部类可以有命名的构造器，并且可以被重载用来初始化，可以产生多个对象。而匿名内部类只能提供一个该类型的对象。
10.12内部类标识符
匿名内部类： Outer类名 $ 数字
成员内部类: Outer类名 $ 内部类名
局部内部类: Outer类名 $ 数字 内部类名
10.13总结
接口和内部类实现了C++的多重继承功能，但是更优雅，更简洁。
可以将一个类的定义放在另一个类的定义内部,这就是内部类.
内部类的定义是简单的,但是它的语法确实很是复杂,让人不是很好理解.下面就内部类做一个小结.
一.内部类的分类
总的来讲内部类分为普通内部类,匿名内部类,局部内部类,嵌套类(静态内部类)等.下面简要的介绍以下这些内部类定义的语法.
(1).对于普通的内部类,就是在外围类中插入另一个类的定义.如下面的代码:
1 package lkl1;
2
3 ///封装一个包裹类
4 public class Parcel {
5
6 ///在一个类的内部定义的另一个类,称之为内部类
7 ///它的定义形式并没有什么不同
8 public class Destination{
9 private String label;
10 Destination(String whereto){
11 label=whereto;
12 }
13 public String getLabel(){
14 return label;
15 }
16 }
17
18 public class Contents{
19 private int i=11;
20 public int value(){
21 return i;
22 }
23 }
24 ///提供一个统一的创建内部类的接口
25 public Destination destination(String s){
26 return new Destination(s);
27 }
28 public Contents contents(){
29 return new Contents();
30 }
31
32 public void ship(String dest){
33 //其实也可以直接调用构造器定义
34 //Contents c1 = new Contents();
35 Contents c = contents();
36 Destination d = destination(dest);
37 System.out.println(d.label);
38 }
39 public static void main(String[] args){
40 Parcel p = new Parcel();
41 p.ship("changsha");
42
43 Parcel p1= new Parcel();
44
45 ///为内部类定义引用,注意名字的层次
46 ///在非静态方法中定义内部类的对像需要具体指明这个对象的类型
47 ///OuterClassName.InnerClassName
48 Parcel.Contents c =p1.contents();
49 System.out.println(c.i);
50 Parcel.Destination d = p1.destination("wuhan");
51 }
52 }
(2).所谓的匿名内部类的定义语法比较奇特.匿名内部类是没有名字的,所以我们不能想一般的类那样调用构造器得到它的对象,一般我们都将它放在一个方法中,这个方法负责返回这个匿名内部类的一个对象.因为匿名内部类没有名字,所以也就不能通过构造器来实现初始化了,我们可以通过初始化块的形式达到构造器的效果(当然我们是可以调用基类的构造器来初始化基类的成员变量).如下面的代码:
1 package lkl1;
2
3 public class Parcel3 {
4 ///用于匿名内部类变量初始化的形参必须要用final修饰
5 //Destination是前面定义的一个类.
6 public Destination destination(String dest,final double price,int i){
7 ///创建匿名内部类的一般格式
8 return new Destination(i){ ////可以通过调用基类的构造器进行基类的初始化
9 private int cost;
10 {///用初始化块达到类似于构造器的初始化过程
11 cost =(int) Math.round(price);
12 if(cost>100){
13 System.out.println("Over budget!");
14 }
15 }
16 private String label=dest;
17 public String readLabel(){
18 return label;
19 }
20 };
21 }
22 public static void main(String[] args){
23 Parcel3 p3= new Parcel3();
24 Destination d = p3.destination("changsha", 109.234,10);
25 System.out.println(d.readLabel());
26 }
27 }
(3)所谓的局部内部类其实就是在方法和作用域内定义的内部类.这种内部类只在一定的范围是有效的(其实上面的内部类就是一种局部内部类).一般我们是将其当成工具使用的,不希望它是公共可见的.如下面的代码:
1 package lkl1;
2
3 public class Test {
4
5 private PrintId create(){
6 ///外部类中的一个方法中定义内部类用于实现某个接口;
7 ///然后返回这个内部类的一个引用
8 {
9 ///PrintId是前面的定义的一个接口
10 class Print implements PrintId{
11 private String id;
12 public Print(){
13 id="longkaili";
14 }
15 public void print(){
16 System.out.println(id);
17 }
18 }
19 return new Print();
20 }
21 //试图在作用域外访问内部类出错
22 //(new Print()).id;
23 }
24 public static void main(String[] args){
25 ///以下说明了虽然内部类是定义在一个作用域类的
26 ///但是在外面还是可以使用它实现的功能的
27 Test ts = new Test();
28 ts.create().print(); ///在本类方法中创建本类的对象,其private接口是可见的
29 }
30 }
(4).嵌套类其实就是就将内部类声明成static.对于普通的内部类其必须要依赖于一个外部类的对象,而嵌套类是不需要的,我们可以将其看成一个static型的变量.如下面的代码:
1 package lkl1;
2
3 ///当内部类被声明成静态时,我们就将其当成一个静态成员来看待
4 ///此时内部类不在和外部类的对象绑定在一起.
5 public class Parcel1 {
6
7 private static class Parcel1Contents extends Contents{
8 private int i=1;
9 public int value(){
10 return i;
11 }
12 }
13 protected static class Parcel1Destination extends Destination{
14 private String label;
15 private Parcel1Destination(String whereTo){
16 label=whereTo;
17 }
18 public String readLabel(){
19 return label;
20 }
21 }
22 //我们可以通过外部类的静态方法创建嵌套类的对象
23 public static Destination destination(String s){
24 return new Parcel1Destination(s);
25 }
26 public static Contents contents(){
27 return new Parcel1Contents();
28 }
29 public static void main(String[] args){
30 Contents c= contents();
31 Destination d =destination("changsha");
32 }
33 }
二.外部类和内部类的联系.
既然内部类定义在了外部类的内部,那么肯定就具有一定的联系的.具体的我们分成非static型的一般内部类和static修饰的嵌套类来分析.
(1).首先对于一般的内部类,其和外部类的联系是很紧密的.体现在内部类的对象必须依附于一个外部类的对象,也就是说我们必须通过一个外部类的对象才能创建内部类的对象.其次,外部类的一切成员变量对于内部类都是可见的,包括private成员变量,而外部类也可以访问内部类的所有变量.另外,内部类还可以通过.this方式显式的访问其对于的外部类对象,外部类也可以通过.new方式创建内部类的对象(一般我们都是通过外部类的一个方法返回内部类的对象引用).下面的代码示范了这几点:
1 package lkl1;
2
3 ///测试外部类对内部类的访问权限
4 public class Outer {
5 private int k=100;
6 private class Inner{
7 private int i=100;
8 public int j=1111;
9 private void print(){
10 System.out.println("Outer.k = "+ k); ///内部类可以访问外部类的所有成员变量
11 System.out.println("Inner.print()");
12 }
13 ///非static内部类中不能创建static类型的变量
14 /// public static int k=999;
15 }
16 public void print(Inner in){
17 ///事实证明外部类同样可以访问内部类的所有方法,变量
18 ///当然前提是我们有一个内部类的对象,直接通过类名来访问是不行的
19 in.print();
20 in.i++; in.j++;
21 System.out.println(in.i);
22 System.out.println(in.j);
23 }
24 public static void main(String[] args){
25 Outer ot = new Outer();
26 Outer.Inner in = ot.new Inner(); ///通过.new创建内部类的引用,注意内部类引用的声明方式
27 ot.print(in);
28 }
29 }
(2).对于static修饰的嵌套类来说,情况就不同了.通过上面的例子我们可以看到普通的内部类对象隐式的保存了一个引用,指向创建它的外围对象.但对于嵌套类,它的对象不依赖于外部类的对象而存在,当然它也不能访问非静态的外围类对象.另外还有一点.普通类中是不能包括static方法,变量的,但是嵌套类中是可以包含这些东西的.如下面的代码所示:
1 package lkl1;
2
3 ///当内部类被声明成静态时,我们就将其当成一个静态成员来看待
4 ///此时内部类不在和外部类的对象绑定在一起.
5 public class Parcel1 {
6 //ContentsheDestination都是前面定义的抽象类
7 private static class Parcel1Contents extends Contents{
8 private static int k=110;
9 private int i=1;
10 public int value(){
11 return i;
12 }
13 }
14
15 //我们可以通过外部类的静态方法创建嵌套类的对象
16 public static Contents contents(){
17 return new Parcel1Contents();
18 }
19 public static void main(String[] args){
20 ///访问Parecel1的静态变量,注意调用格式
21 System.out.println("Parcel1Contents的静态变量k "+Parcel1.Parcel1Contents.k);
22 Contents c= contents();
23 }
24 }
三.内部类的作用
内部类的语法是很复杂的,但是在学习这些复杂语法的时候更令我迷惑的是:内部类有什么用?java编程思想一书是这么讲的:
1.每个内部类都能独立的继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响.
2.可以更好的实现多重继承.我们知道普通的类是不可以多重继承的,但是现在通过内部类,我们就可以对普通类达到多重继承的效果.
3.在一些设计模式中有重要的应用.
对于这些现在还不是都能理解的很清楚,希望在以后的学习中能够搞清楚.
下面给一个通过内部类实现迭代器的实例.下面的Sequence类是一个封装了一个Object数组的普通类,而Selector是一个通用的迭代器接口,我们在Sequence中通过一个内部类实现了Selector接口,然后通过这个内部类的接口向上转型后的对象对Sequence对象进行迭代访问.其实以前我们接触过得集合类的迭代器也就是这么实现的.
1 package lkl1;
2
3 ///定义一个通用的迭代器接口
4 public interface Selector {
5
6 boolean end();
7 Object current();
8 void next();
9 }
10
11
12 package lkl1;
13
14 ///Sequence类封装一个固定大小的
15 ///Object数组,然后提供它自己的一个迭代器
16 ///这里利用的是内部类可以访问外部类的所有数据的性质
17 public class Sequence {
18 private Object[] items;
19 private int next=0;///保留当前元素个数
20 public Sequence(int size){
21 items=new Object[size];
22 }
23 public void add(Object obj){
24 if(next<items.length){
25 items[next++]=obj;
26 }
27 }
28
29 ///封装一个内部类实现迭代器
30 private class SequenceSelector implements Selector{
31 private int i=0; ///当前访问到元素的编号
32 public boolean end(){
33 return i==items.length;
34 }
35 public Object current(){
36 return items[i];
37 }
38 public void next(){
39 if(i<items.length) i++;
40 }
41 }
42 ///提供迭代器对外的接口
43 public Selector selector(){
44 return new SequenceSelector();
45 }
46
47 public static void main(String[] args){
48 Sequence sq= new Sequence(10);
49 for(int i=0;i<10;i++)
50 sq.add(Integer.toString(i));
51
52 ///利用Sequence本身的迭代器来访问
53 Selector se =sq.selector();
54 while(!se.end()){
55 System.out.print(se.current()+" ");
56 se.next();
57 }
58 System.out.println();
59 }
60 }
可以将一个类的定义放在另一个类的定义内部，就叫做内部类。
内部类是一种非常有用的特性，因为他允许你把一些逻辑相关的类组织在一起，并控制位于类内部的可视性。
10.1创建内部类
1.外部类内直接定义，2.外部类有一个方法，返回指向内部类的引用。3.如果想从外部类的非静态方法之外的任意位置创建某个类的对象，必须指明这个类的类型：OuterClass.InnerClass。
10.2链接到外部类
内部类拥有所有其外围类的所有元素访问权限。
当某个外围类的对象创建一个内部类的对象时，此内部类的对象会秘密捕获外部类的对象的引用，然后当内部类访问外围类的成员时，就通过那个引用。
10.3使用.this和.new
外围类.this产生对外围类的对象的引用。告知某个对象去创建某个内部类对象：obj.new Inner();
在拥有外部类对象之前是不可能创建内部类对象的，如果是静态内部类则不需。
10.4内部类向上转型
private类型内部类能完全阻止任何依赖类型的编码，从而完全隐藏了实现细节。
10.5在方法和作用域的内部类
10.6匿名内部类
创建一个集成自接口的匿名类对象，通过new表达式返回的引用被自动向上转型为对接口的引用。
10.7嵌套类
不需要内部类对象与外围类之间关联，可以将内部类声明为static，这通常称为嵌套类。
每个类都会产生一个.class文件，内部类也是明明outer$Inner
、当将内部类向上转型为其基类，尤其是转型为一个接口的时候，内部类就有了用武之地（从实现某个接口的对象，得到对此接口的引用，与向上转型为这个对象的基类，实质上效果是一样得。）这是因为此内部类——某个接口的实现——对于其他人来说能够完全不可见，并且不可用。所得到的只是指向基类或接口的引用，所以能够很方便地隐藏实现细节。
interface Destination{
String readLabel();
}
interface Contents{
int value();
}
class Parce1{
private class PContents implements Contents{
private int i = 2012;
public int value() {
return i;
}
}
protected class PDestination implements Destination{
private String label;
private PDestination(String label){
this.label = label;
}
public String readLabel() {
return label;
}
}
public Destinationdest(String label){
return new PDestination(label);
}
public Contents cont(){
return new PContents();
}
}
public class TestParcel{
public static void main(String[] args){
Parce1 p = new Parce1();
Contents c = p.cont();
System.out.println(c.value());
Destination d = p.dest("Cannel_2020");
System.out.println(d.readLabel());
}
}
运行结果：
1).PContent是private的，所以除了Parcel，没有人能访问它。
2).Pdestination是protected，所以只有Parcel及其子类、还有与Parcel用包的类能访问。
3).这意味着，如果客户端程序员想了解或访问这些成员，那是要受限制的。
4).实际上，甚至不能向下转型成private内部类（或protected内部类，除非是继承自它的子类），因为不能访问其名字。
5).所以通过类似如上的方式，可以完全阻止任何依赖类型的编码，并且完全隐藏了实现的细节。
6).此外，从客户端程序员的角度来看，由于不能访问（为什么？）任何新增加的、原本不属于公共接口的方法，所以扩展接口是没有价值的。这也给Java编译器提供了生成更高效代码的机会。
7).以上是内部类的典型用途。
2、在一个方法或者任意的作用域内定义内部类的两个理由：
1).如前所示，你实现了某个类型的接口，于是可以创建并返回对其的引用。。
2).你要解决一个复杂的问题，想创建一个类来辅助你的解决方案，但是又不希望这个类是公共可用的。
3、局部内部类：在方法的作用域内（而不是在其他类的作用域内）创建一个完整的类。方法的执行完毕，并不意味该局部内部类就不可用了。另外，局部内部类不能有访问说明符。
4、匿名内部类：
public Contentscont(){
return new Contents(){
private int i = 2012;
public int value(){
return i;
}
};
}
其上是下述形式的简化形式：
public Contents cont(){
class MyContents implements Contents{
private int i = 2012;
public int value(){
return i;
}
}
return new MyContents();
}
若匿名内部类需要一个有参数的构造器：
class Wrapping{
int i = 0;
Wrapping(int i){
this.i = i;
}
public int value() {
return i;
}
}
public class Parcel{
public Wrapping wrap(int i){
return new Wrapping(i){
public int value(){
return super.value()*10;
}
};
}
public static void main(String[] args){
Wrapping w = new Parcel().wrap(2012);
System.out.println(w.value());
}
}
5、匿名内部类没有命名的构造器，但通过实例初始化，能够达到为一个构造器的效果。
abstract class Base{
public Base(int i){
System.out.println("基类的构造函数内, i = " + i);
}
public abstract void f();
}
public class AnonymousConstructor{
public static Base getBase(int i){
return new Base(i){
{
System.out.println("实例初始化器内");
}
public void f(){
System.out.println("在匿名内部类里的f()");
}
};
}
public static void main(String[] args){
Base base = getBase(2012);
base.f();
}
}
运行结果：
6、匿名内部类中使用一个在外部定义的对象，那么编译器会要求其参数引用是final的。
7、Java的内部类，拥有其外围类的所有元素的访问权。（这与C++的嵌套类的设计非常不同，在C++中只是单纯的名字隐藏机制与外围对象没有联系，也没有隐含的访问权。）
这是如何做到的呢？
当外围类的对象创建了一个内部类的对象时，此内部类对象必定会保存一个指向那个外围类对象的引用。在你访问外围类的成员的时候，就是那个“隐藏的”引用来选择外围类的成员。（构建内部类对象时，需要一个指向其外围类对象的引用，如果编译器访问不到这个引用就会报错。）
8、嵌套类：如果不需要内部类对象与其外围类对象之间的联系，那么可以将内部类声明为static。这通常称为嵌套类。
1).要创建嵌套类的对象，并不需要其外围类的对象。
2).不能从嵌套类的对象中访问非静态外围对象。
9、普通内部类与嵌套类的区别：普通内部类不能有static数据和static字段，也不能包含嵌套类。但是嵌套类可以包含所有这些东西。
10、普通内部类（非static）可以通过一个特殊的this引用可以链接到其外围类对象。嵌套类就没有这个特殊的this引用，这使得它类似一个static方法。
11、内部类的继承存在的问题：那个指向外围类对象的“秘密的”引用必须被初始化，而在导出类中不再存在可连接的缺省对象。例子如下：
class Outter{
Outter(){
System.out.println("Outter()");
}
class Inner{
Inner(){
System.out.println("Inner()");
}
}
}
public class InheritInner extends Outter.Inner{
InheritInner(Outter outter){
outter.super();
System.out.println("InheritInner()");
}
public static void main(String[] args){
Outter outter = new Outter();
InheritInner inheritInner = new InheritInner(outter);
}
}
虽然是继承内部类，但是当生产一个构造器时，缺省的构造器并不算好，而且不能只是传递一个指向外围类对象的引用，必须在构造器内使用如下语法：
outter.super();
这样才提供了必要的引用，然后程序才能编译通过。若缺省上面语句，会提示“由于某些中间构造函数调用，没有任何类型 Outter 的外层实例可用”的错误。
12、内部类的覆盖，比较俩个例子：
1).
class Outter{
private Inner inner;
Outter(){
System.out.println("基类Outter()");
inner = new Inner();
}
protected class Inner{
Inner(){
System.out.println("基类的内部类Inner()");
}
}
}
public class InheritInner extends Outter{
public class Inner{
public Inner(){
System.out.println("InheritInner重新定义的内部类Inner()");
}
}
public static void main(String[] args){
new InheritInner();
}
}
运行结果：
2).
class Outter{
private Inner inner;
Outter(){
System.out.println("Outter()");
inner = new Inner();
}
public void insertInner(Inner inner){
this.inner = inner;
}
public void outterFunc(){
inner.func();
}
protected class Inner{
Inner(){
System.out.println("Outter.Inner()");
}
public void func(){
System.out.println("Outter.Inner().func()");
}
}
}
public class InheritInner extends Outter{
public InheritInner(){
System.out.println("InheritInner()");
//下面语句先Outter.Inner()，再是InheritInner.Inner();
Inner inner = new Inner();
insertInner(inner);
}
public class Inner extends Outter.Inner{
public Inner(){
System.out.println("InheritInner.Inner()");
}
public void func(){
System.out.println("InheritInner.Inner().func()");
}
}
public static void main(String[] args){
Outter outter = new InheritInner();
outter.outterFunc();//动态绑定
}
}
运行结果：
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).主要用来响应事件的系统被称作事件驱动系统。
点击请看一例子，
内部类可以访问外围类的方法和字段，即是其外围类的方法和字段访问权设置为private。编译器会帮助内部类对象捕获一个指向那个外围类对象的引用。
创建内部类的方法
Out.Inner inner=new Out().new Inner();
或者：
Out out = new Out();
Out.Inner inner = out.new Inner();
例子：迭代器设计模式。
interface Selector {
boolean end(); Object current(); void next();
}
public class Sequence{
private Object[] items;
private class SequenceSelector implements Selector{
private int i=0;
public boolean end(){ return i==items.length; }
...//
}
public Selector selector(){
return new SequenceSelector();
}
}
Sequence sq = new sq(10);
Selector st = sq.selector();
while(!st.end()){
print(st.current());
}
创建内部类：在拥有外部类对象之前食不可能创建内部类对象的。这是因为内部类对象会暗暗地连接到创建它的外部类对象上。除非创建的是嵌套类（静态内部类），那么它就不需要对外部类对象的引用。
内部类与向上转型：
当内部类向上转型为其基类，尤其是转型为一个接口时，内部类就有了用武之地。这样，该内部类---某个接口的实现---能够完全不可见，并且不可用。所得到的只是指向基类或接口的引用，所以能够很方便地隐藏实现细节。
匿名内部类：
1.不可能有构造器，因为它没有名字。
2.如果希望它使用一个在外部定义的对象，那么编译器会要求其参数引用是final的（Why？见最下）。被传递给匿名类的基类的构造器除外，因为它不会在匿名内部类被直接使用。
3.匿名内部类既可以扩展类，也可以实现接口，但是不能两者兼备。而且如果是实现接口，也只能实现一个接口。
嵌套类：静态内部类
1.要创建嵌套类的对象，并不需要外围类的对象。 || Out.Inner inner= new Out.Inner();
2.不能从嵌套类的对象中访问非静态的外围类对象。
3.如果你想要创建某些公共代码，使得它们可以被某个接口的所有不同实现所公用，那么使用接口内部的嵌套类会显得很方便。
作者曾在本书中建议过，在每一个类中都写一个main()方法，用来测试这个类。这样做有一个缺点，那就是必须带着那些已编译
过的额外代码。如果这对你是个麻烦，那就可以使用嵌套类来测试代码。
public static class Tester{
public static void main(String[] args){
dosth;
}
}
这生成了一个独立的类Out$Tester,要运行这个程序,执行java Out$Tester即可，在发布产品之前，简单地删除Out$Tester.class即可
为何需要内部类：
一般来说，内部类继承某个类或实现某个接口，内部类的代码操作创建它的外围类的对象。但，如果只是需要一个对接口的引用，为什么不通过外围类实现那个接口呢？答案：如果能满足需求，那就应该这样做。 然而内部类最吸引人的原因是：
每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
接口解决了部分问题，而内部类有效地实现了“多重继承”。
1.内部类可以有多个实例，每个实例都有自己的信息，与外围类对象的信息互相独立。
2.在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。
3.创建内部类对象的时刻并不依赖外围类对象的创建。
4.内部类并没有令人迷惑的“is-a”关系；它是一个独立的实体。
EX：上述的Sequence类如果不使用内部类，就必须声明“Sequence是一个Selector”，对特定的某个Sequence只能有一个Selector。然而使用内部类很容易就能拥有另一个方法reverseSelector()，用它来生成一个反方向遍历序列的Selector。十分灵活。
内部类的继承
当继承某个外围类的时候，内部类并没有发生什么特别神奇的变化。这两个内部类是完全独立的两个实体，各自在自己的命名空间内。当然，可以明确地继承某个内部类。 class Inner2 extends Out1.Inner1{}...
局部内部类：
在代码块里面创建内部类，典型的方式是在一个方法体的里面创建。使用局部内部类而不是匿名内部类的一个理由是，我们需要一个已命名的构造器，或者需要重载构造器，而匿名内部类只能用于实例初始化。另一理由是，需要不止一个该内部类的对象。
上网找了一下为什么匿名内部类使用参数时一定要是fianl
为了防止---局部变量的生命周期与局部内部类的对象的生命周期的不一致性!
例子如下：
public abstract class B {
public abstract void f(String s);
}
public class A{
public B fun(final String asd) {
final int x=1;
return new B() {
public void f(String s) {
System.out.println(asd+x);
}
};
}
public static void main(String[] args) {
String x = "asd";
B b =new A().fun(x);
b.f(x);
}
}
输出 asd1;
试想，如果局部变量x不声明为final,那么，在方法结束后，x的生命周期结束，但是B对象的生命周期还未结束，此时，b调用f方法，需要用到生命周期已经技术的局部变量x，这是很不合理的事。所以唯有将它声明为final，延长其生命周期。然而，若单单只为延长生命周期，复制一份不就可以了？另外一个原因是要确保变量不变。使得复制出来的变量和原始变量一致，若不然，原始变量在方法里被修改了，这样在匿名类中的复制变量和原始变量就不一致了，这样代码看上去就有点难以理解了。（是这个原因吗？）
用jad反编译class文件后，可见其背后实现原理：
public B fun(String s)
{
AAAAA aaaaa = new AAAAA();
return new B() {
public void f(String s1)
{
System.out.println((new StringBuilder()).append(asd).append(1).append(a.hashCode()).toString());
}
final String val$asd;
final AAAAA val$a;
final Print this$0;
{
this$0 = Print.this;
asd = s;
a = aaaaa;
super();
} || 它将所有变量都复制一份，将它们变成final
}
一、创建内部类
内部类：可以将一个类的定义放在另一个类的定义内部
内部类和组合是完全不同的概念
如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须像在main（）方法中那样，具体的指明这个对象的类型：OuterClassName.InnerClassName.
二、链接到外部类
内部类自动拥有对其外围类的所有成员的访问权限：
当某个外围类的对象创建了一个内部类对象的时候，此内部类对象必定会咪咪的捕获一个指向那个外围类对象的引用。然后，当你访问此外围类的成员的时候，就是用那个引用来选择外围类的成员。幸运的时候，编译器会帮助你处理所有的细节，但是你现在可以看到：内部类的对象只能在与其外围类的对象相连的时候才能被创建（在内部类是非static类时候）。构件内部类对象的时候，需要一个指向外围类的引用，如果编译器访问不到这个引用就会出错。
三、使用.this和.new
想要直接创建内部类的对象，你不能按照你想象的方式，去引用外部类的名字DotNew，而是必须使用外部类的对象来创建该内部类对象。
在拥有外部类对象之前是不可能创建内部类对象的，这是因为内部类对象会暗暗的连接到创建它的外部类的对象上。但是，如果你创建是嵌套类（静态内部类），那么它就不需要对外部类对象的引用。
四、内部类与向上转型
当将内部类向上转型为其基类，尤其是转型为一个接口的时候，内部类就有了用武之地。（从实现了某个接口的对象，得到此接口的引用，与向上转型为这个对象的基类，实质上是一样的）。这是因为内部类---某个接口的实现---能够完全不可见，并且不可用。所得到的只是指向基类或者接口的引用，所以能够很方便的隐藏实现细节。
五、在方法和作用域内的内部类
TrackingSlip类被嵌入if 语句的作用域内，这并不是说该类的创建是有条件的，它其实与别的类一起编译过了。然而，在定义TrackingSlip的作用域之外，它是不可用的，除此之外，它与普通的类一样。
六、匿名内部类
这种奇怪的语法指的是：创建一个继承自Contents的匿名类的对象。
如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器就会要求其参数引用是final的，就像你在destination（）的参数中看到的那样。如果你忘记了，将会得到一个编译时错误信息：
匿名内部类与正规的继承相比有些限制，因为匿名内部类既可以扩展类，也可以实现接口，但是不能两者兼备。而且如果是实现接口，也只能实现一个接口。
内部类实现工厂模式
七、嵌套类
嵌套类：如果不需要内部类对象与其外围类对象之间有联系，那么可将内部类声明为static。
1）要创建嵌套类的对象，并不需要其外围类的对象
2）不能从嵌套类的对象中访问非静态的外围类对象
3）普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是嵌套类可以包含所有这些东西
1、接口内部的类
正常情况下，不能在接口内部放置任何代码，但是嵌套类可以作为接口的一部分。你放到接口中的任何类都自动的是public和static的。因为类是static的，只是将嵌套类置于接口的命名空间内，这并不违反接口的规则。你甚至可以在内部类中实现其外围接口：
使用嵌套类类测试代码
2、从多层嵌套类中访问外部类的成员
一个内部类被潜逃多少层并不重要-----它能够透明的访问所有它所嵌入的外围类的所有成员。
八、为什么需要内部类
每个内部类都能独立的继承自一个（接口的）实现，所以无论外围类是否已经继承类某个（接口的）实现，对于内部类都没有影响。
内部类有效的实现了“多重继承”
1）内部类可以有多个实例，每个实例都有自己得状态信息，并且与其外围类对象的信息相互独立
2）在单个外围类中，可以让多个内部类以不同的方式实现同一接口，或继承同一个类
3）创建内部类对象的时刻并不依赖于外围类对象的创建
4）内部类并没有令人迷惑的“is-a”关系，它就是一个独立的实体。
九、内部类的继承
因为内部类的构造器必须连接到指向其外围类对象的引用，所以在继承内部类的时候，事情会变得有点复杂。问题在于，那个指向外围类的对象的“秘密的”引用必须被初始化，二在导出类中不再存在可连接的默认对象。要解决这个问题，必须使用特殊的语法来明确的说清它们之间的关联：
10、内部类可以被覆盖吗
默认的构造器是编译器自动生成的，这里是调用基类的默认构造器。这个例子说明，当继承了某个外围类的时候，内部类并没有发生什么特别神奇的变化。这两个内部类是完全独立的两个实体，各自在自己得命名空间内：
当然，明确的继承某个内部类也是可以的：
11、局部内部类
使用局部内部类而不是使用匿名 内部类的理由就是：
1）我们需要一个已命名的构造器，或者需要重载构造器，而匿名内部类只能用于实例初始化
2）需要不止一个该内部类的对象
12、内部类标识符
如果内部类是匿名的，编译器会简单的产生一个数字作为其标识符。如果内部类是嵌套在别的内部类之中，只需要直接将他们的名字加上其外围类标识符与“$”的后面：
、什么是内部类？
就是在一个类的内部定义的一个类
2、为什么要使用内部类？
（1）内部类可以进行更好的封装，对于包中的其他类来说，内部类可以被隐藏起来。
（2）可以通过继承和接口实现多继承。
（3）使用匿名内部类可以更好的实现回调函数
（4）内部类可以非常方便的编写驱动程序
3、为什么外部类定义中可以通过内部类对象直接访问内部类的私有属性？
示例代码：
public class Outer {
class Inner{
private String inner="123";
}
public static void main(String[] args) {
System.out.println(new Outer().new Inner().inner);
//System.out.println(new Outer2().new Inner2().inner);//不允许
}
}
class Outer2{
class Inner2{
private String inner2="345";
}
}
网上回答：
内部类就相当于一个外部类的成员变量，所以可以直接访问外部变量，外部类不能直接访问内部类变量，必须通过创建内部类实例的方法访问。
将类置于其他类的内部，实现代码隐藏。
它了解外围类，并且能与之通信。它甚至可以随意访问其外围类的private字段。
用内部类，有时可以让代码变的优雅清晰。
我们知道，一个Java文件，可以包含一个public类和0到多个默认访问权限的类。 为什么要有那些默认访问权限的类呢？为了代码隐藏，这些类不对外提供服务。仅仅是为了服务public类。但是，这种分类是非常粗糙的。它隐藏的不好，它的访问控制权限很粗糙。而内部类，就很细腻了。直接塞入一个普通类里面，你想怎么加访问权限就怎么加。可以有一个很好的访问权限控制（就是隐藏）。这就是内部类的第一个优势。
光有第一个优势，其实还不足以让内部类出现。 一个语言特性，Java专家其实是会看它是否需要，才会去是否支持的。除非有一些特性，是受Java先天影响，添加不上去的。否则，Java专家会尽量的把有用的语言特性都添加上去。为了让用Java的人用的舒服。内部类有第二个优势，它可以与外围类通信，无阻碍的随意的访问外围类的字段。我们对内部类的理解发生了倒转。原来以为，它在内部，我们是通过外围类访问它。现在变成了内部类是访问外围类的通道了。
第三个优势，就需要我们多看一些框架源码，有质量的源码。体会体会这个优雅了。
内部类语法
内部类语法很简单。直接在某个普通类里面写一个类就行了。这个类应该是辅助外围类完成某项功能的。代码就可以隐藏了。
内部类对象的创建，必须提前有一个外围类对象。让这个内部类对象跟外围类对象发生关联。这样，内部类才能访问外围类的字段。第192页说：内部类可以访问其外围类的方法和字段，跟自己拥有它们一样。这一项特权真的是太厉害了。
外围类经过编译后，class文件中会有一个属性。里面记录着它自己的内部类名称。
内部类用法
内部类的用法应该是10.4节，向上转型。内部类一般都是实现了某个接口或者是继承了某个基类。外围类提供了一个方法，可以返回内部类的实例。客户类直接将内部类实例转化成其接口或者是基类。 就可以随便用。 而这个内部类实例可以操作外围类的字段。让外围类表现出某种功能。 太完美的配合了。
10.8节，内部类和接口一样，都可以让Java间接的实现多重继承。 每个内部类可以继承一个基类。外围类多添加几个内部类，就可以继承多个基类。 我们为什么需要继承？？？因为我们想向上转型，因为我们想让子类和基类有相同的访问接口。 内部类完全可以搞定这些，实现这些功能。而内部类最终操纵的字段正好是外围类的字段。配合的太默契了。
public abstract class Event{
private long eventTime;
protected final long delayTime;
public Event(long delayTime){
this.delayTime = delayTime;
start();
}
public void start(){
eventTime = System.currentTimeMillis() + delayTime;
}
public boolean ready(){
return System.currentTimeMillis() >= eventTime;
}
public abstract void action();
}
start()是个独立的方法，而没有包含在构造器内，因为这样就可以在时间运行以后重新启动计数器，也就是能够重复使用Event对象。例如，如果想重复一个事件，只需要简单地在action()中调用start()方法。
public class Controller {
private List<Object> eventList = new ArrayList<Object>();
public void addEvent(Eventevent){
eventList.add(event);
}
public void run(){
while(eventList.size() > 0){
for(int i = 0; i < eventList.size(); i++){
Event event = (Event)eventList.get(i);
if(event.ready()){
System.out.println(event);
event.action();
eventList.remove(i);
}
}
}
}
}
Controller包含了一个用来管理并触发事件的实际控制框架。
设计的关键在于：使变化的事物与不变的事物互相分离。“变化的事物”指的是不同的Event对象所具有的不同的行为，这可以通过不同的Event子类来变现。
这正是内部类所要做的事情，内部类允许：
1).用单一的类完整地实现控制框架，从而将实现的细节封装起来。内部类用来表示解决问题所不许的各种不同的action()。
2).内部类能够很容易地访问外围类的任意成员，具有很大的灵活性。
public class GreenhouseControls extends Controller{
private boolean light = false;//默认灯是关着的。
private boolean water = false;//默认水源是关着的。
private String thermostat = "Day";//默认在白天
//开灯事件
public class LightOn extends Event{
public LightOn(long delayTime) {
super(delayTime);
}
public void action() {
light = true;
}
public String toString(){
return "Light is on";
}
}
//关灯事件
public class LightOff extends Event{
public LightOff(long delayTime) {
super(delayTime);
}
public void action() {
light = false;
}
public String toString(){
return "Light is off";
}
}
//开水事件
public class WaterOn extends Event{
public WaterOn(long delayTime) {
super(delayTime);
}
public void action() {
water = true;
}
public String toString(){
return "Water is on";
}
}
//关水事件
public class WaterOff extends Event{
public WaterOff(long delayTime) {
super(delayTime);
}
public void action() {
water = false;
}
public String toString(){
return "Water is off";
}
}
//温度调节于晚上的事件
public class ThermostatNight extends Event{
public ThermostatNight(long delayTime) {
super(delayTime);
}
public void action() {
thermostat = "Night";
}
public String toString(){
return "Therostat on night setting";
}
}
//温度调节于白天的事件
public class ThermostatDay extends Event{
public ThermostatDay(long delayTime) {
super(delayTime);
}
public void action() {
thermostat = "Day";
}
public String toString(){
return "Therostat on day setting";
}
}
//响铃事件
public class Bell extends Event{
public Bell(long delayTime) {
super(delayTime);
}
//响完铃之后又把一个new Bell(delayTime)加入都eventList
public void action() {
addEvent(new Bell(delayTime));
}
public String toString(){
return "Bing!";
}
}
//重启事件
public class Restart extends Event{
private Event[] eventList;
public Restart(long delayTime, Event[] eventList) {
super(delayTime);
this.eventList = eventList;
for(int i = 0; i < eventList.length; i++){
addEvent(eventList[i]);
}
}
public void action() {
for(int i = 0; i < eventList.length; i++){
eventList[i].start();//重新启动每个事件。
addEvent(eventList[i]);
}
start();//启动当前Restart事件
addEvent(this);//把当前的Restart事件加入到eventList中，循环启动。
}
public String toString(){
return "Restarting system!";
}
}
//终止事件
public class Terminate extends Event{
public Terminate(long delayTime) {
super(delayTime);
}
public void action() {
System.exit(0);
}
public String toString(){
return "Terminating!";
}
}
}
创建GreenhouseControls对象（“命令”设计模式的一个例子）：
public class GreenhouseController {
public static void main(String[] args) {
GreenhouseControls gc = new GreenhouseControls();
gc.addEvent(gc.new Bell(900));
Event[] eventList = {
gc.new ThermostatNight(0),
gc.new LightOn(200),
gc.new LightOff(400),
gc.new WaterOn(600),
gc.new WaterOff(800),
gc.new ThermostatDay(1400)
};
gc.addEvent(gc.new Restart(2000, eventList));
if(args.length == 0){
gc.addEvent(gc.new Terminate(5000));
}
gc.run();
}
}
内部类：将一个类的定义放在另一个类的内部
* 内部类将逻辑相关的类组织在一起，控制类的可视性，内部类了解外围类并与之通信，代码更加优雅。
*内部类可以访问其外围类的方法和字段(内部类拥有其外围类的所有成员的访问权)。这是如何做到的呢？一个外围类对象创建某个内部类对象时，内部类对象会获取这个外围类的对象的引用。
public class DotThis {
public void f() {
System.out.println("DotThis.f()");
}
class Inner {
public DotThis Outer() {
return DotThis.this;
}
}
public Inner inner(){
return new Inner();
}
public static void main(String[] args) {
DotThis dt = new DotThis();
//调用外围类中的定义的方法来创建内部类
DotThis.Inner inner = dt.inner();
inner.Outer().f();
//直接创建内部类
DotThis.Inner inner2 =new DotThis().newInner();
inner2.Outer().f();
}
}
* 接口的所有成员被自动设置为public
* 可以在一个方法或者作用域中定义内部类，这样做有两个理由：
1.实现了某类型的接口，可以创建并返回对其的引用。
2.想创建一个类来辅助解决一个复杂问题，但是又不希望这个类是公用的。
* 局部内部类：在方法的作用域内创建一个完整的类。
* 匿名内部类要想使用外部定义的对象，那么这个参数引用必须是final的。
* 匿名内部类的限制：匿名内部类可以扩展类，也可以实现接口，但不能两者兼备。如果实现接口也只能实现一个接口。
* 如果不需要外围类和内部类之间有联系，可以将外围类声明为static。这通常称为嵌套类。
* 普通的内部类对象隐式地保存了外围类对象的引用，而嵌套类不是这样。
* 嵌套类意味着：1)要创建嵌套类的对象，不需要外围类的对象。2)不能从嵌套类的对象中访问非静态的外围类对象。
普通的内部类和嵌套类之间还有一个区别是：普通的内部类不能有static字段方法，也不能包含嵌套类，但是嵌套类可以包含所有这些东西。
* 嵌套类可以放在接口中，并且默认是public和static的
* 如果想要创建某些公共代码，使得这些代码可以被某个接口的所有不同实现所共用，那么在接口中使用嵌套类会比较方便。
* 从多层嵌套类中也能访问外围类的成员。
* 为什么需要内部类？
答：一般来说，内部类继承自某个类或者实现某个接口，内部类的代码操作创建它的外围类的对象。可以认为内部类提供了某种进入外围类的窗口。
* 如果只是需要一个接口的引用，为什么不通过外围类来实现这个接口呢？
答：如果这能满足需求，就应该这么做。外围类实现一个接口不是总能享受接口带来的便利。有时需要用到接口的实现。
* 那么内部类实现一个接口与外围类实现一个 接口有什么区别呢？
答：外围类实现一个接口不是总能享受接口带来的便利。有时需要用到接口的实现。
* 使用内部类最吸引人的原因是：
答：每个内部类都能独立地继承一个（接口的）实现。所以无论外围类是否继承了某个（接口的）实现，对于内部类没有影响。内部类有效地实现了“多重继承”。
class D {}
abstract class E {}
class Z extends D {
//匿名内部类
public EmakeE(){return new E(){};}
}
public class MutiImpl {
staticvoid takeE(E e){};
static voidtakeD(D d){}
publicstatic void main(String[] args) {
Z z = new Z();
takeD(z);
takeE(z.makeE());
}
}
* 使用内部类除了解决“多重继承”的问题，还可以获得其他一些特性：
1) 内部类可以有多个实例，并且每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。
2) 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口或继承同一个类
3) 创建内部类对象的时刻并不依赖于外围类对象的创建。
4) 内部类并没有is-a关系，它是一个独立地实体。
* 闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。内部类是面向对象的闭包。
* 内部类的继承
class WithInner {
class Inner {};
}
public class InheritInner extends WithInner.Inner {
InheritInner(WithInner wi) {//参数是外围类的引用
wi.super();//这个是必须的，否则编译期报错
}
public static void main(String[] args) {
InheritInnerinner = new InheritInner(new WithInner());
}
}
* 内部类的继承
class Egg2 {
protected class Yolk {
publicYolk() {
System.out.println("Egg2.Yolk()");
}
public voidf() {
System.out.println("Egg2.Yolk.f()");
}
}
private Yolk y = new Yolk();
public Egg2() {
System.out.println("New Egg2()");
}
public void insertYolk(Yolk yy) {
y =yy;
}
public void g() {
y.f();
}
}
public class BigEgg2 extends Egg2 {
public class Yolk extends Egg2.Yolk {//继承父类的内部类
publicYolk() { //覆盖父类构造器
System.out.println("BigEgg2.Yolk()");
}
public voidf() { //覆盖父类方法
System.out.println("BigEgg2.Yolk.f()");
}
}
public BigEgg2() {
insertYolk(new Yolk()); //将覆盖后的Yolk对象的引用赋值给属性y
}
public static void main(String[] args) {
Egg2 e2 =new BigEgg2();
e2.g();
}
}
* 局部内部类和匿名内部类：
局部内部类和匿名内部类可能有相同的行为和能力。但为什么仍要使用局部内部类而不是匿名内部类呢？
理由是：我们需要一个已命名的构造器，或者重载这个构造器。而匿名内部类只能用于实例初始化。
另一个理由是：可能需要不止一个该内部类的对象。
interface Counter {
int next();
}
public class LocalInnerClass {
private int count = 0;
Counter getCounter(final String name) {
//局部内部类:
classLocalCounter implements Counter {
public LocalCounter() {
//局部内部类可以有构造器
System.out.println("LocalCounter()");
}
public int next() {
System.out.print(name); //访问局部final对象
return count++;
}
}
return newLocalCounter();
}
//一个匿名内部类，产生的行为和上面的局部内部类相同
Counter getCounter2(final String name) {
return newCounter() {
//匿名内部类不具有已命名的构造器，只有一个初始化块
{
System.out.println("Counter()");
}
public int next() {
System.out.print(name); //访问局部final对象
return count++;
}
};
}
public static void main(String[] args) {
LocalInnerClass lic = new LocalInnerClass();
Counter
c1 =lic.getCounter("Local inner "),
c2 =lic.getCounter2("Anonymous inner ");
for(int i =0; i < 2; i++)
System.out.println(c1.next());
for(int i =0; i < 2; i++)
System.out.println(c2.next());
}
}
* 内部类标识符
内部类也必须生产一个.class文件以包含它们的Class对象信息。这些类的命名有严格的规则：
外围类的名字 + "$" + 内部类的名字 。
如果内部类是匿名的。以数字作为其标识符。
上面的LocalInnerClass.java生成的.class文件包括：
Counter.class
LocalInnerClass$1.class
LocalInnerClass$1LocalCounter.class
LocalInnerClass.class
java编程思想 --10内部类
猜你喜欢
转载自zhyp29.iteye.com/blog/2306702
今日推荐
周排行