全栈面试题】模块3-9】JavaSE高级 -- Object类、 GC、反射、Socket

面试题3.62 JAVA中Object类中有哪些常用方法？

面试题3.63 什么是深拷贝和浅拷贝

面试题3.64 GC是什么? 为什么要有GC?

面试题3.65 JVM垃圾回收机制和常见算法

面试题3.66 简单的介绍⼀下强引用，软引用，弱引用，虚引用

面试题3.67 什么是java内存泄漏，什么是内存溢出，怎么预防？

面试题3.68 什么是java反射机制？哪些地方用到了？

面试题3.69 获取Class对象有几种方式?

面试题3.70 Java创建对象有几种方式

面试题3.71 知道类的加载过程吗

面试题3.72 知道哪些类加载器

面试题3.73 什么是双亲委派模型

面试题3.74 BIO，NIO，AIO 有什么区别?

面试题3.75 java8新特性

面试题3.76 请说说你知道的设计模式？

面试题3.77 TCP和UDP的区别

面试题3.78 TCP三次握手和四次挥手

面试题3.79 Socket是什么？

面试题3.62 JAVA中Object类中有哪些常用方法？

【技术难度：2 出现频率：1 】

第一层：

1.getClass()获取类的class对象；

2.hashCode()获取对象的hashCode值，子类可重写以自定义；

3.equals()比较对象是否相等，默认用==比较两个对象的内存地址，子类可重写以自定义；

4.clone()克隆方法，子类可重写以自定义，深克隆需要手动深度克隆对象中的目标内容；

5.toString()返回对象16进制的内存地址的哈希值以及类名等信息，子类可重写以自定义；

6.notify()随机选择一个在该对象上调用wait方法的线程，解除其阻塞状态；

7.notifyAll()解除所有在该对象上调用wait方法的线程的阻塞状态；

8.wait()导致当前线程进入等待状态，直到他被其他线程通过notify()或者notifyAll()唤醒；

9.finalize()对象被GC回收时调用，只调用一次。

拓展：

wait():当一个线程调用某个对象的wait()方法时，该线程会释放该对象的锁并进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法。
调用wait()的线程必须首先获得该对象的锁（即，它必须在同步代码块或同步方法中）。
wait()方法可以被重载，允许指定一个超时时间，在超时后线程会自动从等待状态返回。
notify():notify()方法用于唤醒正在等待该对象锁的单个线程。
如果有多个线程在等待，选择哪一个线程被唤醒是随机的，或者说是不可预测的。
被唤醒的线程将尝试重新获得唤醒对象手中的锁。
notifyAll():notifyAll()方法用于唤醒正在等待该对象锁的所有线程。
所有被唤醒的线程将竞争该对象的锁，其中一个线程将获得锁并继续执行，而其他线程将继续等待。

第二层：

notify()、notifyAll()、wait()方法只能在同步方法或同步块内部调用。如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常。

面试题3.63 什么是深拷贝和浅拷贝

【技术难度： 2 出现频率：1 】

1.深拷贝和浅拷贝是针对对象和数组这样的引用类型，包装类和String类对象的值是不可变的，无需拷贝；

2.浅拷贝只克隆当前对象本身，而不克隆它成员变量指向的对象，新旧对象的成员变量还是指向堆中相同数据；

3.深拷贝会深度克隆对象中所有内容，修改新对象不会影响原对象。

扩展(无需背诵)：

面试题3.64 GC是什么? 为什么要有GC?

【技术难度：3 出现频率：2 】

GC是垃圾收集的意思，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显式操作方法。

扩展(无需背诵)：

GC - Gabage Collection 垃圾收集。

内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃。

面试题3.65 JVM垃圾回收机制和常见算法

【技术难度：3 出现频率：2 】

第一层：

理论上来讲Sun公司只定义了垃圾回收机制规则而不局限于其实现算法，因此不同厂商生产的虚拟机采用的算法也不尽相同。GC在回收对象前首先必须发现那些无用的对象，此时会通过搜索算法去发现定位这些无用的对象。搜索到无用对象之后就是回收过程，再通过回收算法进行回收。

垃圾算法的实现涉及大量的程序细节，而且不同的虚拟机平台实现的方法也各不相同。

第二层：

常用的搜索算法有这些：

1）引用计数器算法（废弃）

引用计数器算法是给每个对象设置一个计数器，当有地方引用这个对象的时候，计数器+1，当引用失效的时候，计数器-1，当计数器为 0 的时候，JVM 就认为对象不再被使用，是“垃圾”了。引用计数器实现简单，效率高；但是不能解决循环引用问问题（A 对象引用 B 对象，B 对象又引用 A 对象，但是A，B对象已不被任何其他对象引用），同时每次计数器的增加和减少都带来了很多额外的开销，所以在 JDK1.1 之后，这个算法已经不再使用了。

