3.java基础（三）

遇到过异常吗，如何处理？

1. 捕获异常：使用try-catch语句块来捕获可能出现异常的代码块。在try块中编写可能引发异常的代码，然后通过catch块来捕获特定类型的异常。

2. 处理异常：在catch块中编写异常的处理逻辑，可能包括输出错误信息、日志记录、回滚操作或其他相应的处理。

3. 释放资源：使用finally块来进行清理操作，释放资源，例如关闭打开的文件、数据库连接等，无论是否有异常产生，finally块中的代码都会被执行。如果try块中的代码没有引发异常，finally块直接执行；如果try块中的代码引发了异常，catch块中的代码执行完毕后，也会执行finally块中的代码。

请介绍Java的异常接口

Throwable是异常的顶层父类，代表所有的非正常情况。它有两个直接子类，分别是Error、Exception。

Error是错误，一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢复或不可能捕获，将导致应用程序中断。通常应用程序无法处理这些错误，因此应用程序不应该试图使用catch块来捕获Error对象。在定义方法时，也无须在其throws子句中声明该方法可能抛出Error及其任何子类。

Exception是异常，它被分为两大类，分别是Checked异常和Runtime异常。所有的RuntimeException类及其子类的实例被称为Runtime异常；不是RuntimeException类及其子类的异常实例则被称为Checked异常。Java认为Checked异常都是可以被处理（修复）的异常，所以Java程序必须显式处理Checked异常。如果程序没有处理Checked异常，该程序在编译时就会发生错误，无法通过编译。Runtime异常则更加灵活，Runtime异常无须显式声明抛出，如果程序需要捕获Runtime异常，也可以使用try…catch块来实现。

在finally中return会发生什么？

在通常情况下，不要在finally块中使用return、throw等导致方法终止的语句，一旦在finally块中使用了return、throw语句，将会导致try块、catch块中的return、throw语句失效。

说一说对泛型的理解

集合中有一个缺点，当把对象放入集合中时，集合会忘记这个对象的数据类型，当再次取出该对象时，对象的编译类型就会变成object类型
之所以会这样是因为，集合可以存储各种类型的对象具有很好的通用性，但是这样会出现一些问题
比如：我想创建一个只有dog对象的集合，但是我却可以把cat对象放进去
取出对象的时候只知道是object类型 所以经常要进行强制类型转换，这既增加了复杂度，也容易出错
从Java 5开始，Java引入了泛型的概念，有了泛型以后，程序再也不能“不小心”地把其他对象“丢进”集合中。而且程序更加简洁，集合自动记住所有集合元素的数据类型，从而无须对集合元素进行强制类型转换。

高速缓存知道吗？

高速缓存是指在一定取值范围内，包装类复用对象以提高程序执行效率的机制。比如 Integer 的取值在 -128 到 127 之间时就会复用已有对象。

final、finally 和 finalize 有什么区别？

参考答案：final、finally 和 finalize 从英文字面角度来看，看似很像，实则 3 者在 Java 中没任何关系。final 是用来修饰类、方法、变量和参数的关键字，被 final 修饰的对象不允许修改或替换其原始值或定义；finally 是 Java 中保证重点代码一定要被执行的一种机制；finalize 是 Object 类中的一个基础方法，它的设计目的是保证对象在被垃圾收集前完成特定资源的回收的，但其执行“不稳定”，且有一定的性能问题，已经在 JDK 9 中被设置为弃用的方法了。

普通类和抽象类有哪些区别？

普通类不能包含抽象方法，抽象类可以包含抽象方法。
抽象类不能直接实例化，普通类可以直接实例化。

Java 中 this 和 super 有什么区别？

this 和 super 都是 Java 中的关键字，都起指代作用，当显式使用它们时，都需要将它们放在方法的首行（否则编译器会报错）。this 表示当前对象，super 用来指代父类对象，它们有四点不同：

1.指代对象：super 指代的是父类，是用来访问父类的；而 this 指代的是当前类；
2.查找访问：super 只能查找父类，而 this 会先从本类中找，如果找不到则会去父类中找；
3.本类属性赋值：this 可以用来为本类的实例属性赋值，而 super 则不能实现此功能；
4.配合 synchronized 使用不同：因为 this 表示当前对象，所以this 可用于 synchronized(this){…} 加锁，而 super 则不能实现此功能。

为什么返回类型不同不算方法重载？

JVM 调用方法是通过方法签名来判断到底要调用哪个方法的，而方法签名 = 方法名称 + 参数类型 + 参数个数组成的一个唯一值，这个唯一值就是方法签名。

从方法签名的组成可以看出，返回类型不是方法签名的组成部分，所以不同的返回类型也就不算方法重载了，因为它不能让 JVM 确定要调用的具体方法。

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

