java 面试--序列化、反射、拷贝
在之前的文章中，已经发布了常见的面试题，这里我了点时间整理了一下对应的解答。【由于个人能力有限，不一定完全到位，如果有解答的不合理的地方还请指点，在此谢过。】
java创建一个类的方法有几种？
这是字节跳动的一道面试题，原来的题目意思是除了new一个对象，java还可以通过哪些方法来构建一个对象？这是一个java基本语法的题目，涉及到反序列化，拷贝，反射等基础知识。那这几个知识点也是java面试中常见的面试题。如果在回答完上面的方法适合，我们也可以适当的展开说序列化，拷贝和反射的原理。这样会显得对某些知识点掌握相对扎实，留下一些好的印象。
序列化
Java的序列化的作用是什么？
其底层实现的原理是如何的？
你了解到哪些常见的序列化框架，其优缺点是？
Java 序列化类中有一个final的Long型id,这个序列化id的作用是什么？如果没有的话，是否可以序列化成功？
如果不想序列化某个字段，应该怎么办？
上面描述的问题是序列化中常见的面试题，这里也说明一下。
序列化的作用：
我们都知道，java是以对象为基本核心理念的，在java中，万物皆为对象。在某些场景下，我们需要将对象传递给其他机器或者写到磁盘保存。这个时候就需要将对象转换成二进制的方式，它是一个对象转换为二进制流的过程，而序列化过程就是完成这项工作的，与之对应的是将二进制转换为对象的过程，我们称之为反序列化过程。
序列化的步骤：
Java实现序列化的过程由以下几个流程：
1. 在类对象中实现Serializable接口
2. 在类中定义序列化id
序列化的原理：
在这里，我们介绍java默认的序列化和反序列化的函数。也就是按照上面步骤只实现了序列化的接口。那java底层是通过iO包中的ObjectOutputStream实现将对象转换为二进制流。ObjectOutputStream中的核心方法在于这个writeObject，其实现也是按深度，按照类型写入流中，数组和string，null的写入等等。而writeObject方法核心是writeObject0（看多了源码，你会发现好多源码喜欢使用0代表真正的实现或者do开头的），如果想更多了解源码的话，可以看之前的jdk1.8系列的源码阅读文章。与此相反的是反序列的方法，也就是ObjectInputStream.
1. public final void writeObject(Object obj) throws IOException {
2. if (enableOverride) {//如果是允许重写了这个方法，使用该序列化方法
3. writeObjectOverride(obj);
4. return;
5. }
6. try {
7. writeObject0(obj, false);//使用默认的序列化方法
8. } catch (IOException ex) {
9. if (depth == 0) {
10. writeFatalException(ex);
11. }
12. throw ex;
13. }
14. }
序列化id：
在序列化中，序列化id其实是一个版本管理的问题，其实在很多时候，我们都会使用到，因为一个对象在使用的过程中，难免出现修改字段，这时候需要将序列化id升级一个版本区分之前的版本。如果没有写序列化id能否序列化成功，当然是可以的，如果我们没有写序列化id 的时候，jvm会默认根据相应的规则生成一个，但这个时候可能会有一个问题是，但我们把jdk升级可能会导致序列化id和之前的不同，这就会导致代码出现无法序列化的问题。所以为了安全起见，最后在代码生成的时候加上一个序列化id。
Transient：
如果不想对某个字段进行序列化，可以使用transient。当然了static也不能被序列化，static是类的概念，而transient是临时的概念。
常见的序列化框架：
这类题目一般出现在后面几面，因为它不在是一个基础题，更多是一个知识体系和知识面的扩展。这种一般就是架构师要了解的，对不同的框架优缺点和选型做一个了解。这种一般回答几个，并且对其优缺点做下介绍。一般序列化框架会从以下几个方面比较，速度，序列化后的大小，是否跨语言。下面摘自博客【java序列化性能对比】的结果（详情：https://www.bbsmax.com/A/8Bz841mVzx/），有几类是我平时用的比较多的，protobuf、fastjosn、jdk自带的方法，这个可以有时间重点了解一下。
优点 | 缺点 | |
Kryo | 速度快，序列化后体积小 | 跨语言支持较复杂 |
Hessian | 默认支持跨语言 | 较慢 |
Protostuff | 速度快，基于protobuf | 需静态编译 |
Protostuff-Runtime | 无需静态编译，但序列化前需预先传入schema | 不支持无默认构造函数的类，反序列化时需用户自己初始化序列化后的对象，其只负责将该对象进行赋值 |
Java | 使用方便，可序列化所有类 | 速度慢，占空间 |
拷贝
1. 聊聊你对java拷贝的认识？什么是深拷贝，什么是浅拷贝？
2. 怎么实现一个java 的深拷贝？
深拷贝和浅拷贝：
Java的拷贝技术在面试中的频率相比于序列化会少点，拷贝要实现的内容是将一个对象赋值一份出来。而对于一个基础类型，深拷贝和浅拷贝是一样的，都会复制一份新的，而对于一个对象类型，如果是浅拷贝的话，那其底层访问的是同一份对象，类似于对该对象起了个别名。而深拷贝的话才是我们真正说的复制，它会重新创建一个新的对象出来，和之前的对象的值一模一样，但是底层的地址是完全不同的。
怎么实现一个java 的深拷贝：
在java中，一个最基本的父类Object中有clone方法，而这个方法是实现浅拷贝的，这是一个native方法。如果我们要想实现深拷贝的话，就需要实现Cloneable接口，并且实现clone方法，如果对象中包含其他对象，其他对象也要实现。下面看下通过clone来实现一个类的拷贝。
1. import lombok.AllArgsConstructor;
2. import lombok.Data;
3. import lombok.NoArgsConstructor;
4. @NoArgsConstructor
5. @AllArgsConstructor
6. @Data
7. public class User implements Cloneable{
8. private String name;
9. private LoginInfo loginInfo;
10.
11. @Override
12. protected Object clone() throws CloneNotSupportedException {
13. User clone= (User)super.clone();
14. //调用底层clone方法重新赋值，不然就是浅拷贝
15. clone.loginInfo =(LoginInfo) clone.getLoginInfo().clone();
16. return clone;
17. }
18.
19. @NoArgsConstructor
20. @AllArgsConstructor
21. @Data
22. public static class LoginInfo implements Cloneable{
23. private String id;
24. private String name;
25. //也要实现clone接口
26. @Override
27. protected Object clone() throws CloneNotSupportedException {
28. return super.clone();
29. }
30. }
31. }
当然除了上面的方式，如果底下对象很多的话，那调用也是相对麻烦过程，我们可以直接new一个对象也可以实现深拷贝，或者通过反序列化的方式来说实现。
反射
1. 介绍一下你了解的反射，反射的原理是什么？
2. 怎么实现一个反射？反射的几种调用方法？区别是什么？
反射原理：
反射是java程序员必须掌握的技能，其类似于给java程序员开了一个后门，我们可以在运行时获取到任何类的信息，包含这个类的属性和方法，而且可以获取private信息，这在一定程度上破坏了面向对象的封装。那么java反射的原理是怎么样的呢？反射的原理基本分为：加载类到jvm -》根据需求查询类的信息。这里面涉及到jvm 中类加载的过程，这也是面试中常见的面试题型，下面我们通过forName来看下反射的原理。
1. public static Class<?> forName(String className)
2. throws ClassNotFoundException {
3. //获取调用者类主要是为了获取到类加载器
4. Class<?> caller = Reflection.getCallerClass();
5. return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
6. }
forName0是一个native方法，该方法会去加载类，类的加载是回调java的双亲加载模型的代码。
1. protected Class<?> loadClass(String name, boolean resolve)
2. throws ClassNotFoundException
3. {
4. synchronized (getClassLoadingLock(name)) {//加锁
5. // 检查类是否已经被加载
6. Class<?> c = findLoadedClass(name);
7. // 双亲委派加载模型
8. if (c == null) {
9. long t0 = System.nanoTime();
10. try {
11. if (parent != null) {
12. c = parent.loadClass(name, false);//使用父类加载
13. } else {
14. c = findBootstrapClassOrNull(name);//尝试使用Java boot加载器
15. }
16. } catch (ClassNotFoundException e) {
17. // ClassNotFoundException thrown if class not found
18. // from the non-null parent class loader
19. }
20. // 双亲加载不成功，自身加载器加载
21. if (c == null) {
22. // If still not found, then invoke findClass in order
23. // to find the class.
24. long t1 = System.nanoTime();
25. c = findClass(name);//使用自身类加载器
26.
27. // this is the defining class loader; record the stats
28. sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
29. sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
30. sun.misc.PerfCounter.getFindClasses().increment();
31. }
32. }
33. if (resolve) {//如果是可链接的，链接指定的类
34. resolveClass(c);
35. }
36. return c;
37. }
38. }
反射的使用：
在java中，我们可以通过以下几种方式动态获取一个类的信息：
1. Class.forName()
2. Object.class
3. Instance.getClass()
1. Class c1 = Class.forName("com.java.base.learn.reflect.ReflectTest");
2. //如果知道类的名字
3. Class c2= ReflectTest.class;
4. //如果对象存在
5. ReflectTest reflectTest = new ReflectTest();
6. Class c3 =reflectTest.getClass();
对于三者的区别是：
Class.forName会加载类，默认会对静态代码块初始化，当然也可以通过参数设置不初始化静态代码块。
Object.Class只返回类的信息，不会做任何初始化的操作。
Instance.getClass() 是返回对象对应的class对象。
可以构建一个含有静态代码块，动态代码块，和构造函数的进行试验。值得注意的是，无论是谁调用，类一旦被加载过，就会重缓存中获取，并不会每次都加载。如果我们需要将获取到的class进行实例的获取，那么会调用到另一个方法Class.newInstance。而newInstance会将类初始化完成，并调用构造函数初始化一个对象出来。这个在后续的jvm 面试题中会重点描述。