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

//类A
abstract class A
{
 abstract void display();
}
//Outer类,在其main方法中定义一个内部类,该内部类继承于类A
public 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

//类A
abstract 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的一个匿名子类的实例对象，匿名子类的所有实现代码(包括成员方法和成员变量)都要在那对大括弧间增加即可。