异常、反射

异常处理、反射、注解、泛型

一、异常处理

1.异常介绍

Throwable是异常体系的根，它继承自Object。Throwable有两个体系：Error和Exception

Error（错误）是系统中的错误，程序员是不能改变的和处理的，是在程序编译时出现的错误，只能通过修改程序才能修正。一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止

OutOfMemoryError：内存耗尽
NoClassDefFoundError：无法加载某个Class
StackOverflowError：栈溢出

Exception（异常）表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常（程序逻辑编写不对造成的，应该修复程序本身）

ArrayIndexOutOfBoundsException  数组越界时抛出的异常，下标超出了数组的范围

ClassCastException          试图将对象强制转换为不是实例的子类时，抛出该异常

IllegalArgumentException    抛出的异常表明向方法传递了一个不合法或不正确的参数

NoSuchElementException      表明枚举中没有更多的元素

NullPointerException        当应用程序试图在需要对象的地方使用 null 时，抛出该异常
							

2.捕获异常

捕获异常使用try…catch语句，把可能发生异常的代码放到try {…}中，然后使用catch捕获对应的Exception及其子类：

 	try{
            int[] a = {1,2};
            System.out.println(a[2]);
        }catch (ArrayIndexOutOfBoundsException e ){
            e.printStackTrace();
            System.out.println("数组越界");
        }

		try{
            int[] a = {1,2};
            System.out.println(a[2]);
        }catch (NullPointerException e ){
            e.printStackTrace();
            System.out.println("数组越界");
        }


	try{
            int[] a = {1,2};
            System.out.println(a[2]);
        }catch (Exception e ){
            e.printStackTrace();
            System.out.println("数组越界");
        }

我们通常捕获所有异常的父类Exception
在能确定异常的情况下使用多 catch 块来捕获异常来明确异常信息

 	try{
            int[] a = {1,2};
            System.out.println(a[2]);
        }catch (ArrayIndexOutOfBoundsException e ){
            e.printStackTrace();
            System.out.println("数组越界");
        }catch (NullPointerException e ){
            e.printStackTrace();
            System.out.println("空指针异常");
        }catch (NumberFormatException  e ){
            e.printStackTrace();
            System.out.println("数值转换异常");
        }catch (Exception e ){
            e.printStackTrace();
            System.out.println("异常");
        }
        由于只有一个异常被捕获 所以多个catch语句只有一个能被执行（父级异常写在下面）

finally块用来保证一些代码必须执行

 	try{
            int[] a = {1,2};
            System.out.println(a[2]);
        }catch (Exception e ){
            e.printStackTrace();
            System.out.println("异常");
        }finally{
			System.out.println("结束");
		}
     

3.抛出异常

1.创建某个Exception的实例；

 		NullPointerException e = new NullPointerException();
        throw e;

2.用throw语句抛出；

 		throw new NumberFormatException("null");

4.自定义异常

通常会创建一个类并集成BaseException，然后派生出各种业务类型的异常。
BaseException继承自RuntimeException，继承多个构造方法，这样抛出异常的时候，就可以选择合适的构造方法

public class Demo extends BaseException {

    public Demo (String module, String code, Object[] args, String defaultMessage) {
        super(module, code, args, defaultMessage);
    }

    public Demo (String module, String code, Object[] args) {
        super(module, code, args);
    }

    public Demo (String module, String defaultMessage) {
        super(module, defaultMessage);
    }

    public Demo (String code, Object[] args) {
        super(code, args);
    }

    public Demo (String defaultMessage) {
        super(defaultMessage);
    }
}

BaseException需要从一个适合的Exception派生，通常建议从RuntimeException派生

5.断言

主要使用在代码开发和测试时期，用于对某些关键数据的判断，如果这个关键数据不是你程序所预期的数据，程序就抛出AssertionError异常提出警告或退出（默认关闭）

public class AssertionDemo {  
    //这个成员变量的值可以变，但最终必须还是回到原值5  
    static int i = 5;  
    public static void main(String[] args) {  
        assert i==6;  
        System.out.println("如果断言正常，我就被打印");  
    }  
}

6.日志

在JDK 1.3及以前，Java打日志依赖System.out.println(), System.err.println()或者Exception的printStackTrace()方法来实现，现在常用的日志框架有JDK Logging、Log4j、SLF4J、Logback

通常一个类只有一个 LOG 对象，如果有父类可以将 LOG 定义在父类中

使用JDK Log进行日志打印操作如下

public class Main {
    public static void main(String[] args) {
    	Logger log= Logger.getLogger(this.getName());
        log.info("start...");
        log.fine("end.");
    }
}

使用Java标准库内置的Logging一旦开始运行，就无法修改配置所以Java标准库内置的Logging使用并不是非常广泛

log4j

Log4j的配置一般放在文件里（log4j.properties、log4j.xml）
由三个重要的组成构成：日志记录器(Loggers)，输出端(Appenders)和日志格式化器(Layout)

1.Logger：控制要启用或禁用哪些日志记录语句，并对日志信息进行级别限制
2.Appenders : 指定了日志将打印到控制台还是文件中
3.Layout : 控制日志信息的显示格式

### 设置###
log4j.rootLogger = debug,stdout,D,E

### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

Log4j中将要输出的Log信息定义了5种级别，依次为DEBUG、INFO、WARN、ERROR和FATAL