2）根搜索算法（使用中）

根搜索算法是通过一些“GC Roots”对象作为起点，从这些节点开始往下搜索，搜索通过的路径成为引用链（Reference Chain），当一个对象没有被 GC Roots 的引用链连接的时候，说明这个对象是不可用的。

GC Roots 对象包括：

a) 虚拟机栈（栈帧中的本地变量表）中的引用的对象。

b) 方法区域中的类静态属性引用的对象。

c) 方法区域中常量引用的对象。

d) 本地方法栈中 JNI（Native 方法）的引用的对象。

第三层：

常用的回收算法如下：

1）标记—清除算法（Mark-Sweep）（DVM 使用的算法）

标记—清除算法包括两个阶段：“标记”和“清除”。在标记阶段，确定所有要回收的对象，并做标记。清除阶段紧随标记阶段，将标记阶段确定不可用的对象清除。标记—清除算法是基础的收集算法，标记和清除阶段的效率不高，而且清除后回产生大量的不连续空间，这样当程序需要分配大内存对象时，可能无法找到足够的连续空间。

2）复制算法（Copying）

复制算法是把内存分成大小相等的两块，每次使用其中一块，当垃圾回收的时候，把存活的对象复制到另一块上，然后把这块内存整个清理掉。复制算法实现简单，运行效率高，但是由于每次只能使用其中的一半，造成内存的利用率不高。现在的 JVM 用复制方法收集新生代，由于新生代中大部分对象（98%）都是朝生夕死的，所以两块内存的比例不是 1：1(大概是 8：1)。

3）标记—整理算法（Mark-Compact）

标记—整理算法和标记—清除算法一样，但是标记—整理算法不是把存活对象复制到另一块内存，而是把存活对象往内存的一端移动，然后直接回收边界以外的内存。标记—整理算法提高了内存的利用率，并且它适合在收集对象存活时间较长的老年代。

4）分代收集（Generational Collection）

分代收集是根据对象的存活时间把内存分为新生代和老年代，根据各个代对象的存活特点，每个代采用不同的垃圾回收算法。新生代采用复制算法，老年代采用标记—整理算法。

面试题3.66 简单的介绍⼀下强引用，软引用，弱引用，虚引用

【技术难度： 2 出现频率： 1 】

除了强引用，软、弱、虚引用需要配合对应的类使用，他们的区别在于被GC回收的时机不同。

扩展(无需背诵)：

强引用 User user = new User();

软引用 SoftReference<User> user = new SoftReference<>( new User());

弱引用 WeakReference<User> user = new WeakReference<>(new User());

虚引用
PhantomReference<User> pr = new PhantomReference<User>(new User()，ReferenceQueue);

面试题3.67 什么是java内存泄漏，什么是内存溢出，怎么预防？

【技术难度： 3 出现频率：1 】

内存泄露是指无用对象持续占用内存没有释放，仿佛泄漏掉了一部分内存，这就称为内存泄漏。
内存溢出是指申请内存时，没有足够的内存可以使用。内存泄露的增多，最终会导致内存溢出。

预防这些问题一方面是从代码层面进行优化完善，另一方面可以优化JVM的配置。

从代码层面进行优化完善的思路有很多，比如以下这些情况：

1.尽早释放无用对象的引用，好的办法是使用临时变量的时候，让引用变量在退出活动域后自动设置为null；如在调用close()来关闭对象后，主动将其设置为null。

2.进行字符串处理时，尽量避免使用String，而应使用StringBuffer或StringBuilder；

3.尽量少用静态变量，因为静态变量是全局的，存在方法区，GC不会回收；

4.避免集中创建对象，尤其是大对象，应尽量运用对象池技术、IO流操作以提高系统性能，否则JVM会突然需要大量内存，这时会触发GC优化系统内存环境；

5.生命周期长的对象中引用生命周期短的对象时容易引发内存泄漏，比如大集合对象拥有大数据量的业务对象的时候，可以考虑分块进行处理然后解决一块释放一块的策略；

6.不要在经常调用的方法中创建对象，尤其忌讳在循环中创建对象，可以适当的使用hashtable，vector创建一组对象容器，然后从容器中去取这些对象，而不用每次new之后又丢弃；

7.各种连接不用了应及时调用close()关闭，JDBC、IO、Socket等；

8.当我们把自己定义的类保存到散列表的时候，要保证对象的hashCode不可变，否则散列表的remove()方法无法根据hashCode删除正确对象。

memory leak - 内存泄露

out of memory - 内存溢出

