关闭

从一道面试题开始说起 枚举、动态代理的原理

标签: android面试题
739人阅读 评论(6) 收藏 举报
分类:

本文已在我的公众号hongyangAndroid原创发布。
转载请标明出处:
本文出自:涨鸿洋的博客

前段时间在dota群,一哥们出去面试,回顾面试题的时候,说问到了枚举。

作为一名Android选手,谈到枚举,那肯定是:

Android上不应该使用枚举,占内存,应该使用@XXXDef注解来替代,balabala…

这么一回答,心里美滋滋。

没想到面试官问了句:

  • 枚举的原理是什么?你说它占内存到底占多少内存呢,如何佐证?

听到这就慌了,没了解过呀。

下面说第一个问题(没错还有第二个问题)。

枚举的本质

有篇文章:

http://blog.csdn.net/mhmyqn/article/details/48087247

写得挺好的。

下面还是要简述一下,我们先写个枚举类:

public enum Animal {
    DOG,CAT
}

看着这代码,完全看不出来原理。不过大家应该都知道java类编译后会产生class文件。

越接近底层,本质就越容易暴露出来了。

我们先javac搞到Animal.class,然后通过javap命令看哈:

javap Animal.class

输出:

public final class Animal extends java.lang.Enum<Animal> {
  public static final Animal DOG;
  public static final Animal CAT;
  public static Animal[] values();
  public static Animal valueOf(java.lang.String);
  static {};
}

其实到这里我们已经大致知道枚举的本质了,实际上我们编写的枚举类Animal是继承自Enum的,每个枚举对象都是static final的类对象。

还想知道更多的细节怎么办,比如我们的对象什么时候初始化的。

我们可以添加-c参数,对代码进行反编译。

你可以使用javap -help 查看所有参数的含义。

javap -c Animal.class

输出:

public final class Animal extends java.lang.Enum<Animal> {
  public static final Animal DOG;

  public static final Animal CAT;

  public static Animal[] values();
    Code:
       0: getstatic     #1                  // Field $VALUES:[LAnimal;
       3: invokevirtual #2                  // Method "[LAnimal;".clone:()Ljava/lang/Object;
       6: checkcast     #3                  // class "[LAnimal;"
       9: areturn

  public static Animal valueOf(java.lang.String);
    Code:
       0: ldc           #4                  // class Animal
       2: aload_0
       3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
       6: checkcast     #4                  // class Animal
       9: areturn

  static {};
    Code:
       0: new           #4                  // class Animal
       3: dup
       4: ldc           #7                  // String DOG
       6: iconst_0
       7: invokespecial #8                  // Method "<init>":(Ljava/lang/String;I)V
      10: putstatic     #9                  // Field DOG:LAnimal;
      13: new           #4                  // class Animal
      16: dup
      17: ldc           #10                 // String CAT
      19: iconst_1
      20: invokespecial #8                  // Method "<init>":(Ljava/lang/String;I)V
      23: putstatic     #11                 // Field CAT:LAnimal;
      26: iconst_2
      27: anewarray     #4                  // class Animal
      30: dup
      31: iconst_0
      32: getstatic     #9                  // Field DOG:LAnimal;
      35: aastore
      36: dup
      37: iconst_1
      38: getstatic     #11                 // Field CAT:LAnimal;
      41: aastore
      42: putstatic     #1                  // Field $VALUES:[LAnimal;
      45: return
}

好了,现在可以分析代码了。

但是,这代码看起来也太头疼了,我们先看一点点:

static中部分代码:

0: new           #4                  // class Animal
3: dup
4: ldc           #7                  // String DOG
6: iconst_0
7: invokespecial #8                  // Method "<init>":(Ljava/lang/String;I)V
10: putstatic     #9                  // Field DOG:LAnimal;

大致含义就是new Animal(String,int),然后给我们的静态常量DOG赋值。

好了,不看了,好烦。我们转念想一下,如果这个字节码咱们能看懂,那就是有规则的,只要有规则,肯定有类似翻译类的工具,直接转成java代码的。

确实有,比如jad:

http://www.javadecompilers.com/jad

我们先下载一份,很小:

meiju01.png

命令也很简单,执行:

./jad -sjava Animal.class

就会在当前目录生成java文件了。

输出如下:

public final class Animal extends Enum
{

    public static Animal[] values()
    {
        return (Animal[])$VALUES.clone();
    }

    public static Animal valueOf(String s)
    {
        return (Animal)Enum.valueOf(Animal, s);
    }

