Java笔记十八.内部类和匿名类

内部类和匿名类

转载请表明出处：http://blog.csdn.net/u012637501(嵌入式_小J的天空)

一、内部类

1.定义

    在一个类内部定义类，即为嵌套类(内部类)。有如下几点特点：(1)嵌套类可以直接访问嵌套它的类的成员(变量和方法)，包括private成员。但是，嵌套类的成员却不能被嵌套它的类直接访问。(2)内部类使得程序代码更为紧凑，程序更具模块化。

2.内部类实现方法

(1)类中定义和使用一个内部类

    在类中直接定义的嵌套类的使用范围，仅限于这个类的内部。内部类的定义和普通类的定义没有什么区别，内部类可以直接访问和引用它的外部类的所有变量和方法，就像外部类中的其他非static成员的功能一样，和外部类不同的是，内部类可以声明为private或protected。

a.内部类被外部类引用

源码：innerClassDemo.java

//外部类class Outer{  String name="我是外部类成员变量";  void outerMethod()//在外部类定义一个成员方法，实现创建一个内部类实例并调用其成员方法  {   inner in=new inner();   in.dispaly();  }  //内部类  class inner  {   void display()   {    System.out.println("Method of inner class print 'name'="+name);   }  }}/*-------------------------------------------*/public class innerClassDemo { public static void main(String[] args) {  Outer outer = new Outer();  outer.outerMethod(); }}

打印信息：

分析：该源码实现了在外部类Outer中实现一个内部类inner,且在该内部类中定义一个成员方法来使用外部类的Outer的成员name。另外，只能在外部类Outer实例化内部类inner对象，在外部类之外实例化该内部类是不允许的，除非将inner声明为public(后面介绍)。

    从内存分布的角度分析，实际上在内部类对象保存了一个对外部类对象的引用(Outer.this),当内部类的成员方法中访问某一变量(方法)时，如果在该方法和内部类中都没有定义过这个变量，调用就会被传递给内部类中保存的哪个外部类对象的引用。通过哪个外部类对象的引用调用这个变量(方法)。

注释：只有放this.变量不存在的情况下，传递给Outer.this.变量。

b.内部类被外部类以外的类引用

    内部类可以通过创建对象从外部类之外被调用.

(1)将内部类声明为public;

(2)在外部类以外的类，先创建一个外部类的实例再通过该实例创建内部类的实例

形式：

Outer outer = new Outer(); 

Outer.Inner inner=outer.new Inner(); 

源码：InnerClassDemo

//外部类class Outer{ private int number=100; public class Inner {  private int number=200;  void print(int number)  {   System.out.println("I am innerClass"+"\n"+"参数number="+number+"\n"+"内部类成员         number="+this.number+"\n"+"外部类成员number="+Outer.this.number);  } }}//外部以外的类public class InnerClassDemo { public static void main(String[] string) {  Outer outer = new Outer(); //实例化一个Outer对象  Outer.Inner inner=outer.new Inner();//实例化一个Inner对象  inner.print(300);//调用外部类的成员方法 }}

打印信息：

分析：观察上面的程序，你会发现三个number变量，其区别为：

number：引用的是print函数的形参;

this.number:引用的是Inner类中的成员变量;

Outer.this.number：引用的外部类Outer中的成员变量。

2.方法中定义的内部类

    嵌套类并非智能在类里定义，也可以在几个程序块的范围之内定义内部类。

源码：InnerDemo.java

//外部类class Outer{ private String str="姚明"; public void outerPrint() {    int i=10;    //内部类   class Inner   {    void dispaly(final int number)    {          System.out.println(str);     System.out.println(number);    //System.out.println(i);//这条语句是错误的，方法中的内部类不能访问方法的非final变量    }   }   //实例化内部类并调用其成员方法   Inner inner = new Inner();   inner.dispaly(11); }}public class InnerDemo{ public static void main(String[] args) {  Outer outer = new Outer();  outer.outerPrint(); }}

打印信息：

分析：在方法汇总定义的内部类智能访问方法中的final类型的局部变量(不能访问i)，因为用final定义的局部变量就相当于一个常量，它的声明周期查处方法运行的生命周期。

二、匿名内部类

1.匿名类

    在学习匿名内部类之前，我们先看下这样一个实例，即实现一个内部类，该内部类继承于另外一个类，表述为在类Outer中定义一个内部类Inner，Inner类又继承了类A。

源码：Outer.java

//类Aabstract class A{ abstract void display();}//Outer类,在其main方法中定义一个内部类,该内部类继承于类Apublic class Outer { //main成员方法 public static void main(String[] args) {   //内部类   class Inner extends A   {    void display() {     System.out.println("I am Inner Class.");    }   }   new Outer().callInner(new Inner());//创建Outer实例并调用其成员方法，方法参数为内部类对象 } //callInner成员方法 public void callInner(A a) {  a.display(); }}

打印信息：

分析：由new Outer().callInner(new Inner());可知在Outer.main方法中调用了Outer.callInner方法，传递给callInner方法的参数要求是一个实现了类A中的方法的子类对象。所以，我们在Outer.main方法中定义了一个继承于A类的内部类Inner，该Inner类仅在这里被使用了一次。

    对于上面的程序感觉太复杂了，那么我们有什么办法简写它呢？当然。其实，我们在调用callInner方法时，不用实现定义类的Inner，可以在给callInner方法传递参数时，临时创建一个类A的匿名子类的实例对象，代码如下：

源码：Outer.java

//类Aabstract class A{ abstract void display();//声明一个抽象类}//外部类public class Outer { //main成员方法 public static void main(String[] args) {  new Outer().callInner(new A(){   void display() {    System.out.println("I am childclass of A,but I have not name -'Inner'");   }  }); } //callInner成员方法 public void callInner(A a) {  a.display(); }}

打印信息：

分析：  由程序打印的结果，我们可以看出Outer.main方法中调用了Outer.callInner方法，传递给callInner方法的参数要求是一个实现了类A中的方法的子类对象。在上面的程序中就相当于定义了一个类A的子类，但是这个子类是没有类名的，并且接着又创建了这个子类的一个实例对象，这样的类即为匿名类。

2.匿名类的形式

    假如我们实现实现了一个类A，那么它的匿名子类的一个实例对象可以这样表示。

形式：new A() { }

作用：产生一个类A的一个匿名子类的实例对象，匿名子类的所有实现代码(包括成员方法和成员变量)都要在那对大括弧间增加即可。