JVM参数调优：

堆内存大小：

        -Xms表示堆内存初始内存空间

        -Xmx表示堆内存最大内存空间

新生代内存大小：

        -XX:newSize表示新生代初始内存空间（应小于-Xms的值）

        -XX:MaxnewSize表示新生代最大内存空间（这个值应该小于-Xmx的值）

方法区内存大小：

        -XX:PermSize表示方法区初始内存空间

        -XX:MaxPermSize表示对非方法最大内存空间

面试题3.68 什么是java反射机制？哪些地方用到了？

【技术难度： 2 出现频率：2 】

反射允许java在运行时动态获取类中的资源。这使得java编码变得更加灵活；
比如使用JDBC连接数据库时，使用Class.forName()通过反射加载数据库的驱动程序。比如说Spring框架对象的创建，都是通过反射来完成，我们在配置文件中，定义类的依赖关系，并制定类的全路径，就是为反射创建对象提供信息。

面试题3.69 获取Class对象有几种方式?

【技术难度： 1 出现频率：1 】

1. Class.forName(全类名) ；//Class类的forName()静态方法

2.类名.class；

3.对象名.getClass()。

面试题3.70 Java创建对象有几种方式

【技术难度： 1 出现频率： 1 】

调用构造方法的有：

1.new关键字

2.反射

不调用构造方法的有：

3.克隆方法clone()

4.反序列化

面试题3.71 知道类的加载过程吗

【技术难度： 3 出现频率：2 】

第一层：

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三步来实现对这个类进行初始化。

第二层：

加载、连接、初始化简单说是这样：

1. 加载是将class文件读入内存获取它的二进制字节流，并为之创建一个Class对象；

2. 连接再细分为验证、准备、解析三步；

3. 初始化是在类首次被“主动使用”时执行初始化，为类变量赋予正确的初始值。

第三层：

1.任何类被使用时JVM都会建立并且只建立一个Class对象；

2.连接再细分为验证、准备、解析三步详细说是这样：

先验证字节码文件的字节流是否符合当前虚拟机的要求，接着准备是为类变量分配内存并设置默认值，之后解析是将字节码文件中常量池的符号引用转换为直接引用的过程（主要针对类或接口、字段、类方法、方法类型等）。

面试题3.72 知道哪些类加载器

【技术难度： 3 出现频率： 2 】

第一层：

JVM 中内置了三个重要的类加载器，除了启动类加载器其他类加载器均由Java实现且全部继承自java.lang.ClassLoader。

第二层：

接下来详细说说这些类加载器：

1.启动类加载器是最顶层的加载类，由C++实现，负责加载 %JAVA_HOME%/lib ⽬录下的jar包和类，或是被 -Xbootclasspath 参数指定的路径中的所有类；

2.扩展类加载器主要负责加载⽬录 %JRE_HOME%/lib/ext ⽬录下的jar包和类，或被java.ext.dirs系统变量所指定的路径下的jar包；

3.应⽤程序类加载器是⾯向我们⽤户的加载器，负责加载当前应⽤classpath下的所有jar。

扩展(无需背诵)：

ClassLoader - 类加载器

BootstrapClassLoader - 启动类加载器

ExtensionClassLoader - 扩展类加载器

AppClassLoader - 应⽤程序类加载器

面试题3.73 什么是双亲委派模型

【技术难度： 3 出现频率：2 】

双亲委派模型能够保证多个加载器加载某个类时，最终都是由一个加载器加载，确保最终加载结果相同。

原理是这样：

0.检查是否已加载：当一个类加载器（假设为C）被请求加载某个类时，它首先会检查这个类是否已经被加载过了（即是否已经存在于其命名空间中）。如果已加载，就直接返回这个类的Class对象，避免重复加载。

1.当需要加载一个类的时候，子类加载器并不会马上去加载，而是依次去请求父加载器加载，一直往上找，直到最高的类加载器——启动类加载器；

2.当启动类加载器还加载不了的时候，才依次往下让子类加载器进行加载；

3.当到达最底层的时候，如果还是加载不到该类，就会抛出ClassNotFoundException异常。

面试题3.74 BIO，NIO，AIO 有什么区别?

【技术难度：3 出现频率：1 】

第一层：

1.BIO是一个连接一个线程；

2.NIO是一个请求一个线程；

3.AIO是一个有效请求一个线程。

第二层：

BIO (Blocking I/O)：

BIO是同步阻塞的，实现模式为一个连接一个线程，即当有客户端连接时，服务器端需为其单独分配一个线程，如果该连接不做任何操作就会造成不必要的线程开销(当然可以通过线程池机制改善)。

BIO是传统的Java io编程，其相关的类和接口在java.io 包下。