    private Animal(String s, int i)
    {
        super(s, i);
    }

    public static final Animal DOG;
    public static final Animal CAT;
    private static final Animal $VALUES[];

    static 
    {
        DOG = new Animal("DOG", 0);
        CAT = new Animal("CAT", 1);
        $VALUES = (new Animal[] {
            DOG, CAT
        });
    }
}

到这,我相信你知道我们编写的枚举类:

public enum Animal {
    DOG,CAT
}

最终生成是这样的类,那么对应的我们所使用的方法也就都明白了。此外,你如何拿这样的类,跟两个静态INT常量比内存,那肯定是多得多的。

其次,我们也能顺便回答,枚举对象为什么是单例了。

并且其Enum类中对readObject和clone方法都进行了实现,看一眼你就明白了。

本文并不是为了去讨论枚举的原理,而是想要给大家说明的是很多“语法糖”类似的东西,都能按照这样的思路去了解它的原理。

下面我们再看一个,听起来稍微高端一点的:

  • 动态代理

动态代理

这个比较出名的就是retrofit了。

问:retrofit的原理是?

答:基于动态代理,然后balabal...

问:那么动态代理的原理是?

答:...

我们依然从一个最简单的例子开始。

我们写一个接口:

public interface IUserService{
    void login(String username, String password);
}

然后,利用动态代理去生成一个代理对象,去调用login方法:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class Test{
    public static void main(String[] args){

        IUserService userService = (IUserService) Proxy.newProxyInstance(IUserService.class.getClassLoader(),
                new Class[]{IUserService.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("method = " + method.getName() +" , args = " + Arrays.toString(args));

                        return null;
                    }
                });

        System.out.println(userService.getClass());

        userService.login("zhy","123");
    }
}

好了,这应该是最简单的动态代理的例子了。

当我们去调研userService.login方法,你会发现InvocationHandler的invoke方法调用了,并且输出了相关信息。

怎么会这么神奇呢?

我们写了一个接口,就能产生一个该接口的对象,然后我们还能拦截它的方法。

继续看:

javac Test.java,得到class文件。

然后调用:

java Test

输出:

class com.sun.proxy.$Proxy0
method = login , args = [zhy, 123]

可以看到当我们调用login方法的时候,invoke中拦截到了我们的方法,参数等信息。

retrofit的原理其实就是这样,拦截到方法、参数,再根据我们在方法上的注解,去拼接为一个正常的Okhttp请求,然后执行。

想知道原理,根据我们枚举中的经验,肯定想看看这个

com.sun.proxy.$Proxy0 // userService对象输出的全路径

这个类的class文件如何获取呢?

很简单,你在main方法的第一行,添加:

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");  

然后重新编译、执行,就会在当前目录看到了。

MacBook-Pro:tmp zhanghongyang01$ tree 
.
├── IUserService.class
├── IUserService.java
├── Test$1.class
├── Test.class
├── Test.java
└── com
    └── sun
        └── proxy
            └── $Proxy0.class

3 directories, 6 files

然后,还想通过javap -c来看么~~

这里写图片描述

还是拿出我们刚才下载的jad吧。

执行:

./jad -sjava com/sun/proxy/\$Proxy0.class 

在jad的同目录,你就发现了Proxy0的java文件了:

package com.sun.proxy;

import IUserService;
import java.lang.reflect.*;

public final class $Proxy0 extends Proxy
    implements IUserService
{

    public $Proxy0(InvocationHandler invocationhandler)
    {
        super(invocationhandler);
    }

    public final void login(String s, String s1)
    {
        super.h.invoke(this, m3, new Object[] {
            s, s1
        }); 
    }


    private static Method m3;

    static 
    {
        m3 = Class.forName("IUserService").getMethod("login", new Class[] {
            Class.forName("java.lang.String"), Class.forName("java.lang.String")
        });

    }
}

为了便于理解,删除了一些equals,hashCode等方法。

你可以看到,实际上为我们生成一个实现了IUserSevice的类,我们调用其login方法,实际上就是调用了:

 super.h.invoke(this, m3, new Object[] {
            s, s1
        }); 

m3即为我们的login方法,静态块中初始化的。剩下是我们传入的参数。

那我们看super.h是什么:

package java.lang.reflect;
public class Proxy{
    protected InvocationHandler h;
}

就是我们自己创建的InvocationHandler对象。

看着这个类,再想login方法,为什么会回调到InvocationHandler的invoke方法,你还觉得奇怪么~~

