android 构造匿名内部类

最新推荐文章于 2023-01-11 19:58:05 发布
最新推荐文章于 2023-01-11 19:58:05 发布
阅读量653 收藏 1
点赞数
分类专栏： Android

下面将分别按照 "什么是匿名内部类"， "匿名内部类如何引起内存泄漏", "替代方案 -- 静态内部类", "替代方案 -- 动态代理" 四个部分来讲述，请耐心按顺序的读完.

什么是匿名内部类

匿名内部类，简单的说，就是没有明确指定名字的类。以下面的代码举例:

public class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";

     public void onCreate() {
          ThreadPoolUtil.execRunnable( new Runnable() { // 去线程池中被执行
                   public  void run() {
                        Thread.sleep( 1000 * 60 ); //休眠 1 分钟
                        String info = "name:" + name + "; age:" + age;
                        Log.i("TestInfo", info);
                        ....
                   }
         } );
    }
}

这里的 new Runnable(){...} 就是一个匿名内部类。 它的优点就是让你写起来方便，这个方便体现在两点：
1. 你不必再去声明一个类
2. 可以访问外部类的成员变量，即使是 private 的，也可以访问

然而，之所以你写起来方便，是因为本应该你去做的事情，编译器 ( javac ) 帮你去做了，编译器在把 java 代码代码编译成 class 文件的时候帮你做的。具体做的事情如下：
1. 它会生成一个类，名字大概是 MyActivity$1，或 MyActivity$2 之类的，这个生成的类会实现 Runnable 接口, 会包含 new Runnable(){..} 的 {...} 里面部分的代码，。 
2. 它会有一个成员变量，类型是 MyActivity 类型，当这个类的实例被构造时，会会作为构造方法的参数传递进来，指向外部类的实例，外部类实例暂且记作 mOuter 吧。 它可以通过 mOuter 去访问 MyActivity 的 ( 非 private ) 成员变量、调用它的 (非 private ) 方法，比如 name 。
3. 而对于 MyActivity 的字段 age， 由于是 private 的，编译器会在 MyActivity 的字节码中插入名字大概叫 $access0 之类的方法，可以理解成 getAge() 方法 , 让内部类去调用，从而获取到 age 的值

匿名内部类如何引起内存泄漏

从上面的分析中可知，编译器在内部类中，插入了成员变量，指向着外围的实例。所以，只要内部类不被销毁，外围类就不可能被回收。

替代方案 -- 静态内部类

对于内存泄漏的解决方案，比较流行的就是 静态内部类 + 弱引用的方式了。 写法通常是这样的:

public  class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";

     public void onCreate() {
          ThreadPoolUtil.execRunnable(new  MyRunnable(this));
    }

   static class  MyRunnable implements Runnable {

         private  WeakReference<MyActivity>  mWrActivity;

         public  MyRunnable( MyActivity  activity ) {
               mWrActivity  =  new WeakReference<MyActivity>( activity );
         }

          public  void run() {
                       MyActivity  activity =  mWrActivity.get();
                       if (activity == null) {
                               return;
                        }
                        Thread.sleep( 1000 * 60 ); //休眠 1 分钟
                        String info = "name:" + activity.name + "; age:" + activity.age;
                        Log.i("TestInfo", info);
                        ....
          }
   }

}

静态内部类是不持有对外围类的引用的，且使用了 WeakReference ，确实是不会再引起内存泄漏了。
但这种方式的缺点就是，有一小部分工作，编译器不能帮你做了，你需要自己来做，主要是：
1. 你需要自己来声明类
2. 你要添加一个构造方法，一个 WeakReference 的成员变量，以及对 weakReference.get() 的判空

总体而言，虽然有一点工作量，但也是个不错的解决方案.

替代方案 -- 动态代理

上面的替代方案，当接口比较多、匿名内部类比较多、接口里方法比较多时，写起来总会烦躁的，那么有没有更好一点的版本？
有的，先介绍一个进化版本的静态内部类替代方案 ( 也可以理解成 动态代理 方案的雏形 )

