本文主要是介绍从一道面试题开始说起 枚举、动态代理的原理，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
随时随地技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666)
from:https://blog.csdn.net/lmj623565791/article/details/79278864
本文已在我的公众号hongyangAndroid原创发布。
转载请标明出处：
本文出自：涨鸿洋的博客
前段时间在dota群，一哥们出去面试，回顾面试题的时候，说问到了枚举。
作为一名Android选手，谈到枚举，那肯定是：
Android上不应该使用枚举，占内存，应该使用@XXXDef注解来替代，balabala…
这么一回答，心里美滋滋。
没想到面试官问了句：
- 枚举的原理是什么？你说它占内存到底占多少内存呢，如何佐证？
听到这就慌了，没了解过呀。
下面说第一个问题（没错还有第二个问题）。
枚举的本质
有篇文章：
java枚举类型的实现原理_痴人说梦-CSDN博客_java 枚举类原理
写得挺好的。
下面还是要简述一下，我们先写个枚举类：
public enum Animal {DOG,CAT
}看着这代码，完全看不出来原理。不过大家应该都知道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 {};
}其实到这里我们已经大致知道枚举的本质了，实际上我们编写的枚举类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: areturnpublic static Animal valueOf(java.lang.String);Code:0: ldc #4 // class Animal2: aload_03: invokestatic #5 // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;6: checkcast #4 // class Animal9: areturnstatic {};Code: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;13: new #4 // class Animal16: dup17: ldc #10 // String CAT19: iconst_120: invokespecial #8 // Method "<init>":(Ljava/lang/String;I)V23: putstatic #11 // Field CAT:LAnimal;26: iconst_227: anewarray #4 // class Animal30: dup31: iconst_032: getstatic #9 // Field DOG:LAnimal;35: aastore36: dup37: iconst_138: getstatic #11 // Field CAT:LAnimal;41: aastore42: 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：
JAD Decompiler Download ✓
我们先下载一份，很小：
命令也很简单，执行:
./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() {@Overridepublic 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.class3 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 Proxyimplements 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方法，你还觉得奇怪么~~
好了，实际上这个哥们面试距离现在挺久了，终于抽空写完了，希望大家有一定的收获~
这篇关于从一道面试题开始说起 枚举、动态代理的原理的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