优点是编程简单，缺点是无法处理⼗万甚⾄百万级连接，仅适用于活动连接数于⼩于单机 1000的业务场景。

NIO (Non-blocking或New I/O)：

NIO是同步非阻塞的，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

NIO提供了与传统 BIO 模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和ServerSocketChannel 两种不同的套接字通道实现，两种通道都⽀持阻塞和⾮阻塞两种模式。阻塞模式比较简单，但是性能和可靠性都不好；⾮阻塞模式正好与之相反。对于低负载、低并发的应⽤程序，可以使⽤同步阻塞 I/O 来提升开发速率和更好的维护性；对于⾼负载、⾼并发的（⽹络）应⽤，应使⽤ NIO 的⾮阻塞模式来开发

AIO (Asynchronous I/O)：

AIO是异步非阻塞的，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由操作系统先完成，之后再通知服务器应用启动线程进行处理。

AIO 也就是 NIO 2。在 Java 7 中引⼊了 NIO 的改进版 NIO 2，它是异步⾮阻塞的 IO 模型。异步 IO 是基于事件和回调机制实现的，应⽤操作之后会直接返回，不会堵塞，当后台处理完成，操作系统会通知相应的线程进⾏后续的操作。AIO 是异步 IO 的缩写，虽然 NIO 在⽹络操作中，提供了⾮阻塞的⽅法，但是 NIO 的 IO ⾏为还是同步的。对于 NIO 来说，业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程⾃⾏进⾏ IO 操作，IO 操作本身是同步的。⽬前来说 AIO 的应⽤还不是很⼴泛，Netty 框架(简化网络编程流程)之前也尝试使⽤过 AIO，不过在后来又放弃了。

面试题3.75 java8新特性

【技术难度：1 出现频率：1 】

接口中可以添加default默认方法、Lambda表达式、函数式接口、Stream数据流、Optional类以及全新的时间包等。

面试题3.76 请说说你知道的设计模式？

【技术难度：2 出现频率：1 】

第一层：

比如Spring中使用到的设计模式，

先说说单例、原型、代理模式：

单例模式，在Spring中最明显的使用场景是在配置文件中配置注册bean对象的时候设置scope的值为singleton，让目标类只创建一个实例,目的是节省内存；
原型模式，也叫克隆模式，Spring中该模式使用的很明显，和单例一样在bean标签中设置scope的属性为prototype即表示该bean以克隆的方式生成，基于clone()方法需要注意深拷贝浅拷贝问题；
代理模式，比如在Spring的AOP面向切面编程就有用到，有两种代理方案，一是基于接口的JDK动态代理，二是基于字节码文件生成子类来代理的CGLIB，具体是这样：

如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP；
如果目标对象实现了接口，可以强制使用CGLIB实现AOP；
如果目标对象没有实现接口，必须采用CGLIB，Spring会自动在JDK动态代理和CGLIB之间转换。

第二层：

然后再看模板、观察者、工厂：

模板模式，核心是父类定义好流程，然后将流程中需要子类实现的方法就抽象话留给子类实现，Spring中的JdbcTemplate（JDBC模板）就是这样的实现。我们知道jdbc的步骤是固定的(加载驱动，获取连接通道，构建sql语句，执行sql语句，关闭资源)，在这些步骤中第3步和第四步是不确定的，所以就留给客户实现，而我们实际使用JdbcTemplate的时候也确实是只需要构建SQL就可以了.这就是典型的模板模式。
观察者模式，它定义的是对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。使用比较场景是在监听器中而spring中Observer模式常用的地方也是listener的实现。如ApplicationListener。
工厂模式分两种，

简单工厂模式就是通过工厂根据传递进来的参数决定产生哪个对象。Spring中我们通过getBean方法获取对象的时候根据id或者name获取就是简单工厂模式了。

工厂方法模式，在Spring中我们一般是将Bean的实例化直接交给容器去管理的，实现了使用和创建的分离，这时容器直接管理对象，还有种情况是，bean的创建过程我们交给一个工厂去实现，而Spring容器管理这个工厂。这个就是我们讲的工厂模式，在Spring中有两种实现，一种是静态工厂方法模式，一种是动态工厂方法模式。

第三层：

以及适配器、装饰者、策略模式是这样：

适配器模式是将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。这就是适配器模式。在Spring中在AOP实现中的Advice和interceptor之间的转换就是通过适配器模式实现的。
装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。

spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

具体的使用在Spring session框架中的SessionRepositoryRequestWrapper使用包装模式对原生的request的功能进行增强，可以将session中的数据和分布式数据库进行同步，这样即使当前tomcat崩溃，session中的数据也不会丢失。