【沉浸式求职学习day43】【Java面试题精选3】

1.Java中this和super的区别

this和super都是java中的关键字，都是指代作用，当显式的调用它们，需要将它们放在方法的首行。

• this是当前类，super是父类
• super只能查父类，this会先从本类中找，如果找不到则去父类中找；
• this可以给本类的实例属性赋值，super不可以
• this可以用synchronized加锁，但是super

2.为什么返回类型不算方法重载

JVM调用方法的时候，是依靠方法签名来判断调用哪个方法的。

其中方法签名=方法名称+参数类型+参数个数组成的一个唯一值

3.方法重写时需要注意什么问题

Java中的方法重写，就是子类重新定义父类已有的方法的过程，它是面向对象编程中多态的具体表现。

但是重写的时候注意以下几个问题：

• 子类方法的权限控制符不可以变小；因为如果父类暴露了一个方法，子类不能把它“藏起来”，否则会破坏面向对象的继承契约。
• 子类方法返回的类型只能变小；（和父类的一致或者是父类返回类型的子类）（协变返回类型）
• 子类抛出异常的类型只能变小
• 子类方法名必须和父类一致
• 子类方法的参数个数和类型必须与父类保持一致

4.深克隆和浅克隆有什么区别

深克隆：将对象中的所有类型，无论是值类型还是引用类型，都复制一份给克隆对象，即深克隆会把原型对象和原型对象所引用的对象都复制一份

浅克隆：把原型对象中的成员变量为值类型的属性复制给克隆对象，把原型对象中的成员变量为引用类型的引用地址也复制给克隆对象，也就是原型对象中如果有成员变量是引用对象，则这个引用对象的地址是共享给原型对象和克隆对象的。所以浅克隆只会复制原型对象，但是不会复制它引用的对象。

主要区别在于：深克隆复制原型对象和它所引用的对象，浅克隆只会复制原型对象

5.如何实现深克隆

• 所有对象都实现克隆方法
• 通过构造方法实现深克隆
• 使用JDK自带的字节流实现深克隆

1. 所有对象都实现克隆方法

这种方式需要让所有引用对象实现克隆（Cloneable接口），代码如下：

