Java中的反射

反射的引入
模块之间有关系—耦合度（高内聚、低耦合）

一、反射的概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

以上的总结就是什么是反射
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
如图是类的正常加载过程：反射的原理在与class对象。
熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

1.反射–解析类，通过字节码对象来获取实例对象的过程

Class—代表类的类（产生对象就是一个具体的类（字节码对象））
Filed—代表属性的类（产生的对象就是一个具体属性）
Method—代表方法的类（产生的对象就是一个具体的方法）
Constructor—代表构造方法的类（产生的对象就是一个具体的构造方法）

2.获取字节码对象的方式

1.通过类型.class来获取字节码对象
2.通过对象.getClass()来获取字节码对象
3.通过class.forName("")把字符串内容转成对应的字节码对象

package cn.tedu.reflect;

import java.util.List;

public class ClassDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.通过类型.class来获取字节码对象
        //String类的字节码对象
       /* Class<String> clz=String.class;
        //接口的字节码对象
        Class<List> clz1=List.class;
        //基本类型的字节码对象
        Class clz2=int.class;
        System.out.println(clz2);*/
        //2.由对象.getClass()来获取字节码对象
        /*Class<String> clz=(Class<String>)"abc".getClass();
        System.out.println(clz);*/
        //3.通过字符串来获取字节码对象
        Class<List> clz=(Class<List>) Class.forName("java.util.List");
        System.out.println(clz);

    }
}

3.获取实例对象

1.字节码对象.newinstance()执行无参构造返回实例对象
2.先获取有参构造，同newintsance(有参)有参形式来执行有参构造，并且给构造方法来赋值，返回实例对象

package cn.tedu.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ClassDemo2 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //字节码对象
        Class<String> clz=String.class;
        //通过字节码对象来获取实例对象
        //执行无参构造来创建实例对象
        //String str=clz.newInstance();
        
        //先获取有参构造---(String original)
        //参数类型需要以字节码对象的形式来传入才能找到对应的构造方法
        //Constructor c=clz.getConstructor(String.class);
        //执行有参构造并且赋值返回实例对象
        /*String str= (String) c.newInstance("abc");
        //
        String str1=new String("abc");
        //
        System.out.println(str);*/
        //通过反射来获取Integer类的实例对象
        //获取字节码对象
        Class<Integer> clz1=Integer.class;
        //获取有参构造---（int）
        Constructor<Integer> c=clz1.getConstructor(int.class);
        //执行有参构造并且给构造方法来赋值返回实例对象
        Integer in= c.newInstance(3);
        System.out.println(in);
    }
}

4.缺点：

1.打破封装原则

package cn.tedu.reflect;

import java.lang.reflect.Field;

public class ClassDemo4 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        //
        Class<String> clz=String.class;
        //获取指定属性--hash
        //获取私有化属性---缺点
        Field field =clz.getDeclaredField("hash");
        //提供实例对象
        String str="bac";
        System.out.println(str.hashCode());
        //改变属性值
        //暴力破解---进行正常的赋值
        field.setAccessible(true);
        //选择str对象的hashcode属性改变值为123
        field.set(str,123);
        //获取属性值
        System.out.println(field.get("abc"));
        System.out.println(str.hashCode());

    }
}

2.跳过泛型的类型检测

package cn.tedu.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ClassDemo7 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //
        List<String> list=new ArrayList<>();
        list.add("abc");
        //在编译时期泛型会有类型检测，如果不符合指定类型就会报错
        //在运行时期反射会改变存储数据元素类型（跳过泛型类型检测）
        Class<List> clz=(Class<List>) list.getClass();
        Method m=clz.getDeclaredMethod("add",Object.class);
        //
        m.invoke(list,123);
        //
        System.out.println(list);
    }
}