1.子类方法的权限控制符不能变小；
2.子类方法返回的类型只能变小；
3.子类抛出异常的类型只能变小；
4.子类方法名必须和父类保持一致；
5.子类方法的参数类型和个数必须和父类保持一致。

什么是动态代理？

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

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

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

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

动态代理和静态代理有什么区别？

静态代理其实就是事先写好代理类，可以手工编写也可以使用工具生成，但它的缺点是每个业务类都要对应一个代理类，特别不灵活也不方便。

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

所以总结来说，动态代理和静态代理的效果都是一样的，但静态代理使用麻烦，而动态代理使用简单，后者也是现在编程中实现代理的主流方式。

如何实现动态代理？

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

JDK Proxy 和 CGLib 有什么区别？

JDK Proxy 和 CGLib 的区别主要体现在以下几个方面：

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

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

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

说一下反射机制？

Java 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。简单来说，反射机制指的是程序在运行时能够获取自身的信息。在 Java 中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。

Java 反射机制主要提供了以下功能，这些功能都位于 java.lang.reflect 包：

在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。
在程序开发中反射的使用场景有很多，比如以下几个。

使用场景一：编程工具 IDEA 或 Eclipse 等，在写代码时会有代码（属性或方法名）提示，就是因为使用了反射；

使用场景二：很多知名的框架，如 Spring、MyBatis 等，为了让程序更优雅更简洁，也会使用到反射。

例如，Spring 可以通过配置来加载不同的类，调用不同的方法，代码如下所示：

<bean id="person" class="com.spring.beans.Person" init-method="initPerson">
</bean>

例如，MyBatis 在 Mapper 使用外部类的 Sql 构建查询时，代码如下所示：

@SelectProvider(type = PersonSql.class, method = "getListSql")
List<Person> getList();
class PersonSql {
    public String getListSql() {
        String sql = new SQL() {{
            SELECT("*");
            FROM("person");
        }}.toString();
        return sql;
    }
}

使用场景三：数据库连接池，也会使用反射调用不同类型的数据库驱动，代码如下所示：

String url = "jdbc:mysql://127.0.0.1:3306/mydb";
String username = "root";
String password = "root";
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, username, password);

问题：如何使用反射？

在 Java 中，反射获取调用类可以通过 Class.forName()，反射获取类实例要通过 newInstance()，相当于 new 一个新对象，反射获取方法要通过 getMethod()，获取到类方法之后使用 invoke() 对类方法进行调用。如果是类方法为私有方法的话，则需要通过 setAccessible(true) 来修改方法的访问限制，以上的这些操作就是反射的基本使用，具体调用如下。

① 反射调用静态方法

Class myClass = Class.forName("com.interview.chapter4.MyReflect");
Method method = myClass.getMethod("调用方法名");
method.invoke(myClass);

② 反射调用公共方法

Class myClass = Class.forName("com.interview.chapter4.MyReflect");
// 创建实例对象（相当于 new ）
Object instance = myClass.newInstance();
Method method2 = myClass.getMethod("调用方法名");
method2.invoke(instance);

③ 反射调用私有方法

Class myClass = Class.forName("com.interview.chapter4.MyReflect");
// 创建实例对象（相当于 new ）
Object object = myClass.newInstance();
Method method3 = myClass.getDeclaredMethod("调用方法名");
method3.setAccessible(true);
method3.invoke(object);

反射有什么优缺点？

优点：

能够运行时动态获取类的实例，大大提高系统的灵活性和扩展性；
与 Java 动态编译相结合，可以实现无比强大的功能；
对于 Java 这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。
缺点：

反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
反射调用方法时可以忽略权限检查，获取这个类的私有方法和属性，因此可能会破坏类的封装性而导致安全问题。

BIO、NIO 和 AIO 有什么区别？

它们三者都是用来实现 IO（Input/Output）操作的，它们的区别如下。

BIO 传统的 java.io 包，它是基于流模型实现的，交互的方式是同步、阻塞方式，也就是说在读入输入流或者输出流时，在读写动作完成之前，线程会一直阻塞在那里，它们之间的调用是可靠的线性顺序。它的优点就是代码比较简单、直观；缺点就是 IO 的效率和扩展性很低，容易成为应用性能瓶颈。
NIO 是 Java 1.4 引入的 java.nio 包，提供了 Channel、Selector、Buffer 等新的抽象，可以构建多路复用的、同步非阻塞 IO 程序，同时提供了更接近操作系统底层高性能的数据操作方式。
AIO 是 Java 1.7 之后引入的包，是 NIO 的升级版本，提供了异步非堵塞的 IO 操作方式，因此人们叫它 AIO（Asynchronous IO），异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。
简单来说：BIO 就是传统 IO 包，产生的最早；NIO 是对 BIO 的改进提供了多路复用的同步非阻塞 IO，而 AIO 是 NIO 的升级，提供了异步非阻塞 IO。