日志级别	描述
OFF 关闭	最高级别 不输出日志
TRACE 跟踪	输出更细致的程序运行轨迹
DEBUG 调试	输出更细致的对调试应用有用的信息
INFO 信息	输出应用运行过程的详细信息
WARN 警告	输出可能潜在的危险状况
ERROR 错误	输出错误，但应用还能继续运行
FATAL 致命	输出非常严重的可能会导致应用程序终止的错误
ALL 所有	输出所有级别信息

	private static final Logger logger= LoggerFactory.getLogger(this.getClass());
		 // 记录debug级别的信息    
        logger.debug("This is debug message.");    
        // 记录info级别的信息    
        logger.info("This is info message.");    
        // 记录error级别的信息    
        logger.error("This is error message."); 

Slf4j、Logback

Slf4j 也是现在主流的日志门面框架，使用 Slf4j 可以很灵活的使用占位符进行参数占位，简化代码，拥有更好的可读性.
Logback 是 Slf4j 的原生实现框架，同样也是出自 Log4j 一个人之手，但拥有比 log4j 更多的优点、特性和更做强的性能，现在基本都用来代替 log4j 成为主流

SLF4J的日志采用接口传入的形式 而且增加了可以带占位符的字符串写法，用后面的变量自动替换占位符

int score = 99;
p.setScore(score);
logger.info("Set score {} for Person {} ok.", score, p.getName());

二、反射

1.概念

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2.Class

创建的每一个类也都是对象，即类本身是java.lang.Class类的实例对象，这个实例对象称之为类对象，也就是Class对象，jvm中有很多的实例，每个类都有唯一的Class对象.

一个类被加载到内存并供我们使用需要经历三个阶段 加载、链接、初始化.

所有的类都是在对其第一次使用时，动态加载到JVM中的（懒加载），因此java程序程序在它开始运行之前并非被完全加载，其各个类都是在必需时才加载的,在类加载阶段，类加载器首先检查这个类的Class对象是否已经被加载如果尚未加载，默认的类加载器就会根据类的全限定名查找.class文件

获取class的方式有三种

1.Class.forName(“类的全限定名”)
2.实例对象.getClass()
3.类名.class （类字面常量）

package com.cry;
class Cat {
    static {
        System.out.println("Loading Cat");
    }
}
public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println("inside main");
        Class c1 = Cat.class;
        Class c2= Class.forName("com.cry.Cat");
        Class c3=new Cat().getClass();
        System.out.println(c1==c2);
        System.out.println(c2==c3);
        System.out.println("finish main");
    }
}
/*　Output:
inside main
-------
Loading Cat
true
true
finish main
 */

获取数据

class SysUsers{
    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void ToString(String data){
        System.out.println(data);
    }
}
public void Test() throws Exception {
        SysUser sysUser = new SysUser();
        sysUser.setUserName("demo");
        Class cls = sysUser.getClass();
        Field field = cls.getField("userName"); //包括父类
        System.out.println(field.getName());//返回字段名称
        System.out.println(field.getType());//返回字段类型
        System.out.println(field.getModifiers()); //返回字段的修饰符，它是一个int
        Field field_02 = cls.getDeclaredField("userName"); //不包括父类，但可获取私有字段
        Field[] fields = cls.getFields();
        Field[] fields_02 = cls.getDeclaredFields();
        //field.setAccessible(true); //设置允许访问私有字段权限 可能会失败
        System.out.println(field_02.get(cls));
        field_02.set(field_02,"demo02");
        System.out.println(field_02.get(cls));

    }
/*　Output:
		userName
		class java.lang.String
		2
		demo
		demo2
 */

setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager，那么它会根据规则进行检查，有可能阻止setAccessible(true)。例如，某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true)，这样可以保证JVM核心库的安全

方法

public void Test02() throws Exception {
        SysUsers sysUser = new SysUsers();
        sysUser.setUserName("demo");
        Class cls = SysUsers.class;
        Method method = cls.getMethod("ToString",String.class); //包括父类
        System.out.println(method.getName()); //返回方法名称
        System.out.println(method.getReturnType());//返回返回值类型
        System.out.println(method.getParameterTypes()[0]);//返回方法的参数类型
        System.out.println(method.getModifiers());//返回方法的修饰符，它是一个int
        Method method_02 = cls.getDeclaredMethod("ToString",String.class); //不包括父类，但可获取私有方法
        Method[] methods = cls.getMethods();
        Method[] methods_02 = cls.getDeclaredMethods();
        method_02.setAccessible(true); //设置允许访问私有方法权限 可能会失败
        method.invoke(cls.newInstance(),"demo");

 		//静态方法 获取Integer.parseInt(String)方法，参数为String:
        Method m = Integer.class.getMethod("parseInt", String.class);
        // 调用该静态方法并获取结果:
        Integer n = (Integer) m.invoke(null, "12345");
    }
/*　Output:
		ToString
		void
		class java.lang.String
		1
		demo
 */

		Class i = Integer.class;
        Class n = i.getSuperclass();
        System.out.println(n);
        Class o = n.getSuperclass();
        System.out.println(o);
        System.out.println(o.getSuperclass());
/*　Output:
		class java.lang.Number 
		class java.lang.Object 
		null 
 */

动态代理

JDK动态代理就是要生成一个包装类对象，由于代理的对象是动态的，所以叫动态代理。由于我们需要增强，这个增强是需要留给开发人员开发代码的，因此代理类不能直接包含被代理对象，而是一个InvocationHandler，该InvocationHandler包含被代理对象，并负责分发请求给被代理对象，分发前后均可以做增强