本文已在我的公众号hongyangAndroid原创发布。
转载请标明出处:
本文出自:涨鸿洋的博客
前段时间在dota群,一哥们出去面试,回顾面试题的时候,说问到了枚举。
作为一名Android选手,谈到枚举,那肯定是:
Android上不应该使用枚举,占内存,应该使用@XXXDef注解来替代,balabala…
这么一回答,心里美滋滋。
没想到面试官问了句:
- 枚举的原理是什么?你说它占内存到底占多少内存呢,如何佐证?
听到这就慌了,没了解过呀。
下面说第一个问题(没错还有第二个问题)。
枚举的本质
有篇文章:
写得挺好的。
下面还是要简述一下,我们先写个枚举类:
public enum Animal { DOG,CAT}
- 1
- 2
- 3
看着这代码,完全看不出来原理。不过大家应该都知道java类编译后会产生class文件。
越接近底层,本质就越容易暴露出来了。
我们先javac搞到Animal.class,然后通过javap命令看哈:
javap Animal.class
- 1
输出:
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 {};}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
其实到这里我们已经大致知道枚举的本质了,实际上我们编写的枚举类Animal是继承自Enum的,每个枚举对象都是static final的类对象。
还想知道更多的细节怎么办,比如我们的对象什么时候初始化的。
我们可以添加-c参数,对代码进行反编译。
你可以使用javap -help 查看所有参数的含义。
javap -c Animal.class
- 1
输出:
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}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
好了,现在可以分析代码了。
但是,这代码看起来也太头疼了,我们先看一点点:
static中部分代码:
0: new #4 // class Animal3: dup4: ldc #7 // String DOG6: iconst_07: invokespecial #8 // Method "<init>":(Ljava/lang/String;I)V10: putstatic #9 // Field DOG:LAnimal;
- 1
- 2
- 3
- 4
- 5
- 6
大致含义就是new Animal(String,int),然后给我们的静态常量DOG赋值。
好了,不看了,好烦。我们转念想一下,如果这个字节码咱们能看懂,那就是有规则的,只要有规则,肯定有类似翻译类的工具,直接转成java代码的。
确实有,比如jad:
我们先下载一份,很小:
命令也很简单,执行:
./jad -sjava Animal.class
- 1
就会在当前目录生成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 }); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
到这,我相信你知道我们编写的枚举类:
public enum Animal { DOG,CAT}
- 1
- 2
- 3
最终生成是这样的类,那么对应的我们所使用的方法也就都明白了。此外,你如何拿这样的类,跟两个静态INT常量比内存,那肯定是多得多的。
其次,我们也能顺便回答,枚举对象为什么是单例了。
并且其Enum类中对readObject和clone方法都进行了实现,看一眼你就明白了。
本文并不是为了去讨论枚举的原理,而是想要给大家说明的是很多“语法糖”类似的东西,都能按照这样的思路去了解它的原理。
下面我们再看一个,听起来稍微高端一点的:
- 动态代理
动态代理
这个比较出名的就是retrofit了。
问:retrofit的原理是?答:基于动态代理,然后balabal...问:那么动态代理的原理是?答:...
- 1
- 2
- 3
- 4
- 5
- 6
- 7
我们依然从一个最简单的例子开始。
我们写一个接口:
public interface IUserService{ void login(String username, String password);}
- 1
- 2
- 3
然后,利用动态代理去生成一个代理对象,去调用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"); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
好了,这应该是最简单的动态代理的例子了。
当我们去调研userService.login方法,你会发现InvocationHandler的invoke方法调用了,并且输出了相关信息。
怎么会这么神奇呢?
我们写了一个接口,就能产生一个该接口的对象,然后我们还能拦截它的方法。
继续看:
先javac Test.java
,得到class文件。
然后调用:
java Test
- 1
输出:
class com.sun.proxy.$Proxy0method = login , args = [zhy, 123]
- 1
- 2
可以看到当我们调用login方法的时候,invoke中拦截到了我们的方法,参数等信息。
retrofit的原理其实就是这样,拦截到方法、参数,再根据我们在方法上的注解,去拼接为一个正常的Okhttp请求,然后执行。
想知道原理,根据我们枚举中的经验,肯定想看看这个
com.sun.proxy.$Proxy0 // userService对象输出的全路径
- 1
这个类的class文件如何获取呢?
很简单,你在main方法的第一行,添加:
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
- 1
- 2
然后重新编译、执行,就会在当前目录看到了。
MacBook-Pro:tmp zhanghongyang01$ tree .├── IUserService.class├── IUserService.java├── Test$1.class├── Test.class├── Test.java└── com └── sun └── proxy └── $Proxy0.class3 directories, 6 files
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
然后,还想通过javap -c
来看么~~
还是拿出我们刚才下载的jad吧。
执行:
./jad -sjava com/sun/proxy/\$Proxy0.class
- 1
在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") }); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
为了便于理解,删除了一些equals,hashCode等方法。
你可以看到,实际上为我们生成一个实现了IUserSevice的类,我们调用其login方法,实际上就是调用了:
super.h.invoke(this, m3, new Object[] { s, s1 });
- 1
- 2
- 3
m3即为我们的login方法,静态块中初始化的。剩下是我们传入的参数。
那我们看super.h是什么:
package java.lang.reflect;public class Proxy{ protected InvocationHandler h;}
- 1
- 2
- 3
- 4
就是我们自己创建的InvocationHandler对象。
看着这个类,再想login方法,为什么会回调到InvocationHandler的invoke方法,你还觉得奇怪么~~
好了,实际上这个哥们面试距离现在挺久了,终于抽空写完了,希望大家有一定的收获~
再分享一下我老师大神的人工智能教程吧。零基础!通俗易懂!风趣幽默!还带黄段子!希望你也加入到我们人工智能的队伍中来!https://blog.csdn.net/jiangjunshow