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

沉浸式求职学习

- 1.Java中this和super的区别
- 2.为什么返回类型不算方法重载
- 3.方法重写时需要注意什么问题
- 4.深克隆和浅克隆有什么区别
- 5.如何实现深克隆
- 6.什么是动态代理
- 7.静态代理和动态代理的区别
- 8.如何实现动态代理？
- [9.JDK Proxy 和 CGLib 有什么区别？](#9.JDK Proxy 和 CGLib 有什么区别？)
- 10.动态代理的底层是如何实现的

1.Java中this和super的区别

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

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

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

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

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

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

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

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

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

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

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

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

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

5.如何实现深克隆

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

所有对象都实现克隆方法

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

java 复制代码

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;
        @Override
        protected 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;
        @Override
        protected 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 一个对象，实现代码如下：

java 复制代码

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

java 复制代码

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 有什么区别？

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

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

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