升级版的静态内部类替代方案

代码还可以这样写：

public  class  WeakRunnable implements Runnable {
       private  WeakReference<Runnable> mWr;
       public  WeakRunnable(Runnable  runnable) {
              mWr = new WeakReference<Runnable>( runnable );
       }

      public void run() {
             Runnable runnable = mWr.get();
             if (runnable != null) {
                    runnable.run();
             }
      }
}

public  class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";
    List<Object>  mReferList = new ArrayList<Object>();// 很重要

     public void onCreate() {
          Runnable runnable = new Runnable() { // 去线程池中被执行
                   public  void run() {
                        Thread.sleep( 1000 * 60 ); //休眠 1 分钟
                        String info = "name:" + name + "; age:" + age;
                        Log.i("TestInfo", info);
                        ....
                   }
         };
         mReferList.add( runnable ); // 防止 runnable 被快速 GC 掉。
         ThreadPoolUtil.execRunnable( new WeakRunnable( runnable ));
    }
}

这个版本比着之前的那个版本，是要好了不少，所有的 Runnable 都可以共用一个类 WeakRunnable 了，你可以对 Runnable 接口自由的使用匿名内部类，且不会引起内存泄漏。

(注意： mReferList 的作用是把 runnable 给存起来，否则 runnable 没有被其他强引用所持有， 在下次 GC 的时候就被回收掉 )

有没有更通用性一点的解决方案呢？ 有的

动态代理方案

上面的 WeakRunnable 类，从设计模式上讲，是设计模式中的代理模式。而 Java 语言对代理模式做了进一步的支持，它提供了一个类 Proxy，专门处理类似于上面的问题，不懂 Java 动态代理的读者，可以参考 IBM 大神们写的http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/ 。

此时，代码可以写成这样：

public  class WeakProxy implements InvocationHandler {
       private  WeakReference<Runnable> mWr;
       public  WeakRunnable(Runnable  runnable) {
              mWr = new WeakReference<Runnable>( runnable );
       }

      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          Object proxied = mWr.get();
          if (proxied == null) {
              return null;
          }
          return method.invoke(proxied, args);
       }

       public static <T> T wrap(T object) {
          if (object == null) {
              return null;
          }
          return (T) Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(), new WeakProxy(object));
        }
 }

public  class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";
    List<Object>  mReferList = new ArrayList<Object>();// 很重要

     public void onCreate() {
          Runnable runnable = new Runnable() { // 去线程池中被执行
                   public  void run() {
                        Thread.sleep( 1000 * 60 ); //休眠 1 分钟
                        String info = "name:" + name + "; age:" + age;
                        Log.i("TestInfo", info);
                        ....
                   }
         };
         mReferList.add(runnable); // 防止 runnable 被快速 GC 掉。
         ThreadPoolUtil.execRunnable( WeakProxy.wrap( runnable ));
    }
}

先大致讲解下代码，关于 WeakProxy.wrap( runnable ) 这行代码，共涉及了 3 个对象，一个是具体做事情的 runnable，一个是 WeakProxy 实例，记作 runnableWrapper, runnableWrapper 的字段 mWr 就弱引用着 runnable, 还有一个对象是 WeakProxy.wrap( runnable ) 的返回值，记作 runnableProxy; runnableProxy 和 runnable 拥有所有相同的接口方法，即 runnableProxy 可以当作 runnable 使用； 当调用 runnableProxy 的方法时，runnableProxy 会去调用 runnableWrapper 的 invoke() 方法，而 runnableWrapper 再去调用 runnable 的方法.

然而，还是有不足的，我们必须待使用 Runnable runnable = new Runnable(){...} 的方式去写匿名内部类，而不能直接以 doXxx( new Runnable() { ... } ) 的方式！

书写成 Runnable runnable = new Runnable(){...} 这个样子，是为了把 runnable 放置到 mReferList 中，而这部分工作可以使用接口化来做。所以，最终的方案如下：

