异常、反射、注解知识点
1. Java 中的异常
是 Java 提供的一种处理程序中错误的机制。
当发生异常时，JVM 会将异常封装成一个异常对象抛出。此对象用来描述异常信息。
当 JVM 遇到程序异常就会自动停止。
2. 异常分类
-
Throwable：是 Java 异常的根类，Error 和 Exception 是 Throwable 的子类；
-
Error：是程序无法处理的错误，表示运行程序中较严重的问题，它们在应用程序控制和处理范围之外，而且绝大多数是程序运行时不允许出现的状况（是处理不到的）。
-
Exception：是程序本身可以处理的异常。异常处理通常指针对这种类型异常处理。
-
- RuntimeException：非检查异常（编译器不要求强制处理的异常）【包括 RuntimeException 及其相关子类】
- CheckExcepton：检查异常（编译器要求处理的异常）【包括 IO 异常，SQL 异常等】
3. 异常处理
异常的产生是不可避免的，那么为了保证程序有效地执行，需要对发生的异常进行相应的处理。
Java 的异常处理通过 5 个关键字来实现：try、catch、throw、throws 和 finally。
3.1 捕获
try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码。
-
try：try 块中放可能发生异常的代码。
-
catch：每一个 catch 块用于捕获并处理一个特定的异常，或者这异常类型的子类。
-
finally：finally 块不是必须的，通常是可选的。无论异常是否发生，异常是否匹配被处理，finally 中的代码都会执行。
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; public class TestCatch { public static void main(String[] args) { //捕获异常 try { //可能产生异常的代码 readFile(); } catch (FileNotFoundException e) { //异常的处理逻辑，将异常记录日志，异常封装后显示 System.out.println("系统找不到指定的文件~~~~"); } System.out.println("后续操作代码~~~~"); } public static void readFile() throws FileNotFoundException { InputStream is = new FileInputStream("D:/01.txt"); } }
异常信息的输出方式
- e.getMessage();：打印异常信息
- e.printStackTrace();：打印异常栈信息。
3.2 抛出
throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。
- throw：用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
- throws：运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常。
import java.io.FileNotFoundException;
public class ThrowsEx {
public void setAge(int age) throws FileNotFoundException {
if (age < 0) {
throw new FileNotFoundException("输入的年龄小于 0");
}
}
public static void main(String[] args) {
ThrowsEx te=new ThrowsEx();
try {
te.setAge(10);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
4. 自定义异常
除了 JDK 定义好的异常类外，在开发过程中根据业务的异常情况自定义异常类。
自定义异常步骤：
-
继承某 Exception 类
-
构造方法（可选）
以下为自定义异常的示例代码：
/**
* 自定义异常类
* 用户不存在异常信息类
*/
public class UserNotExistsException extends RuntimeException{
public UserNotExistsException() {
super();
}
public UserNotExistsException(String message) {
super(message);
}
}
5. 常见异常
5.1 运行时异常
| 异常类型 | 说明 |
|---|---|
| ArithmeticException | 算术错误异常，如以零做除数 |
| ArraylndexOutOfBoundException | 数组索引越界 |
| ArrayStoreException | 向类型不兼容的数组元素赋值 |
| ClassCastException | 类型转换异常 |
| IllegalArgumentException | 使用非法实参调用方法 |
| lIIegalStateException | 环境或应用程序处于不正确的状态 |
| lIIegalThreadStateException | 被请求的操作与当前线程状态不兼容 |
| IndexOutOfBoundsException | 某种类型的索引越界 |
| NullPointerException | 尝试访问 null 对象成员，空指针异常 |
| NegativeArraySizeException | 在负数范围内创建的数组 |
| NumberFormatException | 数字转化格式异常，比如字符串到 float 型数字的转换无效 |
| TypeNotPresentException | 类型未找到 |
5.2 非运行时异常
| 异常类型 | 说明 |
|---|---|
| ClassNotFoundException | 没有找到类 |
| IllegalAccessException | 访问类被拒绝 |
| InstantiationException | 试图创建抽象类或接口的对象 |
| InterruptedException | 线程被另一个线程中断 |
| NoSuchFieldException | 请求的域不存在 |
| NoSuchMethodException | 请求的方法不存在 |
| ReflectiveOperationException | 与反射有关的异常的超类 |
6. 反射
JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。
7. 反射相关类
-
java.lang.Class;//包名，修饰符，类名，基类，实现的接口
-
java.lang.reflect.Constructor;//类的构造方法的信息：修饰符，类名，参数列表，抛出的异常
-
java.lang.reflect.Field;//类的属性的信息：修饰符，属性类型，属性名称，属性值
-
java.lang.reflect.Method;//类的方法的信息：修饰符，返回类型，方法名称，参数列表，抛出的异常
-
java.lang.reflect.Modifier;//类提供了用于代表类和成员访问修饰符的静态方法和常量。
8. 获得 Class 方式
8.1 获得基本类型
- 基本类型。class ; 例如：int.class 获取到的是 int 对应的 Class
- 包装器类型。TYPE . 例如：Integer.TYEP , 获取的是 int 对应的 Class
8.2 获得引用类型
- 引用类型。class ; 例如：String.class 获取的是 String 对应的 Class
- Class.forName()
- 通过对象来获取 Class . 例如：obj.getClass()
9. 代理模式
代理 ( Proxy ) 是一种设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。 这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需改修改，可以通过代理的方式来扩展该方法
举个例子来说明代理的作用：假设我们想邀请一位明星，那么并不是直接连接明星，而是联系明星的经纪人，来达到同样的目的。明星就是一个目标对象，他只要负责活动中的节目，而其他琐碎的事情就交给他的代理人（经纪人）来解决。这就是代理思想在现实中的一个例子
9.1 静态代理
静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。
9.1.1 接口
/**
* 接口
*/
public interface IUserDao {
void save();
}
9.1.2 目标对象
/**
* 接口实现
* 目标对象
*/
public class UserDao implements IUserDao {
public void save() {
System.out.println("----已经保存数据！----");
}
}
9.1.3 代理对象
/**
* 代理对象，静态代理
*/
public class UserDaoProxy implements IUserDao{
//接收保存目标对象
private IUserDao target;
public UserDaoProxy(IUserDao target){
this.target=target;
}
public void save() {
System.out.println("开始事务。..");
target.save();//执行目标对象的方法
System.out.println("提交事务。..");
}
}
9.1.4 测试
/**
* 测试类
*/
public class App {
public static void main(String[] args) {
//目标对象
UserDao target = new UserDao();
//代理对象，把目标对象传给代理对象，建立代理关系
UserDaoProxy proxy = new UserDaoProxy(target);
proxy.save();//执行的是代理的方法
}
}
9.1.5 总结
- 可以做到在不修改目标对象的功能前提下，对目标功能扩展。 2. 缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类。同时，一旦接口增加方法，目标对象与代理对象都要维护。
如何解决静态代理中的缺点呢？答案是可以使用动态代理方式。
9.2 动态代理
动态代理有以下特点：
- 代理对象，不需要实现接口
- 代理对象的生成是利用 JDK 的 API ，动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）。
- 动态代理也叫做：JDK 代理，接口代理。
9.2.1 代理工厂
/**
* 创建动态代理对象
* 动态代理不需要实现接口，但是需要指定接口类型
*/
public class ProxyFactory{
//维护一个目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
//给目标对象生成代理对象
public Object getProxyInstance(){
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始事务 2");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务 2");
return returnValue;
}
}
);
}
}
9.2.2 测试
/**
* 测试类
*/
public class App {
public static void main(String[] args) {
// 目标对象
IUserDao target = new UserDao();
// 【原始的类型 UserDao】
System.out.println(target.getClass());
// 给目标对象，创建代理对象
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
// class $Proxy0 内存中动态生成的代理对象
System.out.println(proxy.getClass());
// 执行方法 【代理对象】
proxy.save();
}
}
9.2.3 总结
代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。
使用第三方的 Cglib 方式生成代理对象，不需要目标对象一定实现接口。
10. 注解
Annotation 注解可以看作是 Java 中的一种标记记号，用来给 Java 中的类，成员，方法，参数等元素添加一个写额外的说明信息。
注解可以分为三类：基本注解、元注解、自定义注解。
10.1 基本注解
- @Deprecated：用来说明程序中的某个元素已经不再使用。如果使用的话，编译器会给出警告。
- @SuppressWarnings：用来抑制各种可能出现的警告。
- @Override：用来说明子类覆盖了父类的方法，保护覆盖方法的准确性。
- @SafeVarargs：1.7 新出的注解，用来说明使用了该注解的方法或构造函数不会对 varargs 参数执行可能不安全的操作。
10.2 元注解
元注解也称为元数据注解，是对注解进行标注的注解。
- @Target：用来限制注解的使用范围。
- @Retention：用来说明注解的生存周期。
- @Document：用来说明生成文档的时候是否包含该注解的说明。
- @Inherited：用来说明使用了该注解的父类，其子类会自动继承该注解。
- @Repeatable：1.8 新出的元注解，如果需要在给程序元素使用相同类型的注解，则需将该注解标注上。
- @FunctionalInterface：1.8 新出的元注解，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。
10.3 自定义注解
- @Interface：用来声明注解。
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface UserMessage {
String name() default "tom";
int num() default 0;
String desc();
}