反射：在类运行时，能够动态获取并访问其构造结构的机制称为反射机制。
反射是Java中框架设计的核心，通过对类的构造、属性、方法等数据的获取提供抽象的底层构建
反射机制：
反射需要先获得类的class字节码，由JVM类加载器(ClassLoader)负责加载，并在内存中缓存class的内部结构。借助于Java的反射机制允许快速对类的结构数据进行访问和调用
获得class字节码文件的三种方式：
1.Object对象的getClass()方法
获得方式一
Class<User> userClass = (Class<User>) user.getClass();2.类的class静态属性（一个类只有一个class,实例化多次对应的都是同一个class，所以class可以用==进行比较，a.getClass==b.getClass）
获得方式二
Class<User> userClass = User.class;3.Class.forName(String classPath)的加载（反射应用的核心）
获得方式三 通过类路径访问类的Class信息，在不知道类型的情况下，可以不写泛型
Class<User> userClass = (Class<User>) Class.forName("com.igeek.pojo.User");反射允许获取到类的各种构造结构，包括构造方法、方法、属性、接口、注解等
反射能够对类完成实例构建，并能对方法进行实例调用
第三种方法的使用：
Class objClass = Class.forName(“com.igeek.pojo.User”)
Object obj = objClass.newInstance()获取类的构造方法
getConstructor(Class<T>… parameterTypes)
getConstructors()获取类的属性
getField(String fieldName)
getFields()获取类的方法
getMethod(String methodName,Class<T>…parameterType)
getMethods()获取类的接口
getInterfaces()获取类的超类
getSuperclass()XML
Extensible Markup Language 可扩展标记语言
作用：
1.用于对工程进行外部配置
2.用于描述复杂格式的数据，对数据进行存储管理
3.用于跨应用进行数据的交互
每一个XML文件都以标签的方式进行编写，并且必须要有一个跟标签
XML中每个标签都称为节点或元素，标签体的文本也是节点元素，称为文本节点
定义根标签：使用DTD或者是Schema文件来定义XML的内容
解析XML文档主要有两种方式：
1.DOM解析
特点： 将整个XML文档全部加载至内存中，在内存中对文档进行解析
2.SAX解析
特点：使用事件驱动方式进行解析，一边读取一边解析
DOM解析的使用步骤：
1.DOM4j架包导入：
File——Project Structures——Libraries——选择DOM所在的位置——OK
2.创建XML
Setting——Editor——File and Code templates——"+"——名称为“new.xml”——输入“<?xml version="1.0" encoding="UTF-8"?>”——单击"OK"
3.新建文件
新建文件进行new一个new.xml文件
MyInterfaceA
package com.igeek;
public interface MyInterfaceA {
}MyInterfaceB
package com.igeek;
public interface MyInterfaceB {
}Human类
package com.igeek.pojo;
public class Human {
public int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}User类
package com.igeek.pojo;
import com.igeek.MyInterfaceA;
import com.igeek.MyInterfaceB;
//实现了A、B两个接口，继承了Human类
public class User extends Human implements MyInterfaceA, MyInterfaceB {
//三个属性
private int userId;
private String userName;
public String password;
//空参构造方法
public User() {
}
//带参构造方法
public User(int userId, String userName, String password) {
this.userId = userId;
this.userName = userName;
this.password = password;
}
//属性的get 、set方法
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}获取类的方法
package com.igeek;
import com.igeek.pojo.Human;
import com.igeek.pojo.User;
/**
* 获得class文件
* 反射是基于Class类型访问的
* Class对象封装缓存了类的数据结构
*/
public class Demo1 {
public static void main(String[] args) {
User user = new User();
Human human = new User();
//获得方式一：返回值为Class，不写泛型默认为object类型，写了泛型就要进行强转
//将类实例化以后对对象进行获取class处理
Class<User> userClass = (Class<User>) user.getClass();
//获得方式二：不用对类进行实例化，直接对类进行获取class处理
Class<User> userClass = User.class;
//获得方式三 通过类路径访问类的Class信息
try {
//这个方法是因为：这个方法是可以在不明确类型和其结构时使用，
（第一个方法都已经将对象实例化出来了，不需要使用反射。）
Class<User> userClass = (Class<User>) Class.forName("com.igeek.pojo.User");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//上面两种（第一种和第二种获取class方法）方式主要用于多态场景下的类型匹配
if(human instanceof User){
System.out.println("human的实例类型是user类型");
}
if(human.getClass() == User.class){
System.out.println("human的实例类型是user类型");
}
}
}第三种获取class方法的应用：
package com.igeek;
import com.igeek.pojo.User;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 使用反射解析类的数据结构
*/
public class Demo2 {
public static void main(String[] args) {
try {
//获得类的Class对象（第三种方法）,该对象封装了类的数据结构信息
Class objClass = Class.forName("com.igeek.pojo.User");
//使用反射将类进行实例化
//该方式只能通过类的无参构造进行实例化
Object obj = objClass.newInstance();
System.out.println("实例化后的结果："+obj);
//获得类的所有的构造方法：返回值是构造方法的数组 构造方法的类型是Constructor类型
Constructor[] constructors = objClass.getConstructors();
//可获得私有的构造方法
Constructor[] constructors=ObjClass.getDeclareConstructors();
System.out.println("该类有"+constructors.length+"个构造方法");
//遍历所有的构造
for (Constructor constructor : constructors) {
System.out.println("\n-----------------------------");
//获得构造方法的参数数量
int paramCount = constructor.getParameterCount();
System.out.println("构造方法的参数数量："+paramCount);
//获得构造方法的参数类型
Class[] paramClassArray = constructor.getParameterTypes();
for (Class paramClass : paramClassArray) {
System.out.print(paramClass.getName()+"\t");
}
}
System.out.println();
//根据参数获得指定的构造方法
//获得无参的构造
Constructor constructor1 = objClass.getConstructor();
System.out.println(constructor1);
//根据构造方法来实例化对象
Object obj1 = constructor1.newInstance();
System.out.println(obj1);
//获得带参构造方法：通过参数的class获取指定的构造方法
//基本类型和包装类的class是不同的
Constructor constructor2 = objClass.getConstructor(int.class,String.class,String.class);
//使用带参的构造方法实例化对象
//可以用Object接收
Object obj2=constructor2.newInstance(100,"tom","123");
//也可强转后用User接收
User user = (User) constructor2.newInstance(100,"tom","123");
System.out.println(user.getUserId()+"\t"+user.getUserName()+"\t"+user.getPassword());
//获得当前类的父类
Class superClass = objClass.getSuperclass();
System.out.println("\n------------父类------------");
//若结果是Object则这个类没有手动进行extends继承
System.out.println(superClass);
//获取实现的接口
Class[] interfaceClasses = objClass.getInterfaces();
System.out.println("\n---------实现的接口---------");
for (Class interfaceClass : interfaceClasses) {
System.out.println(interfaceClass.getName());
}
//获得属性
//访问当前允许访问（具有访问权限）到的属性，包括父类继承得到的属性
（不同包中加了protect或者加了private或者没加访问修饰符的都没有访问权限）
Field[] fields = objClass.getFields();
//访问当前类（本类）直接声明的属性，不论访问修饰符是什么
Field[] fields = objClass.getDeclaredFields();
System.out.println("\n------------属性-------------");
for (Field field : fields) {
//获得属性的名称
System.out.println("属性名称："+field.getName());
//获得属性的类型
System.out.println("属性类型："+field.getType());
}
System.out.println("\n-------------------------------");
//获得指定名称属性
Field nameField = objClass.getDeclaredField("userName");
//为属性提供访问权限，即使是私有属性也将允许访问处理
nameField.setAccessible(true);
//对属性进行赋值，第一个参数表示该属性从属的对象，第二个参数表示要设置的值
//set方法允许对属性进行赋值，但是会根据属性本身的访问修饰符来决定是否可以成功操作
（paivate时不能被set，但是setAccessible后即可不管是什么访问修饰符都可以进行设置可以访问处理）
nameField.set(user,"jack");
//System.out.println(user.getUserName());
//获取属性的值
Object value = nameField.get(user);
System.out.println(value);
System.out.println("--------------方法的访问-------------");
//获取所有方法，包括私有的
Method[] methods=objClass.getDeclareMethods()；
//获取所有方法
Method[] methods = objClass.getMethods();
for (Method method : methods) {
//获取方法的名称
System.out.println("方法名："+method.getName());
//获取返回值类型
Class returnClass = method.getReturnType();
System.out.println("返回值类型："+returnClass);
//获取方法的参数类型
Class[] paramClassArray = method.getParameterTypes();
System.out.println("方法的参数：");
for (Class paramClass : paramClassArray) {
System.out.println(paramClass);
}
System.out.println("------------------");
}
//获取一个指定名称的方法：第一个参数是方法的名称，第二个参数是参数的类型，可以多个可以一个可以没有
Method setMethod = objClass.getMethod("setUserName", String.class);
//使用反射调用方法（修改原内容）：第一个参数是代表修改的哪个对象中的内容，第二个参数是要修改成的值
setMethod.invoke(user, "admin");
Method getMethod = objClass.getMethod("getUserName");
//调用方法（获得返回值）：返回值是Object类型，如果调用的方法没有返回值，则返回的值null
Object returnValue = getMethod.invoke(user);
System.out.println("返回值是："+returnValue);
} catch (Exception e) {
e.printStackTrace();
}
}
}例子：
使用反射动态解析javax.swing.JFrame类
使用反射实例化该对象
使用反射动态解析该类的构造方法，获得构造方法的参数数量和类型
并使用无参构造以及带有String的构造
方法来实例化JFrame对象
package Demo1;
import java.lang.reflect.Constructor;
public class Demo {
public static void main(String[] args) {
//获取类方法
try {
Object objClass=Class.forName("javax.swing.JFrame");
//使用反射实例化该对象
Object obj=((Class) objClass).newInstance();
System.out.println("实例化后的对象是："+obj);
//使用反射动态解析该类的构造方法，获得构造方法的参数数量和类型
Constructor[] constructors=((Class) objClass).getConstructors();
System.out.println("共有"+constructors.length+"个构造方法");
//获得构造方法的参数数量和类型
for (Constructor constructor : constructors) {
//获取参数数量
int count=constructor.getParameterCount();
System.out.println("该构造方法有"+count+"个参数");
//获取参数类型
Class[] classes=constructor.getParameterTypes();
for (Class aClass : classes) {
System.out.println(aClass.getName()+"\t");
}
}
//使用无参构造
Constructor con1=((Class) objClass).getConstructor();
Object Obj1=con1.newInstance();
System.out.println("无参构造实例化对象是："+Obj1);
//带有String的构造
Constructor con2=((Class) objClass).getConstructor(String.class);
Object Obj2=con2.newInstance("我是一个标题");
System.out.println("带参构造实例化对象是："+Obj2);若是想要获得父类和子类所以的属性，则需要进行递归，先对子类进行属性的获得，然后获得子类的父类，如果不是Object类型，则使用递归将父类传入继续进行属性的获得
XML的使用：
根标签：(user是标签名称， id是标签属性， 1001是标签值， userName和password是标签体的内容)
XML中每个标签都称为节点或元素，标签体的文本也是节点元素，称为文本节点
（紫色标记的都是节点，红色标记的都是文本加点，所以一共11个节点）
框架中灵活处理的内容都要写成配置文件，通过底层代码对配置文件进行解析，解析完成后通过反射进行处理调用
<?xml version="1.0" encoding="UTF-8"?>
//相当于集合存储用户信息
<users>
//用户一
<user id="1001" age=20>
//标签体（标签内容）
<userName>tom</userName>
<password>tom123</password>
</user>
//标签二：用户二
<user id="1002" age=21>
//标签体（标签内容）
<userName>jack</userName>
<password>jack123</password>
</user>
</users>package com.igeek;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.util.List;
/**
* 使用DOM4J对XML文档进行解析
*/
public class Demo3 {
public static void main(String[] args) {
//使用ClassLoader获取资源是在类路径(src文件夹内)中访问的
//System.out.println(Demo3.class.getClassLoader().getResource("").getPath());
//使用类自身Class对象获取资源是在类所在的包路径中访问的
//System.out.println(Demo3.class.getResource("").getPath());
//从类路径中访问文件并将文件转换为输入流
//System.out.println(Demo3.class.getClassLoader().getResourceAsStream("test.xml"));
try {
//创建SAX解析器对象
SAXReader reader = new SAXReader();
//通过获取xml文件的输入流，加载文档
//通过类的class获取classLoader ,在通过classLoader读取文件的输入流
//这个方式是从当前类所在的包中查询test.xml文件
//Document document=reader.read(Dome3.class.getClass().getResourceAsStream("test.xml"));
//这个方式是从整个项目的路径中查询test.xml文件
Document document = reader.read(Demo3.class.getClassLoader().getResourceAsStream("test.xml"));
//获取文档的根节点对象
Element root = document.getRootElement();
//访问节点的名字
System.out.println(root.getName());
//访问节点中的所有下一层子节点
List<Element> list = root.elements();//获取的是数组：所有的节点
//遍历user标签
for (Element element : list) {
System.out.println(element.getName());
//访问标签的所有属性，也可以通过attribute通过名称获取单独的一个属性
List<Attribute> attributeList = element.attributes();//得到的是集合所有的属性
//遍历属性（属性的类型是：Attibute标签的类型是：Element）
for (Attribute attribute : attributeList) {
//获取属性的名称
System.out.print("\t"+attribute.getName()+":");
//获取属性的值
System.out.println(" "+attribute.getValue());
}
//获得指定的userName子标签
Element nameNode = element.element("userName");
System.out.println("\t"+nameNode.getName());
//获取userName的标签体文本：trim是去除空格（如果只是需要查找不需要操作，也可以不用接收直接打印）
String name = nameNode.getTextTrim();
System.out.println("\t\t"+name);
//获取password子标签
Element pwdNode = element.element("password");
System.out.println("\t"+pwdNode.getName());
System.out.println("\t\t"+pwdNode.getTextTrim());
}
} catch (DocumentException e) {
e.printStackTrace();
}
}
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