public class WeakProxy implements InvocationHandler {
       private  WeakReference<Runnable> mWr;
       public  WeakRunnable(Runnable  runnable) {
              mWr = new WeakReference<Runnable>( runnable );
       }

      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          Object proxied = mWr.get();
          if (proxied == null) {
              return null;
          }
          return method.invoke(proxied, args);
       }

      public static <T> T wrap(IWeakHost host, T object) {
          if (host != null && object != null) {
             host.referObject(object);
          }
          return wrap(object);
       }

       private  static <T> T wrap(T object) {
          if (object == null) {
              return null;
          }
          return (T) Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(), new WeakProxy(object));
        }

       public interface IWeakHost {
          void referObject(Object obj);
       }
 }

public  class  MyActivity extends Activity implements WeakProxy. IWeakHost{
    private  int  age = 14;
    String name = "zhangsan";

    List<Object>  mReferList = new ArrayList<Object>();

    @Override
    public void referObject(Object obj) {
        mReferList.add(obj);
     }

     public void onCreate() {
         ThreadPoolUtil.execRunnable(WeakProxy.wrap(this, new Runnable() { // 去线程池中被执行
                   public  void run() {
                        Thread.sleep(1000 * 60 ); //休眠 1 分钟
                        String info = "name:" + name + "; age:" + age;
                        Log.i("TestInfo", info);
                        ....
                   }
         }));
    }
}

接口 IWeakHost 的实现可以固定为

    List<Object>  mReferList = new ArrayList<Object>();

    @Override
    public void referObject(Object obj) {
        mReferList.add(obj);
     }

建议在你的工程中的 BaseFragment 或 BaseActivity 类上实现 IWeakHost 。

(Note: WeakProxy 这个类是可以直接拿去用的， 不用做任何修改！)

动态代理的适用场景

动态代理的适用场景： 内部类的方法中，确实使用到了外围类的成员变量 或 方法。
举个例子，类似于下面的场景:
场景 1 ：

public class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";

     public void onCreate() {
          ThreadPoolUtil.execRunnable( new Runnable() { // 去线程池中被执行
                   public  void run() {
                        Thread.sleep( 1000 * 60 ); 
                        String info = "name:" + name + "; age:" + age; // 使用了外围实例的成员变量
                        Log.i("TestInfo", info);
                        ....
                   }
         } );
    }
}

或 场景2 ：

public  class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";

     public void onCreate() {
          ThreadPoolUtil.execRunnable(new  MyRunnable(this));
    }

   public void doXXX() {
       // do someThing
   }
   static class  MyRunnable implements Runnable {

         private  WeakReference<MyActivity>  mWrActivity;

         public  MyRunnable( MyActivity  activity ) {
               mWrActivity  =  new WeakReference<MyActivity>( activity );
         }

          public  void run() {
                       MyActivity  activity =  mWrActivity.get();
                       if (activity == null) {
                               return;
                        }
                        Thread.sleep( 1000 * 60 ); 
                        String info = "name:" + activity.name + "; age:" + activity.age;// 使用了外围实例的成员变量
                        activity.doXXX(); // 或 调用了外围实例的方法
                        Log.i("TestInfo", info);
                        ....
          }
   }

}

这两种场景，都可以使用 WeakProxy.wrap() 的写法代替。 对于场景 2 ，它的优点和缺点 与 WeakProxy 是一样的。 WeakProxy 是从场景 2 的写法中推演出来的，它并不比场景 2 的写法更高明，只是写法上让程序员更加舒服而已。

而对于以下的场景:
场景 3:

public class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";

     public void onCreate() {
          ThreadPoolUtil.execRunnable( new Runnable() { // 去线程池中被执行
                   public  void run() {
                        Log.i("TestInfo", "hello, world"); // 没有使用外围实例的成员变量 或 方法
                        ....
                   }
         } );
    }
}

或 场景 4 ：

