Java 基础 --- 匿名内部类

1 匿名内部类定义方式

new A() { // A 表示对象名
… // 内部类体
} ;

分号代表 创建匿名内部类的 引用表达式的 标识

使用前提：

• 必须继承一个父类 或者 实现一个接口，然后重写 父类或者接口里面的方法

匿名内部类，是直接使用 new，来生成一个对象的引用，当然这个引用是隐式的
由于匿名内部类没有名称，所以匿名内部类 使用默认构造方法，来生成匿名内部类的对象

在匿名内部类定义结束后，需要 加分号;标识， 这个分号不代表定义内部类结束的标识，而是代表 创建匿名内部类的引用表达式 的标识

说明：匿名内部类编译后，会产生以 外部类名$序号 为名称的 .class文件，序号以 1~n 排列，分别代表 1~n个 匿名内部类

2 注意事项

在使用 匿名内部类的过程中，必须注意以下几点：

• 1 必须 继承一个类 或者 实现一个接口，但是，两者只能二选一
• 2 匿名内部类中 不能定义构造函数
• 3 匿名内部类中 不能存在 任何 静态成员变量和静态方法
• 4 匿名内部类为局部内部类，所以局部内部类的限制都适用于匿名内部类
• 5 匿名内部类不能是抽象的，它必须要实现继承的类或实现接口的所有抽象方法

3 使用的形参 必须为 final

public class OutClass{
    public InnerClass getInnerClass(final int age,final String name){ // 使用的形参 必须为 final 
     // ... ... 
    }
}

为什么：

拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变
故如果定义了一个匿名内部类，并且希望它使用一个其外部定义的参数，那么编译器会要求该参数引用是final的

具体说明：
首先，在内部类编译成功后，它会产生一个 class文件，该 class文件与外部类，并不是同一个 class文件，仅仅只保留对外部类的引用。当外部类传入的参数，需要被内部类调用的时候，从 Java程序的角度看，是直接被调用：

public class OuterClass{
    public void display(final String name,String age){
          class InnerClass{
              void display(){
                 System.out.println(name);
              }
          }
    }
}

从上面的代码看，好像 name参数应该是被内部类直接调用，其实不然。在java编译之后实际的操作如下：

public class OuterClass$InnerClass{
   public InnerClass(String name,String age){
       this.InnerClass$name = name;
       this.InnerClass$age = age;
   }

   public void display(){
      System.out.println(this.InnerClass$name+"----"+this.InnerClass$age);
   }
}

所以，从上面的代码来看，内部类 并不是直接调用方法传递参数，而是 利用自身的构造器，对传入的参数进行备份，自己内部的方法调用的实际上是自己的属性，而不是外部方法传递进来的参数
在内部类中的属性 和 外部方法的参数 两者从外表上看是同一个东西，但实际上却不是，所以他们两者是可以任意变化的，也就是说在内部类中我对属性的改变并不会影响到外部的形参，然而这从程序员的角度来看这是不可行的，毕竟站在程序的角度来看这两个根本就是同一个，如果内部类该变了，而外部方法的形参却没有改变这是难以理解和不可接受的，所以为了保持参数的一致性，就规定使用 final来避免形参的不改变

4 实际应用

4.1 抽象方法应用

// 不使用匿名内部类来实现抽象方法
abstract class Person{
    public abstract void eat();
}

class Child extends Person{
    public void eat(){
       System.out.println("eat something");
    }
}

public class Demo{
     main(){
      Person p = new Child();
      p.eat();
     }
}
运行结果：eat something

可以看到，我们用 Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用。但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

// 匿名内部类的实现
abstract class Person{
   public abstract void eat();
}

public class Demo{

       Person p = new Person(){
         public void eat(){
           System.out.println("eat something");

         }
       };
       
       p.eat();
    }
}
运行结果：eat something

4.2 使用在接口上

在 main()方法中，编写 匿名内部类 去除字符串中的 全部空格

编写 接口 IStringDeal，在该接口中声明一个方法 filterBlankChar()

public interface IStringDeal{
    public String filterBlankChar(); // 声明过滤字符串中空格的方法
}

匿名内部类，实现接口或者继承一个父类，需要 重写里面的方法 ，所以无论里面有几个方法，都无所谓，把该重写的方法，都重写了，就可以

public class Anonymous{
   main(){
     final String sourceStr = "上海市  浦东新区  外滩 --- 金融大厦";
     
     IStringDeal s = new IStringDeal(){ // 编写 匿名内部类
     public String filterBlankChar(){
       String convertStr = sourceStr;
       convertStr = convertStr.replaceAll(" ","");
       return convertStr;
     }
     };
     
      System.out.println("源字符串："+ sourceStr);
      System.out.println("转换后的字符串："+s.filterBlankChar());
   }
}
运行结果：
上海市  浦东新区  外滩 --- 金融大厦
上海市浦东新区外滩---金融大厦

4.3 在多线程中的应用

匿名内部类最常用的情况就是，在多线程的实现上，因为要实现多线程，必须继承 Thread类或是 实现 Runnable接口
Runnable是接口，Thread是类，实现方式不一样。
Runnable：Runnable r = new Runnable(){};
Thread t = new Thread(r);
t.start();
Thread： Thread t = new Thread() {};
t.start();

具体实现：

// Thread类的匿名实现
class Demo{
   main(){

     Thread t = new Thread(){
         public void run(){
           for(int i=1;i<=5;i++){
              System.out.println(i+"");
           }
         }
     };

     t.start();

   }
}
运行结果： 1 2 3 4 5 

// Runnable接口的 匿名内部类实现
class Demo{
    main(){
 
        Runnable r = new Runnable(){
            public void run() {
               for(int i =1; i<=5;i++){
                 System.out.println(i+" ");
               }
            }
        };
        
        Thread t = new Thread(r);
        t.start();
    }
}
运行结果： 1 2 3 4 5