匿名内部类

匿名内部类为没有名字的内部类

匿名内部类一般只能使用一次，通常用来简化代码

使用匿名内部类的前提条件是：必须继承一个父类或者实现一个借口

例1： 不使用匿名内部类来实现抽象方法。

抽象基类

/**
 *
 */
package com.test.innerClass;

/**
 * @author li
 *
 */
abstract class Person {

 protected abstract void eat();
 
}

子类

/**
 *
 */
package com.test.innerClass;

/**
 * @author li
 *
 */
public class Child extends Person {

 /**
  *
  */
 public Child() {
 }

 /* (non-Javadoc)
  * @see com.test.innerClass.Person#eat()
  */
 @Override
 protected void eat() {
  
  System.out.println("eat");

 }
}

测试类

/**
 *
 */
package com.test.innerClass;

/**
 * @author li
 *
 */
public class Demo {

 /**
  * @param args
  */
 /**
  * @param args
  */
 public static void main(String[] args) {

   1）

  //不使用匿名内部类。
  //需要多声明一个子类对象
  Person person = new Child();
  person.eat();
  
  2）
  //我们直接将抽象类Person中的方法在大括号中实现
  //使用内部类的方式可以省略一个类（Child）的书写
  Person person2 = new Person() {
   @Override
   protected void eat() {
    System.out.println("继承父类实现匿名内部类");
   }
  };
  
  person2.eat();
  

  3）
  //我们直接将接口PersonIF中的方法在大括号中实现
  //使用内部类的方式可以省略一个类（Child）的书写
  PersonIF person3 = new PersonIF() {
   
   @Override
   public void eat() {
    
    System.out.println("实现接口实现匿名内部类");
    
   }
  };
  
  person3.eat();
 }
}

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上，

实例4：Thread类的匿名内部类实现

public class Demo {      public static void main(String[] args) {          Thread t = new Thread() {              public void run() {                  for ( int i = 1 ; i <= 5 ; i++) {                      System.out.print(i + " " );                  }              }          };          t.start();      } }

运行结果：1 2 3 4 5

 

实例5：Runnable接口的匿名内部类实现

public class Demo {      public static void main(String[] args) {          Runnable r = new Runnable() {              public void run() {                  for ( int i = 1 ; i <= 5 ; i++) {                      System.out.print(i + " " );                  }              }          };          Thread t = new Thread(r);          t.start();      } }

运行结果：1 2 3 4 5因为要实现多线程必须继承Thread类或是继承Runnable接口