反射

Java中的反射

反射是框架的灵魂；
框架是半成品软件，在框架的基础上进行开发，可以简化我们的编码。
什么是反射呢？
反射：将类的各个组成部分封装成其他对象，这就是反射机制
一.获取class对象的方式
1.1.Class.forName(“全类名”)：将字节码文件加载进内存，返回class对象

   String name = "java.lang.String";
   Class c1 = null;
   try {
          c1 = Class.forName(name);
          System.out.println(c1.getName());
      } catch (ClassNotFoundException e) {
  }

这里也通过捕获异常，因为我们传的这个字符串可能不合法，字符串合法命名是类的命名空间和类的名称组成
1.2.类名.class:通过类名的class获取

1.3.对象.getClass():getClass()方法在object类当中定义着

 String name = "Huanglinqing";
 Class c1 = name.getClass();
 System.out.println(c1.getName());

打印结果为：java.lang.String

定义测试类：

```java
public class refulectDemo1 {
	
	/**
	 *  1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象
		2.类名.class:通过类名的class获取
		3.对象.getClass(): getClass()方法在object类当中定义着
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws Exception {
		// 1.Class.forName("全类名")：
		Class class1 = Class.forName("reflect.Person");
		System.out.println(class1);
		
		//2.类名.class:通过类名的class获取
		Class class2 = Person.class;
		System.out.println(class2);
		
		//3.对象.getClass()
		Person person = new Person();
		Class class3 = person.getClass();
		System.out.println(class3);
		
	}

}

进行判断

System.out.println(class1 == class2);
System.out.println(class2 == class3);

输出结果为：true
结论是：同一类加载器加载的文件（*.class）在一次程序运行过程中，只会被加载一次，不论你通过那种方式获取的class对象都是同一个

二、获取类的成员
1.获取成员变量们

1.Field[] getFields() ：获取所有public修饰的成员变量 
2.Field getField(String name)：获取指定名称的
3.Field[] getDeclaredFilds()：获取所有的成员变量，不考虑修饰符
4.Field getDeclaredField(String name)

2.获取构造方法们

1.Constructor<?>[] getConstructors()
2.Constructor<T> getConstructor(类<?>...parameterTypes)
3.Constructor<?>[] getDeclaredConstructors()
4.Constructor<T> getDeclaredConstructors(类<?>...parameterTypes)

3.获取方法名

1.Method[] getMethod()
2.Method getMethod(String name,类<?>... parameterTypes)
3.Method[] getDeclaredMethod()
4.Method getDeclaredMethod(String name,类<?>... parameterTypes)

Field成员变量
1.设置值

void set(Object obj,Object value)

2.获取值

	get(Object obj)

3.忽略安全访问修饰符的安全检查

setAccessible(true) //暴力反射   ---》private

public static void main(String[] args) throws Exception {

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
             1. 获取成员变量们
                 * Field[] getFields()
                 * Field getField(String name)

                 * Field[] getDeclaredFields()
                 * Field getDeclaredField(String name)

         */
        //1.Field[] getFields()获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("------------");
        //2.Field getField(String name)
        Field a = personClass.getField("a");
        //获取成员变量a 的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);

        System.out.println("===================");

        //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);

    }

Constructor访问构造方法
*创建对象
*T newInstance(Object… initarges)
*如果使用空参数构造方法，此操作可以简化：class对象的newInstance方法

public static void main(String[] args) throws Exception {
		//0.获取Person的class对象
		Class personClass = Person.class;

		//因为构造器的方法名称是相同的，不同的是参数列表，所以我们可以根据不同的参数列表来找到构造器
		Constructor constructor = personClass.getConstructor(String.class,int.class);
		System.out.println(constructor);
		//创建对象
		Object perObject = constructor.newInstance("张三",20);
		System.out.println(perObject);
		
		System.out.println("-------------------------------");
	
		Constructor constructor1 = personClass.getConstructor();
		System.out.println(constructor1);
		//创建对象
		Object perObject1 = constructor1.newInstance();
		System.out.println(perObject1);
		
		System.out.println("-------------------------------");
		Object o = personClass.newInstance();
		System.out.println(o);
	}

Method:方法对象
*执行方法
*object invoke(Object object,Object… ages)
*获取方法名称
*String getName:获取方法名

public static void main(String[] args) throws Exception {
		//0.获取Person的class对象
		Class personClass = Person.class;
		
		//获取指定名称的方法,方法无参
		Method eat_method = personClass.getMethod("eat");
		//执行方法
		Person person =new Person();
		eat_method.invoke(person);
		
		//获取指定名称的方法，方法有参
		Method eat_method1 = personClass.getMethod("eat",String.class);
		//执行方法
		eat_method1.invoke(person,"饭");
		
		//获取所有public修饰的方法
		Method[] methods = personClass.getMethods();
		for (Method method : methods) {
			System.out.println(method);
			//获取方法的名称
			String name = method.getName();
			System.out.println(name);
		}
	}

如何创建一个注脚

一个具有注脚的文本。¹

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma (n)=(n-1)!\forall n\in \mathbb{N}$ 是通过欧拉积分

$$\Gamma (z)={\int }_0^{\infty }{t}^{z-1}{e}^{-t}dt.$$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

• 关于 甘特图 语法，参考 这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

这将产生一个流程图。:

• 关于 Mermaid 语法，参考 这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

• 关于 Flowchart流程图 语法，参考 这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

---

1. 注脚的解释 ↩︎