佛山格尔做网站的公司宣传推广计划怎么写
目录
一、定义
二、获取class对象的三种方式
1、Class.forName("全类名")
2、类名.class
3、对象.getClass()
三、案例
1、获取 class 反射对象三种方式
2、利用反射获取构造方法
3、利用反射获取成员变量
4、利用反射获取成员方法
Java反射是一种强大的编程机制，它允许程序在运行时检查和操作类、接口、字段和方法等元素。
一、定义
Java反射是指在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能被称为Java语言的反射机制。（反射允许对成员变量，成员方法和构造方法的信息进行编程访问）
二、获取class对象的三种方式
1、Class.forName("全类名")
源代码阶段使用 Class.forName("") 方式获取反射对象。
2、类名.class
当类名加载到了内存中，使用 类名.class 方式获取class反射对象。
3、对象.getClass()
当内存中 new 了一个类对象，处于运行阶段。则使用 对象.getClass() 方式获取反射对象。
三、案例
1、获取 class 反射对象三种方式
假设我们有 Student 对象
package com.angindem.myreflect1;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Student {private String name;private int age;public Student(String name, int age) {this.name = name;this.age = age;}
}
代码案例：
package com.angindem.myreflect1;public class MyReflectDemo1 {public static void main(String[] args) throws ClassNotFoundException {/*** 获取class对象的三种方式:* 1.Class.forName("全类名")* 2.类名.class* 3.对象.getClass()*/
// 1.第一种方式
// 全类名： 包名 + 类名
// 最为常用的Class sClass1 = Class.forName("com.angindem.myreflect1.Student");System.out.println(sClass1);
// 2.第二种方式
// 一般更多的是当作参数进行传递Class sClass2 = Student.class;System.out.println(sClass2);System.out.println(sClass1 == sClass2);
// 3.第三种方式
// 当我们已经有了这个类的对象时，才可以使用Student s = new Student("angindem", 18);Class sClass3 = s.getClass();System.out.println(sClass3);System.out.println(sClass1 == sClass3);}
}
2、利用反射获取构造方法
假设我们有 Student 对象
package com.angindem.myreflect2;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
public class Student {private String name;private int age;private Student(String name, int age) {this.name = name;this.age = age;}public Student() {}public Student(String name) {this.name = name;}protected Student(int age) {this.age = age;}
}
代码案例：
package com.angindem.myreflect2;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;public class MyReflectDemo {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {/*** Class 类中用于获取构造方法的方法* Constructor<?>[] getConstructors()* Constructor<?>[] getDeclaredConstructors()* Constructor<?> getConstructor(Class<?>... parameterTypes)* Constructor<?> getDeclaredConstructor(Class<?>... parameterTypes)** Constructor类中用于创建对象的方法* T newInstance(Object... initargs)* setAccessible(boolean flag)*/// 1、获取 class 字节码文件对象Class<?> clazz = Class.forName("com.angindem.myreflect2.Student");// 2、获取所有公有构造器
// Constructor<?>[] cons = clazz.getConstructors();
// for (Constructor<?> con : cons){
// System.out.println(con);
// }// 3、获取所有构造器（包括私有、受保护、默认、公有）
// Constructor<?>[] cons = clazz.getDeclaredConstructors();
// for (Constructor<?> con : cons){
// System.out.println(con);
// }// 4、获取单个的构造器Constructor<?> con1 = clazz.getDeclaredConstructor();
// System.out.println(con1);Constructor<?> con2 = clazz.getDeclaredConstructor(String.class);
// System.out.println(con2);Constructor<?> con3 = clazz.getDeclaredConstructor(int.class);
// System.out.println(con3);
//Constructor<?> con4 = clazz.getDeclaredConstructor(String.class, int.class);
// System.out.println(con4);// 获取权限修饰符
// int modifiers = con4.getModifiers();
// System.out.println(modifiers);// 获取参数个数，获取参数的类型
// Parameter[] parameters = con4.getParameters();
// for (Parameter parameter : parameters) {
// System.out.println(parameter);
// }// 通过反射构建对象，参数类型要符合构造函数的参数类型
// 小细节： getDeclaredConstructor 只能获取当前类中的构造器相关信息，当类中的构造器私有时，则无法进行调用
// 需要通过 setAccessible(true) 设置为 true，临时取消访问权限限制con4.setAccessible(true); // 这种方式也称为：暴力反射Student stu = (Student) con4.newInstance("angindem", 18);System.out.println(stu);}
}扩展：关于 Modifier 的 常量字段值
| 修饰符 | 值 | 十六进制表示 | 描述 |
| public | 1 | 0x0001 | 表示该成员（类、方法、字段等）对所有类都可见。 |
| private | 2 | 0x0002 | 表示该成员只能在定义它的类内部访问。 |
| protected | 4 | 0x0004 | 表示该成员在定义它的类、同一包中的类以及所有子类中可见。 |
| default | 0 | 0x0000 | 表示该成员在定义它的类和同一包中的类中可见（没有显式修饰符）。 |
| abstract | 1024 | 0x0400 | 表示该类是抽象类，不能被实例化。 |
| final | 16 | 0x0010 | 表示该类不能被继承，或者该方法不能被重写，或者该字段是常量。 |
| interface | 512 | 0x0200 | 表示该类是一个接口。 |
| static | 8 | 0x0008 | 表示该字段或方法是静态的，属于类本身而不是类的实例。 |
| transient | 128 | 0x0080 | 表示该字段在序列化时不会被序列化。 |
| volatile | 64 | 0x0040 | 表示该字段的值可能会被多个线程同时访问，每次访问都需要从主内存中读取。 |
| synchronized | 32 | 0x0020 | 表示该方法是同步的，同一时间只能被一个线程访问。 |
| native | 256 | 0x0100 | 表示该方法是本地方法，其实现用非 Java 语言编写。 |
3、利用反射获取成员变量
假设我们有 Student 对象
package com.angindem.myreflect3;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Student {private String name;private int age;public String gender;public Student(String name, int age, String gender) {this.name = name;this.age = age;this.gender = gender;}
}
代码案例：
package com.angindem.myreflect3;import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;public class MyReflectDemo {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {/*** Class 类中用于获取成员变量的方法* Field[] getFields() 返回所有公有成员变量对象的数组* Field[] getDeclaredFields() 返回所有成员变量对象的数组* Field getField(String name) 返回一个公有成员变量对象* Field getDeclaredField(String name) 返回一个成员变量对象** Field 类中用于创建对象的方法* void set(Object obj,Object value) 为成员变量赋值* Object get(Object obj) 获取成员变量的值*/// 1、获取 class 字节码文件对象Class<?> clazz = Class.forName("com.angindem.myreflect3.Student");// 2、获取公有的成员变量
// Field[] fields = clazz.getFields();
// for (Field field : fields){
// System.out.println(field);
// }// 3、获取所有成员变量(包括 私有的)
// Field[] fields = clazz.getDeclaredFields();
// for (Field field : fields){
// System.out.println(field);
// }// 获取单个成员的变量Field name = clazz.getDeclaredField("name");System.out.println(name);// 获取成员变量的权限修饰符int modifiers = name.getModifiers();System.out.println(modifiers);// 获取成员变量的名称String n = name.getName();System.out.println(n);// 获取成员变量的类型Class<?> type = name.getType();System.out.println(type);// 获取成员变量的值Student stu = new Student("angindem", 18, "男");name.setAccessible(true); // 暴力反射：临时取消访问权限Object value = name.get(stu);System.out.println(value);// 修改对象里面记录的值name.set(stu, "ang");System.out.println(stu);}
}4、利用反射获取成员方法
假设我们有 Student 对象
package com.angindem.myreflect4;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Student {private String name;private int age;public Student(String name, int age) {this.name = name;this.age = age;}public void sleep(){System.out.println("sleep睡觉");}private void eat(String food){System.out.println("在吃 " + food);}
}
代码案例：
package com.angindem.myreflect4;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class MyReflectDemo1 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {/*** Class 类中用于获取成员方法的方法* Method[] getMethods() 返回所有的公有成员方法对象的数组，包括父类中的* Method[] getDeclaredMethods() 返回所有的成员方法对象的数组，不包括父类中的* Method getMethod(String name,Class<?>... parameterTypes) 返回一个公有成员方法对象* Method getDeclaredMethod(String name,Class<?>... parameterTypes) 返回一个成员方法对象** Method类中用于创建对象的方法* Object invoke(Object obj,Object... args) 运行方法* 参数一：用 obj 对象调用该方法* 参数二：调用方法的传递的参数（如果没有就不写）* 返回值：方法的返回值（如果没有就不写）* 获取方法的修饰符* 获取方法的名字* 获取方法的形参* 获取方法的返回值* 获取方法的抛出的异常*/
// 1、获取 class 字节码文件对象Class<?> clazz = Class.forName("com.angindem.myreflect4.Student");// 2、获取里面所有的方法对象(包含父类中所有的公共方法)
// Method[] methods = clazz.getMethods();
// for (Method method : methods) {
// System.out.println(method);
// }// 3、获取里面所有的方法对象(不能获取父类的，但是可以获取本类中私有的方法)
// Method[] methods = clazz.getDeclaredMethods();
// for (Method method : methods) {
// System.out.println(method);
// }
// 获取指定的单一方法Method m = clazz.getDeclaredMethod("eat", String.class);System.out.println(m);
// 获取方法的修饰符int modifiers = m.getModifiers();System.out.println(modifiers);
// 获取方法的名字String name = m.getName();System.out.println(name);
// 获取方法的形参Class<?>[] parameterTypes = m.getParameterTypes();for (Class<?> parameterType : parameterTypes){System.out.println(parameterType);}
// 获取方法的抛出异常Class<?>[] exceptionTypes = m.getExceptionTypes();for (Class<?> exceptionType : exceptionTypes){System.out.println(exceptionType);}
// 获取方法的返回值Class<?> returnType = m.getReturnType();System.out.println(returnType);/** Method类中用于创建对象的方法* Object invoke(Object obj,Object... args) 运行方法* 参数一：用 obj 对象调用该方法* 参数二：调用方法的传递的参数（如果没有就不写）* 返回值：方法的返回值（如果没有就不写）*/Student s = new Student();
// 参数一s：表示方法的调用者
// 参数“汉堡包”：表示在调用方法的时候传递的实际参数m.setAccessible(true);String result = (String) m.invoke(s, "汉堡包");System.out.println(result);}
}