求解答 匿名内部类的运用场景和它重写的方法  怎样去调用

匿名内部类，
这是一个内部类，
首先：该类的内容量不会太大，通常就过程来讲不要太复杂，
其次：该类需要和其所在的类有着至关重要的联系。
相比较而言，内部类因为没有名字，所以该类只能执行一次
如果确定该类实现的对象只执行某个行为的操作，
例如某个点击监听动作，去实现他的行为，
并且只针对该监听，其他监听不用执行该动作，
这种时候使用匿名内部类

个人总结，感觉一般匿名内部类都是去
通常new 一个接口类或者是一个抽象类
当然也有去直接new 一个实体类  例如多线程的操作
然后再去重写他的方法，来实现匿名内部类
仅仅是个人的感觉

1. import android.app.Activity;
   
2. import android.os.Bundle;
   
3. import android.view.View;
   
4. import android.view.View.OnClickListener;
   
5. 
   
6. public class MainActivity2 extends Activity {
   
7. 
   
8.     @Override
   
9.     protected void onCreate(Bundle savedInstanceState) {
   
10.         super.onCreate(savedInstanceState);
    
11.         setContentView(R.layout.activity_main2);
    
12.         
    
13.         
    
14.       
    
15.         View view = findViewById(R.id.v);
    
16.         /**在此处获取了点击监听的匿名内部类
    
17.          * 若点击对象只想执行该命令，
    
18.          * 而且该命令只能在此处执行，
    
19.          * 那使用匿名内部类可以省略一些不必要的代码
    
20.          */
    
21.         view.setOnClickListener(new OnClickListener() {
    
22.                        
    
23.                         @Override
    
24.                         public void onClick(View v) {
    
25.                                
    
26.                         }
    
27.                 });
    
28.         /**通常状态下是先去创建一个类，去实现OnClickListener接口
    
29.          * 然后再去实例化一个对象来进行操作
    
30.          */
    
31.         view.setOnClickListener(new MyOnClickListener());
    
32.         
    
33.     }
    
34.     /**
    
35.      * 此处为创建了一个实现点击监听接口的类
    
36.      * 该类不是匿名内部类
    
37.      * 因为此类有名字(MyOnClickListener)，因此在MainActivity2中
    
38.      * 任何地方都可以实例化该类
    
39.      */
    
40.     private class MyOnClickListener implements OnClickListener{
    
41. 
    
42.                 @Override
    
43.                 public void onClick(View v) {
    
44.                        
    
45.                 }
    
46.            
    
47.     }
    
48. ////////////////////万恶的分割线////////////////////////////////////////////////   
    
49.     @Override
    
50.     protected void onStart() {
    
51.             /**
    
52.              * 此处为通过匿名内部类获取一个线程对象
    
53.              */
    
54.              new Thread(){public void run() {
    
55.                 
    
56.          };}.start();
    
57.          
    
58.          /**
    
59.           * 获取自己创建的内部类对象的实例
    
60.           */
    
61.          MyThread mt = new MyThread();
    
62.          mt.start();
    
63.          /**
    
64.           * 自己创建的对象可以重复调用
    
65.           */
    
66.          MyThread mt2 = new MyThread();
    
67.          mt2.start();
    
68.             super.onStart();
    
69.     }
    
70.     /**
    
71.      * 此处为创建一个类然后去继承Thread类
    
72.      *实际上是为了重写里面的run方法
    
73.      */
    
74.     private class MyThread extends Thread{
    
75.             @Override
    
76.             public void run() {
    
77.                    
    
78.                    
    
79.                     super.run();
    
80.             }
    
81.     }
    
82. }
    

复制代码

看看示例代码，希望能帮你区分，内部类和匿名内部类。