new 接口{内部实现方法} 转为 匿名内部类

一、内部类

1、内部类初识

一般，一个类里主要包含类的方法和属性，但在Java中还提出在类中继续定义类（内部类）的概念。

内部类的定义：类的内部定义类

先来看一个实例

[html] view plain copy

 

1. public class Out {  
2.     private int a=1;  
3.     //定义内部类  
4.     class Inner  
5.     {  
6.         private int a=12;  
7.         public void show()  
8.         {  
9.             System.out.println(a);  
10.         }  
11.     }  
12.       
13.     public static void main(String[] args) {  
14.         Out.Inner in=new Out().new Inner();//实例化内部类  
15.         in.show();  
16.           
17.     }  

     如Out类中定义一个a变量，再定义一个Inner内部类，该类可直接调用输出a；同时为Out设定的show方法内部类也可直接调用。内部类的提出，唯一的好处就在于可直接使用外部类（Out类）的所有属性，不再需要通过get、set操作数据。但这种方便是以牺牲类的基本结构为代价的。这里需要注意的是对内部类的实例化语法。

2、 内部类对外部类的操作：内部类中的变量访问形式

[html] view plain copy

 

1. public class Out {  
2.     private int a=1;  
3.     //定义内部类  
4.     class Inner  
5.     {  
6.         private int a=12;  
7.         public void show()  
8.         {  
9.             int a=122;  
10.             System.out.println("局部变量："+a);  
11.             System.out.println("内部类变量："+this.a);  
12.             System.out.println("外部类变量："+Out.this.a);  
13.         }  
14.     }  
15.       
16.     public static void main(String[] args) {  
17.         Out.Inner in=new Out().new Inner();//实例化内部类  
18.         in.show();        
19.     }  

依次输出122，12，1 ，这个实例主要是提醒大家在对具有内部类的类成员变量、内部类变量调用的时候需要注意加上对应的关键字。

 二、内部类的常用类型

1、常规内部类

常规内部类没有用static修饰且定义在在外部类类体中。
  1.常规内部类中的方法可以直接使用外部类的实例变量和实例方法。
  2.在常规内部类中可以直接用内部类创建对象。

2、静态内部类

用static修饰内部类

1.如果使用static修饰内部类，该内部类只能访问外部类的静态成员变量。

3、局部内部类

 内部类前加上private修饰，使得该内部类只有当前外部类方法才可调用。其他类无实例化权限。

4、匿名内部类

这里着重介绍匿名内部类的使用。匿名内部类：没有名字的内部类，它的特点是只能使用一次，通常用于简化代码编写。使用匿名内部类必须继承一个父类或实现一个接口。

   声明和构造匿名内部类的一般格式如下：
   new ClassOrInterfaceName(){ //抽象类或接口

    /*类体*/ }

1）匿名内部类在抽象类上的应用

  不使用匿名内部类实现抽象类方法实例

[html] view plain copy

 

1. public abstract class InnerClass2 {  
2.     public abstract void show();  
3.       
4.     public static void main(String[] args) {  
5.         InnerClass2 in=new Child(); //多态，实例化子类，调用子类show方法  
6.         in.show();  
7.     }  
8. }  
9.   
10. public class Child extends InnerClass2{  
11.         public void show()  
12.         {  
13.             System.out.println("jdfklj");  
14.         }  
15. }  

   使用匿名类实现思路

[html] view plain copy

 

1. public abstract class Out2 {  
2.     public abstract void show();  
3.       
4.     public static void main(String[] args) {  
5.         Out2 out=new Out2()  
6.         { //匿名类-直接实例化了out2和show 方法，在调用out.show()  
7.             public void show()  
8.             {  
9.                 System.out.println("jdljsalkf");  
10.             }  
11.         };  
12.         out.show();  
13.     }     
14. }  

    在注释出就是使用了一个匿名类，对抽象类Out2的show实例，最后out.show()调用即可。
2）匿名内部类在接口上的应用

[html] view plain copy

 

1. public interface Out3 {//接口  
2.     void show();  
3.       
4.     public static void main(String[] args) {  
5.         Out3 out=new Out3()//new Out3  
6.         {  
7.             public void show()  
8.             {  
9.                 System.out.println("lkjdfaj");  
10.             }  
11.         };  
12.     }  
13. }  

   这里new Out3是本片博客出生的源头，直接new 抽象类、new 接口？？how could it be？ one Answer:cause it is a Anonymous Inner Class.只要是一个抽象类或接口，那就可以使用匿名内部类来实现。最常用的是在多线程中继承Thread类或实现Runnable接口。

[html] view plain copy

 

1. public static void main(String[] args) {  
2.         Thread thread =new Thread()  
3.         {  
4.             public void run()  
5.             {  
6.                 System.out.println("kdjfka");  
7.             }  
8.         };  
9.         thread.start();  
10.           
11.         //接口  
12.         Thread thread2=new Thread(new Runnable(){  
13.             public void run()  
14.             {  
15.                 System.out.println("22222222");  
16.             }  
17.               
18.         });   
19.         thread2.start();  
20.     }