好了,实际上这个哥们面试距离现在挺久了,终于抽空写完了,希望大家有一定的收获~

2
0
查看评论

iOS 面试时可能会提到的知识点,整理下!

1、frame bouns  区别  在view中画出区别2、代理、单例  手写代码 3、设计模式   延迟加载    监听     kvo    mvc 4、深拷贝 浅拷贝  区别 &...
  • jekkihun
  • jekkihun
  • 2014-06-10 14:53
  • 915

java学习笔记之 --------枚举(enum)

enum枚举类型是JAVA SE 5.0 以后的版本新定义出来的, 在此版本之前,有个常用的方法来做枚举类,  这个是视频中学到的。。。 class WeekDay{ public static final WeekDay SUN = new WeekDay(); public...
  • yzldw333
  • yzldw333
  • 2013-03-14 17:45
  • 1917

Java 枚举enum 使用详解

在实际编程中,往往存在着这样的“数据集”,它们的数值在程序中是稳定的,而且“数据集”中的元素是有限的。 例如星期一到星期日七个数据元素组成了一周的“数据集”,春夏秋冬四个数据元素组成了四季的“数据集”。 在java中如何更好的使用这些“数据集”呢?因此枚举便派上了用场,以下代码详细介绍了枚举的用...
  • zcback1
  • zcback1
  • 2016-03-30 14:30
  • 9589

史上最难的一道Java面试题

求下面这段程序的运行结果public class TestSync2 implements Runnable{ int b=100; synchronized void m1() throws InterruptedException { b=1000; ...
  • weixin_38553453
  • weixin_38553453
  • 2017-06-08 15:31
  • 606

建议7: 将0值作为枚举的默认值

建议7: 将0值作为枚举的默认值 允许使用的枚举类型有byte、sbyte、short、ushort、int、uint、long和ulong。应该始终将0值作为枚举类型的默认值。不过,这样做不是因为允许使用的枚举类型在声明时的默认值是0值,而是有工程上的意义。 试想,一个代表星期的枚举类Week...
  • houwc
  • houwc
  • 2016-08-29 20:35
  • 1159

Wireshark入门:第一次亲密接触

本篇文章转载自-- 林沛满的博客 http://blog.sina.com.cn/linpeiman  很多年前,当笔者还是少年的时候,就在家里搭建过Windows Domain, Linux与Windows相互共享,交换机和路由器的虚拟环境等。因为读书百遍,其...
  • JIANGXIN04211
  • JIANGXIN04211
  • 2015-11-02 17:44
  • 591

web前端一道很“坑”的js面试题

f = function() {return true;}; g = function() {return false;}; (function() {if (g() && [] == ![]) {f = function f() {return false;};function...
  • k358971707
  • k358971707
  • 2017-02-23 22:28
  • 994

从一道++操作面试题说起(Javap)

题目: j初始值为0,j=j++;循环100遍值为多少? int j = 0; for (int i = 0; i < 100; i++) { j = j++; } System.out.println(j); 答案: 0 原理探析: 1、当然如果我们讨论的深入一些...
  • tayanxunhua
  • tayanxunhua
  • 2013-10-05 15:10
  • 1190

java 枚举(面试题)基本知识总结即简例

枚举 jdk1.5以后引入 关键字 enmu enmu Apple{     Jonathan,   GoldenDel, RedDel }  枚举常量被隐式声明为Apple的公有静态 final成员 枚举能够定义类类型,但却不...
  • beloveddarling
  • beloveddarling
  • 2016-03-21 21:06
  • 581

细说JDK动态代理的实现原理

关于JDK的动态代理,最为人熟知的可能要数Spring AOP的实现,默认情况下,Spring AOP的实现对于接口来说就是使用的JDK的动态代理来实现的,而对于类的代理使用CGLIB来实现。那么,什么是JDK的动态代理呢? JDK的动态代理,就是在程序运行的过程中,根据被代理的接口来动态生成代理类...
  • mhmyqn
  • mhmyqn
  • 2015-09-15 21:12
  • 21908
    个人资料
    • 访问:18230847次
    • 积分:51660
    • 等级:
    • 排名:第65名
    • 原创:207篇
    • 转载:0篇
    • 译文:6篇
    • 评论:15733条
    我的微信公众号
    联系方式


    QQ群:
    • 55032675
    • 423372824
    • 497438697
    • 请勿重复加群,Thx
    博客专栏
    统计