public class CloneExample {public static void main(String[] args) throws CloneNotSupportedException {// 创建被赋值对象Address address = new Address(001, "北京");People p1 = new People(1, "Java", address);// 克隆 p1 对象People p2 = p1.clone();// 修改原型对象p1.getAddress().setCity("上海");// 输出 p1 和 p2 地址信息System.out.println("p1:" + p1.getAddress().getCity() +" p2:" + p2.getAddress().getCity());}static class People implements Cloneable {private Integer id;private String name;private Address address;@Overrideprotected People clone() throws CloneNotSupportedException {People people = (People) super.clone();people.setAddress(this.address.clone());// 引用类型克隆赋值return people;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}public People(Integer id, String name, Address address) {this.id = id;this.name = name;this.address = address;}}static class Address implements Cloneable {private Integer id;private String city;@Overrideprotected Address clone() throws CloneNotSupportedException {return (Address) super.clone();}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getCity() {return city;}public void setCity(String city) {this.city = city;}public Address(Integer id, String city) {this.id = id;this.city = city;}}}

​ 2.通过构造方法实现深克隆 《Effective Java》 中推荐使用构造器（Copy Constructor）来实现深克隆

如果构造器的参数为基本 数据类型或字符串类型则直接赋值，如果是对象类型，则需要重新 new 一个对象，实现代码如下：

public class SecondExample {public static void main(String[] args) throws CloneNotSupportedException {// 创建对象Address address = new Address(001, "北京");People p1 = new People(1, "Java", address);// 调用构造函数克隆对象People p2 = new People(p1.getId(), p1.getName(),new Address(p1.getAddress().getId(), 
p1.getAddress().getCity()));// 修改原型对象p1.getAddress().setCity("上海");// 输出 p1 和 p2 地址信息System.out.println("p1:" + p1.getAddress().getCity() +" p2:" + p2.getAddress().getCity());}static class People {private Integer id;private String name;private Address address;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}public People(Integer id, String name, Address address) {this.id = id;this.name = name;this.address = address;}}static class Address {private Integer id;private String city;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getCity() {return city;}public void setCity(String city) {this.city = city;}public Address(Integer id, String city) {this.id = id;this.city = city;}}}

​ 3.使用 JDK 自带的字节流实现深克隆

通过 JDK 自带的字节流实现深克隆的方式，是先将要原型对象写入到内存中的字节流，然后再从这个字 节流中读出刚刚存储的信息，来作为一个新的对象返回，那么这个新对象和原型对象就不存在任何地址 上的共享，这样就实现了深克隆，代码如下：

import java.io.*;public class ThirdExample {public static void main(String[] args) throws CloneNotSupportedException {// 创建对象Address address = new Address(001, "北京");People p1 = new People(1, "Java", address);// 通过字节流实现克隆People p2 = (People) StreamClone.clone(p1);// 修改原型对象p1.getAddress().setCity("上海");// 输出 p1 和 p2 地址信息System.out.println("p1:" + p1.getAddress().getCity() +" p2:" + p2.getAddress().getCity());}static class StreamClone {public static <T extends Serializable> T clone(People obj) {T cloneObj = null;try {// 写入字节流ByteArrayOutputStream bo = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bo);oos.writeObject(obj);oos.close();// 分配内存,写入原始对象,生成新对象ByteArrayInputStream bi = new 
ByteArrayInputStream(bo.toByteArray());//获取上面的输出字节流ObjectInputStream oi = new ObjectInputStream(bi);// 返回生成的新对象cloneObj = (T) oi.readObject();oi.close();} catch (Exception e) {e.printStackTrace();}return cloneObj;}}static class People implements Serializable {private Integer id;private String name;private Address address;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}public People(Integer id, String name, Address address) {this.id = id;this.name = name;this.address = address;}}static class Address implements Serializable {private Integer id;private String city;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getCity() {return city;}public void setCity(String city) {this.city = city;}public Address(Integer id, String city) {this.id = id;this.city = city;}}}

此方式需要注意的是，由于是通过字节流序列化实现的深克隆，因此每个对象必须能被序列化，必须实 现 Serializable 接口，标识自己可以被序列化，否则会抛出异常 (java.io.NotSerializableException)。

6.什么是动态代理

动态代理指的是，程序运行期间，动态的创建目标对象的代理对象，并且对目标对象中的方法能够进行功能性增强的一种技术

生成代理对象的过程中，目标对象不变，代理对象中的方法是对目标对象方法的增强方法。可以理解为运行期间，对象中方法的动态拦截，再拦截方法的前后执行功能操作，

动态代理的常见使用场景：

• 统计每个api请求耗时
• 统一的日志输出
• 校验被调用的api是否已经登录和权限鉴定
• Spring AOP

7.静态代理和动态代理的区别

静态代理就是事先写好代理类，缺点是每个业务都得对应一个代理类，不够灵活方便

动态代理是在程序运行期间，动态创建目标的代理对象。

效果一样，但是静态代理使用麻烦，动态代理更简单也更主流。

8.如何实现动态代理？

在 Java 中，实现动态代理的常用方式是 JDK Proxy 和 CGLib

9.JDK Proxy 和 CGLib 有什么区别？

1. JDK Proxy 是 Java 语言自带的功能，无需通过加载第三方类实现；
2. Java 对 JDK Proxy 提供了稳定的支持，并且会持续的升级和更新 JDK Proxy，例如 Java 8 版本中 的 JDK Proxy 性能相比于之前版本提升了很多；
3. JDK Proxy 是通过拦截器加反射的方式实现的；
4. JDK Proxy 只能代理继承接口的类；
5. JDK Proxy 实现和调用起来比较简单；
6. 6CGLib 是第三方提供的工具，基于 ASM 实现的，性能比较高；
7. CGLib 无需通过接口来实现，它是通过实现子类的方式来完成调用的

10.动态代理的底层是如何实现的

不同的动态代理的底层实现是不同的，比如 JDK Proxy 底层是通过反射技术实现的，而 CGLib 是基于 ASM，一个 Java 字节码操作框架实现的。