public  class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";

     public void onCreate() {
          ThreadPoolUtil.execRunnable(new  MyRunnable(this));
    }

   static class  MyRunnable implements Runnable {

         private  WeakReference<MyActivity>  mWrActivity;

         public  MyRunnable( MyActivity  activity ) {
               mWrActivity  =  new WeakReference<MyActivity>( activity );
         }

          public  void run() {

                        Log.i("TestInfo", "hello, world");// 没有使用外围实例的成员变量 或 方法
                        ....
          }
   }

}

对于上面两种场景，内部类的方法中没有使用外围实例的成员变量 和 方法，所以它们的最佳写法不是使用 WeakProxy，也不是使用静态内部类 + 弱引用的方式 ，而是使用静态方法，比如写成这样:

public  class  MyActivity extends Activity {
    private  int  age = 14;
    String name = "zhangsan";

     public void onCreate() {
          doSomeThing();
         printNameAndAge(age,  name);
    }

   private   static  void  doSomeThing() {
       ThreadPoolUtil.execRunnable( new Runnable() {  // 这个是静态匿名内部类，不引用外围类
                   public  void run() {
                        Log.i("TestInfo", "hello, world"); // 没有使用外围实例的成员变量 或 方法
                        ....
                   }
         } );
  }

 private   static  void  printNameAndAge(final  int  age , final  String  name ) {// 参数只要没有引用外围类就行
       ThreadPoolUtil.execRunnable( new Runnable() { // 这个是静态匿名内部类，不引用外围类
                   public  void run() {
                        Log.i("TestInfo", "name : " + name + "; age:" + age ); // 没有使用外围实例的成员变量 或 方法
                        ....
                   }
         } );
  }

最后需要说明一点： WeakProxy.wrap() 的方式，是从 静态内部类 + 弱引用 的写法中推演出来的，它的优点和缺点 都与 静态内部类 + 弱引用 一样 ！ 所以它的使用场景，即是 静态内部类 + 弱引用 的使用场景 ！

当你要写匿名内部类时，如果你的代码：
符合场景 1 和 场景 2： 请使用 WeakProxy.wrap(....)
符合场景 3 和场景 4： 请使用静态方法 + 静态匿名内部类的方式

Warden032
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 匿名内部类作为事件监听类
05-25
Android 匿名内部类作为事件监听类
接口到底能不能实例化。
热门推荐
MaoDunTi的专栏
08-20 2万+
先给大家看一个常用的代码： tv1.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub
匿名内部类在开发中的使用（安卓中常用到）
test_testTim的博客
07-01 375
//定义接口 interface PersonDao{ void study(); }//调用接口 class Demo{ public void toSchool(PersonDao p){ p.study(); } }//测试 class Test{ public static void main(String[] args){ ...
Android什么是匿名内部类,Android里的匿名内部类
weixin_32160507的博客
06-03 766
(转)https://blog.csdn.net/qq_25827845/article/details/52598319匿名内部类也就是没有名字的内部类，正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口1、继承一个父类的匿名内部类实现：abstractclassPeople{publicabstractvoidea...
安卓学习笔记 匿名内部类
Hello！
06-27 490
目录 目录 一.怎么使用匿名内部类 二. 在使用匿名内部类的过程中，我们需要注意如下几点： 一.怎么使用匿名内部类 在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。 // 设置取消的Button ...
老生常谈 java匿名内部类
09-01
- 由于其匿名性，匿名内部类不能声明公共构造器。 - 匿名内部类中定义的方法数量没有硬性规定，但过多的方法会降低代码可读性。 - 匿名内部类不能包含静态成员（除了静态final常量）。 6. **示例解析**： 在给...
Android开发匿名内部类
08-01
`MyThread2`中，匿名内部类直接实现了`Thread`的`run()`方法，而`MyThread3`则创建了一个实现了`Runnable`接口的匿名内部类，然后将其传递给`Thread`构造函数。 匿名内部类的特点： 1. **简洁紧凑**：匿名内部类...
Java 匿名内部类
08-02
这在处理事件监听时特别常见，比如在Swing或Android开发中，我们可以直接在需要的地方创建一个匿名内部类来实现事件处理器接口。 2. **单次使用**： 因为匿名内部类没有名字，所以它只能被定义一次，通常用于一次...
Java4Android 35_内部类和匿名内部类
09-07
学习“Java4Android 35_内部类和匿名内部类”这个教程，开发者将掌握如何有效地利用内部类和匿名内部类，提升代码的结构和功能，特别是在Android应用开发中，这两个特性对于构建组件和事件处理尤为重要。通过观看...
Java匿名内部类的写法示例
09-07
- **匿名实现回调**：在多线程编程中，`Thread`类的构造函数接受`Runnable`接口作为参数，可以使用匿名内部类快速实现回调。 - **匿名继承抽象类**：当需要快速实现一个抽象类的某个特定方法时，可以使用匿名内部类...
匿名内部类实现接口回调
08-22
简单接口回调demo。
android什么叫匿名内部类,Android里面的匿名类与匿名内部类使用
weixin_35607076的博客
05-30 1097
在android开发中经常碰到匿名类(和匿名内部类)的使用，那么匿名类和一般情况下使用的类有什么不同，从实现的功能来讲是一样的，但是使用匿名更加简洁方便，形式上有点像new一个接口或类的感觉，但是我们必须记住接口是不可以new出来的(实例化)，我们要在内部重写需要的接口的方法，这样就new出了一个实现接口方法的对象，但是这个对象的类名不可见，所以叫做匿名类。下面是功能相同的两段代码，分别用上述两种...
匿名内部类的理解（java + Android）
qq_41008818的博客
01-11 662
匿名内部类的官方说法特别不容易理解，是从"有没有名字"给它命名，而不是功能命名，导致很多人学了都不知道怎么用，考试厉害实操菜，今天就说说匿名内部类的经典实操案例。
android学习：匿名内部类
08-01 436
class Father(){ ... } public class Test{    Father f = new Father(){ .... }  }   相当于 class Father(){ ... } class Son extends Father   ....     } public class Test{    Father f =
Android中随处可见的匿名内部类
my9074的专栏
01-26 670
在JAVA中接口是不可以被实例化的 那么这段代码是如何执行的呢？ button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub Log.v("Event", "butto
android access 内部类,内部类-匿名内部类
weixin_39763293的博客
05-31 254
https://www.geeksforgeeks.org/anonymous-inner-class-java/Anonymous Inner Class in JavaIt is an inner class without a name and for which only a single object is created. An anonymous inner class can be...
Android的四种点击事件之匿名内部类
小白学编程
12-08 1050
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具与关键技术：Android Studio软件， Android点击事件 撰写时间：2021-12-08 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 下面是以一个按钮作为点击，分别写出4种点击事件。
android中常用的匿名内部类的写法
翟浩浩Android专栏
03-20 2066
package com.zhh; /** * * android中常用的匿名内部类的写法 * */ public class MyNiMing { public static void main(String[] args) { method1(new MyInterface() { @Override public void method2() {
android内部匿名类调用方法,Android编程之匿名内部类与回调函数用法分析
weixin_42505477的博客
05-25 498
本文实例讲述了Android编程之匿名内部类与回调函数用法。分享给大家供大家参考，具体如下：我们Android开发中经常用到一些匿名内部类，及其其中的回调函数，例如，我们给Button设置监听器时候通常要实现OnCLickListener接口，并重写其中的Onclick()方法，这就是匿名内部类与回调函数，那么你对Java匿名内部类以及回调函数又理解多少呢？这篇文档给予比较详细的解释。首先应该知道...
java匿名内部类的用法
最新发布
07-02
2. **创建事件监听器**：在Swing或Android等框架中，常常使用匿名内部类作为事件处理器，如按钮点击事件监听器： ```java button.addActionListener(new ActionListener() { public void actionPerformed...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值