导读：很多优秀的高级框架都是通过反射完成的，反射的重要性，由此可见一斑。反射机制可以使得程序更加灵活，只有学习好反射的基础语法，这样才能自己写出优秀的框架。好了一起打卡学习吧，别忘记了素质三连哦！
往期精彩回放:一文搞定Java的输入输出流等常见流
文章目录
- 反射机制有什么作用？
- java语言中反射机制可以操作字节码文件。
- 优点:可以直接读和修改字节码文件。通过反射机制可以操作class文件。
- 反射在框架中使用很多，掌握它，你注定不凡。
- 在java.lang.reflect.*;包下。
- 反射机制相关重要的类：
- java.lang.Class：代表字节码，代表一个类型（整个类）。
- java.lang.reflect.Method：代表字节码中的方法字节码（类中的方法）
- java.lang.reflect.Constructor：代表字节码中的构造方法字节码（类中的构造方法）
- java.lang.reflect.Field:代表字节码中的属性字节码。（类中的静态变量和成员变量）
- 要操作一个类的字节码，需要首先获取到这个类的字节码，那如何获取java.lang.Class实例呢？
- 有三种方式：
- 第一种：class.forName（“ ”）方法：静态方法，方法的参数是一个字符串（完整的类名），不能省略包。返回一个Class类型.（lang.class字节码文件）。使用这个方法会加载类到JVM,使static静态代码块执行（只执行一次），如果你只想让程序执行static静态代码块，只用这个方法就好了。（重点，JDBC中会用）
- 第二种：getClass()方法，任何一个对象都有这个方法。(返回字节码文件）同一个类的对象返回的java.lang.Class字节码相同（所指的地址相同）。
- 第三种：java语言中任何一中类型，包括基本数据类型，他都有.class属性。例如：
- Class x = String.class;
- Class a = int.class;
- 通过反射机制，获取Class,通过Class来实例化对象.
- newInstance()方法：创建一个和之前反射相同类型的对象，会自动调用类的无参构造方法。没有无参构造方法，会报异常。（JDK8之后过时了，不过现在主要用的就是JDK8,sun公司长期支持JDK8和JDK11）
- 举个栗子：
package Day2; public class ReflectTest1 { public static void main(String[] args) { Class s1 = null; try { //通过反射机制获取Class s1= Class.forName("Day2.User"); } catch (ClassNotFoundException e) { e.printStackTrace(); } Object a=null; try { a =s1.newInstance();//用反射获得的Class,创建一个对象 System.out.println(a); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } } class User{ public User() { System.out.println("无参构造方法！"); } } - 使用反射机制创建对象有什么作用呢？
- 反射机制让程序更加灵活。
- java代码写一遍，在不改变java源代码的基础上，可以做到不同对象的实例化。（符合OCP原则:对外开放，修改关闭。)
- 高级框架：底层实现原理：采用了反射机制。
- 举个栗子：（使用IO流，properties集合，通过属性文件来实例化对象）（重点）
package Day2; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.Properties; public class ReflectTest2 { public static void main(String[] args) throws Exception { //通过IO流读取flie.properties文件 FileReader reader = new FileReader("file.properties"); //创建属性类对象(Properties对象，Map集合，key和value都是字符串类型 Properties pro = new Properties(); //将文件中的数据加载到Map集合中加载 pro.load(reader); reader.close();//这个流不能在没加载数据之前就关闭了 //通过key获取value String a = pro.getProperty("ClassName"); Class bb = Class.forName(a);//反射获得Class Object c = bb.newInstance();//通过Class,新建一个对象 System.out.println(c); } } class User1 { public User1() { System.out.println("无参构造方法！"); } } - 如何获取类路径下文件的绝对路径？
- 为什么聊这个？因为上述代码可能换一个位置，当前路径名就失效了，（即移植性差)所以我们的聊聊这个。
- 使用以下通用方式，这个文件必须保存在类路径下，（即src目录下)。
- String path = Thread.currentThread().getContextClassLoader().getResource(" ").getPath();(重点）使用这个方法可以获取文件的绝对路径。（适用于各种操作系统）
- 哈哈，看不懂?别急解释一下上述程序：
- Thread.currentThread()当前线程对象
- getContextClassLoader()使对象的方法，可以获取当前线程的类加载器对象。
- getResource()这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
- 示例：
public class Path1 { public static void main(String[] args) { String path = Thread.currentThread().getContextClassLoader().getResource("File2").getPath(); System.out.println(path); } } - 从执行结果可以看出：源文件和字节码文件存放在不同的位置，执行后与之对应的文件保存在out/production目录下（IDEA中）。
- 直接以流的方式读取文件，省去获取绝对路径的环节。
- InputStream reader = Thread.currentThread().getContextClassLoader().getResoutceAsStream("文件名“（类路径下））
- 举个栗子：
package Day2; import java.io.InputStream; import java.util.Properties; public class Path2 { public static void main(String[] args) throws Exception { //创建一个流，读取文件 InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("File2"); //创建一个Properties集合，保存数据 Properties pro = new Properties(); pro.load(reader);//将文件数据加载到集合中 reader.close(); String f =pro.getProperty("NewName"); Class bb = Class.forName(f);//反射获得Class Object cc = bb.newInstance();//通过Class实例化对象 System.out.println(cc); } } class User2 { public User2() { System.out.println("无参构造方法！"); } } - 资源绑定器（重点）
- 在java.util包下，便于获取属性配置文件的内容。
- 使用这种方式也必须将属性配置文件放置类路径下。
- 只能绑定xxx.properties文件。并且不用写路径的扩展名。
- 此方法简洁简单。所以，以后就用这个方法就好了，集合配合流的方法就不需要用了。
- 举个栗子：
import java.util.ResourceBundle; public class Path3 { public static void main(String[] args) { ResourceBundle bundle = ResourceBundle.getBundle("File2"); String Name = bundle.getString("NewName"); System.out.println(Name); } } - 反射属性之前，应该获取整个类。（Class.forName(" ")方法获取。)
- 获取整个类中的所有的Field。
- **getFields()方法；用之前获取的整个类调用；**其获取所有public修饰的属性，返回到Field[]数组中。
- **getDeclaredFields()方法；获取所有属性。**不受修饰符现在，返回到Field[]数组中。
- getName()方法：可以获取属性名字。对于类也有名字，也用这个方法，对于反射获得的类还有simpleName()方法，来获取简单名字。
- **getType()方法：获取属性的类型，返回值为类，**然后我们再通过这个得到的类用getName方法获取属性类型的名字。
- getModifiers()方法：获取属性的修饰符列表，返回的是int类型，每个修饰符的数字是，修饰符的代号。我们可以用toString方法（Modifier.toString),Modefier为reflect的子类，返回一个字符串类型。
- 举个栗子：
package Day1; import java.lang.reflect.Field; import java.lang.reflect.Modifier; public class FieldTest1 { public static void main(String[] args) { Class First=null; try { First = Class.forName("Day1.Student"); } catch (ClassNotFoundException e) { e.printStackTrace(); } Field[] fields = First.getDeclaredFields(); System.out.println(fields.length); for(Field arg:fields) { int a = arg.getModifiers(); System.out.println(Modifier.toString(a));//Modefier为reflect的子类 Class ff = arg.getType(); System.out.println(ff.getName()); System.out.println(arg.getName()); } } } class Student{ public String name; private int age; protected double scroe; boolean flag; } - 通过反射机制，反编译一个类的属性Field
- 怎么通过反射机制访问对象属性？（赋值，获取属性的值）
- 首先获取整个Class。
- 然后通过Class实例化对象。
- 获取对象的属性；依据名字。
- 属性.set（对象,222)方法：以获取的属性调用，给对象的属性赋值。
- 反射机制代码复杂，但灵活。
- 读取属性的值：属性.get(对象）。
- 举个栗子:
package Day1; import java.lang.reflect.Field; public class FieldTest2 { public static void main(String[] args) { Class fio = null;//获取Class Object ff = null; { try { fio = Class.forName("Day1.Student"); ff = fio.newInstance();//实例化对象 } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } } //获取属性 Field fl = null; { try { fl = fio.getDeclaredField("name");//通过类获取属性，无法通过对象获取 } catch (NoSuchFieldException e) { e.printStackTrace(); } } //给fio对象的fl属性赋值 try { fl.set(ff,"sfdsa"); } catch (IllegalAccessException e) { e.printStackTrace(); } //获取属性的值 try { System.out.println(fl.get(ff)); } catch (IllegalAccessException e) { e.printStackTrace(); } } } - 可以用上述方法访问私有属性吗？
- 不可以？当时我们可以用：属性.setAccessible(true)方法打破封装。
- 因此安全性差。
反射Mothod
- 首先获取Class。
- 获取所有的Method方法。
- Method[] methods=类.getDeclaredMethod();方法:获取所有的Method.
- 获取方法的返回值类型：方法.getReturnType().getSimpleName();
- 获取修饰符列表：Modifer.toString(方法.getModifiers()；
- 获取方法参数的类型：方法.getParameterTypes()；返回Class[]数组。再调用getSimpleName()即可。
- Mothod的反编译（不要求掌握，有兴趣的小伙伴可以自行了解一下）
- 通过反射机制怎么调用对象的方法。（重点）
- 1.获取Calss，并用Calss实例化对象。
- 2.获取Method:使用Method logMethod = 类.getDeclaredMethod("方法名“，类型名.class,类型名.class);方法。
- 3.调用方法：（对象，方法名，参数，返回值）
- Object value = 方法.invoke("对象”，“参数值”，“参数值”）；invoke方法返回一个Object类型。
- 举个栗子：
package Day1; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class MethodTest1 { public static void main(String[] args) { Class fos =null; try { fos = Class.forName("Day1.Student1");//获取Class } catch (ClassNotFoundException e) { e.printStackTrace(); } Object fis =null; try { fis = fos.newInstance();//创建对象 } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } Method method =null; try { method = fos.getDeclaredMethod("GetScore",String.class,double.class);//获取方法 } catch (NoSuchMethodException e) { e.printStackTrace(); } Object value = null; try { value = method.invoke(fis,"jia",520);//调用方法 } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } System.out.println(value); } } class Student1{ private String name; private int age; private double score; public String GetScore(String name,double score){ if(score>500){ System.out.println("恭喜成功！"); } else { System.out.println("继续加油！"); } return name; } } - 反射机制的优点：让代码具有通用性，可变化的内容都是写到配置文件中，将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，但是java代码不需要做任何修改。非常的灵活。
- 反射机制怎么调用构造方法？
- 使用反射机制创建对象？
- 1.调用无参构造方法。（newInstance方法)
- 2.调用有参构造方法（也可以用这种方法调用无参构造方法）。
- 第一步：先获取这个有参构造方法；Constructor con = 类.getDeclaredConstructor(int.class,String.classs)第二步：调用构造方法new对象。Object aa =con.newInstance(参数列表）。
- 举个栗子：
package Day1; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; public class ConstructorTest1 { public static void main(String[] args){ Class fio=null; Constructor con=null; Object cc = null; try { //获取类Class fio = Class.forName("Day1.Student3"); //获取构造方法，参数很重要 con =fio.getDeclaredConstructor(int.class,String.class); cc= con.newInstance(11,"Jia");//调用构造方法new对象，这种方法没有过期 } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } //输出对象 System.out.println(cc);//自动调用toString方法 } } class Student3{ private int age; private String name; //构造方法 public Student3() { } public Student3(int age, String name) { this.age = age; this.name = name; System.out.println("调用成功！"); } } - 1.获取类的Class
- 2.获取Class父类：Class superClass = 子类.getSuperclass();
- 获取子类实现的所有接口：Class[] interfaces = 子类.getInterfaces();方法。
- 举个栗子：
package Day1; public class SuperClassTest1 { public static void main(String[] args){ Class fos =null; Class superClass=null; try { //获取类的Class fos= Class.forName("Day1.Student5"); //获取父类的Class superClass = fos.getSuperclass(); //实例化父类对象 Object cc = superClass.newInstance(); System.out.println(cc); //获取子类的所有接口 Class[] interfaces = superClass.getInterfaces(); for(Class ff : interfaces){ //获取接口的简称，即不含包名 System.out.println(ff.getSimpleName()); } } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } } } //学生类 class Student5 extends Parents{ private int age; private String name; //构造方法 public Student5() { } public Student5(int age, String name) { this.age = age; this.name = name; System.out.println("调用成功！"); } } //家长类 class Parents implements Study,Sport{ public Parents() { super(); } } //接口 interface Study{ } interface Sport{ } - 什么是类加载器？
- 专门负责加载类的命令/工具。
- ClassLoader
- JDK中自带了3个类加载器
- 启动类加载器（加载jre\lib\rt.jar)父
- 扩展类加载器（母）
- 应用类加载器
- 假设有这样一段代码：
- String s = “abc”;
- 代码在开始执行之前，会将所需要的类全部加载JVM。看到以上代码，类加载器会找到String.class文件，找到就加载，那么是怎么进行加载的呢？
- 首先通过：启动类加载器”加载。
- rt.jar中都是Jdk最基本的核心类库。
- 如果通过“启动类加载器"加载不到的时候：会通过”扩展类加载器“加载。
- 注意：扩展类加载器专门加载：jre\lib\ext*.jar
- 如果扩展类加载器没有加载到，那么会通过“应用类加载器”加载。
- 应用类加载器:classpath中的jar包的类。（class文件）
- java中为了保证类加载的安全，使用了双亲委派机制。
- 优先从启动类，（父）然后是扩展类（母），最后是应用类加载器。
- int…args:这就是可变长度参数。个数为0到N个。
- 可变长只能在参数的最后一个，且只能有一个。
- 可变成长度参数可以当做数组看待，具有length属性，有下标，调用的时候可以传一个数组。
- 注解：或者叫做注释（Annotation)
- 注解有什么作用？
- 对程序的注释。
- 注解是一个引用数据类型。编译之后也是生成xxx.class文件。
- 怎么自定义注解呢？语法格式是怎么样的？
- [修饰符列表] @interface 注解类型名{
}
- [修饰符列表] @interface 注解类型名{
- 注解怎么使用，用在什么地方？
- 注解使用时语法格式时：@注解类型名
- 可以用在构造方法，类，属性，接口，方法，注解等，注解可以修饰注解。
- 自定义注解：
- 如果注解中有属性，必须给其赋值。可以在注释的时候@注解名(属性=值），属性名为value时并且只有一个属性的时候，注解的时候可以不写value。定义属性的时候后面需要小括号，可以用default给属性赋默认值。
- 注解的属性可以是哪些类型？
- byte,short,int, long,double,boolean,char,float,String,枚举，Class类型，和其数组类型。如果数组中只有一个元素给其赋值时大括号可以省略。
- 什么是元注解？
- 用来标注“注解类型”的注解。
- 常见的元注解：
- Target注解：（用来标注，被注解的注解可以出现在哪个位置上，其由后面的小括号参数决定。）如：@Target({ElementType.Type,ElementType.MEYHOD})只允许该注解标注类，方法
- Retention注解:用来标注“被注解的注解”最终保存在哪里。
- @Retention(RetentionPolicy,SOURCE)表示只被保留在java源文件中。
- @Retention（RetentionPolicy,CLASS)class文件中。
- @Retention（RetentionPolicy,RUNTIME）class文件中，并能被注解。//RetentionPolicy是一个枚举类型。
- JDK内置的注解。
- java.lang包下：
- 1.Override注解：只能注解方法，只给编译器参考。如果这个方法不是重写父类的方法，编译器报错。（标识性注解）
- 2.Deprecated注解：表示某个类，方法已过时。为了告知别人某个类，方法等已过时。
如何获取注解类的属性？
1.获取类Class
* Class dd = Class.forName(“完整类名”);
2.判断类上面是否存在特定的注解。
* if(dd(类).isAnnotationPresent(注解类名.class)
3.如果存在特定的注解，则获取注解对象。
* 注解类名 fs = (注解类名）dd.getAnnotation(注解类名.class);
4.获取注解对象的属性。
* 注解对象.属性（）；
如果获取方法上的注解信息？
1.获取类Class。
2.获取方法。
3.判断方法上是否存在该注解。存在的话，获取方法上的注解。调用方式为:方法.getAnnotation(注解类名.class)
4.再通过得到的注解获得属性。
注解在开发中的使用场景：
举个栗子：假设存在一个注解，只能出现在类上面；当这个类有这个注解：类必须有int类型的属性，否则报异常。
原创不易，码字不易，点个赞再走吧！
往期精彩回放:一文搞定Java的输入输出流等常见流
