反射的知识点
1：什么是反射
反射是框架完成的核心。那什么又是框架呢？框架是一个半完成品的程序，在开发项目的时候可以直接拿来用。用于提高效率
反射就是把java类中的各个成分映射成一个个的java对象。
2：获取反射的Class
注意：java中，无论生成每个类的多少个对象，这些对象都会对应于同一个Class对象。(一个类的字节码指挥被加载一次)
从上述分析可知，任意一个字码节都会通过ClassLoader类加载器，加载到JVM内存中，以Class对象的形式存在。
常见的获取Class对象的方式有三种：
| 第一种 | Class.forName("类路径") |
| 第二种 | 类名.class |
| 第三种 | 对象.getClass(); |
public class Test {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// 第一种：根据user类路径获取user的反射对象
Class<?> aClass = Class.forName("demo4.User");
System.out.println(aClass);
// 第二种：根据类名获取user类的反射对象
Class<User> userClass =User.class;
System.out.println(userClass);
// 通过类对象获取类的反射对象
User user = new User();
Class<? extends User> aClass1 = user.getClass();
System.out.println(aClass1);
//判断是否为同一个Class对象
System.out.println(aClass==userClass);
System.out.println(userClass==aClass1);
}
}
class User{
private String users;
private Integer pwd;
public String getUsers(){
return users;
}
public void setUsers(String users){
this.users=users;
}
public Integer getPwd() {
return pwd;
}
public void setPwd(Integer pwd) {
this.pwd = pwd;
}
}
结果展示：
3：通过反射获取反射类对象
通过Class类对象，调用newiInstance()
public class Test {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<User> aClass2 =(Class<User>)Class.forName("demo4.User");
// 通过反射类的到对应的类对象---之前的方式：new USer 来获取User类的对象
User user1 = aClass2.newInstance();
User user2 = aClass2.newInstance();
System.out.println(user2==user1);
System.out.println(user1);
}
}
class User{
private String users;
private Integer pwd;
public String getUsers(){
return users;
}
public void setUsers(String users){
this.users=users;
}
public Integer getPwd() {
return pwd;
}
public void setPwd(Integer pwd) {
this.pwd = pwd;
}
}
spring根据你传递的类路径--得到该类的反射类---并通过newInstance（）创建类对象
4：获取反射类中的属性成员对象
字节码中的属性成员被加载到内存中后会以Field类对象的形式存在。如何获取Field属性对象，可通过以下几种方式：
1.获取本类中指定的属性对象
反射类.getDeclaredField("属性名")
2.获取本类以及父类中指定的public修饰的属性
反射类.getField("属性名")
3.获取本类中所有的属性对象
反射类.getDeclaredFields("属性名")
4.获取本类以及父类中所有public修饰的属性
反射类.getFields("属性名")
public class Test2 {
public static void main(String[] args) throws NoSuchFieldException {
// 获取docter反射类
Class<Docter> docterClass = Docter.class;
// 获取反射类中的成员对象
Field[] declaredFields = docterClass.getDeclaredFields();//获取本类中的所有属性对象
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
System.out.println("=================");
Field[] fields = docterClass.getFields();//获取本类以及父类中的public对象
for (Field field : fields) {
System.out.println(field);
}
Field x = docterClass.getField("y");
System.out.println(x);
}
}
class People{
private String x;
public String y;
}
class Docter extends People{
private String name;
public String pwd;
String sex;
@Override
public String toString() {
return "Docter{" +
"name='" + name + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("姓名:"+name);
}
}
5：Field类中常用的方法
1.获取属性名
属性对象.getName():
2.设置属性可访问（会打破封装）
属性对象.setAccessible(true);
3.为对象的属性赋值
属性对象.set(对象,值)
属性对象为你获取到的属性对象，对象为你要赋值属性所属的对象。
4.获取对象的属性值
属性对象.get(对象)
这里属性对象为你获取到的属性对象，对象为你要获取属性值所属的对象。
public class Test3 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException {
// 获取反射类对象
Class<Teather> teatherClass = Teather.class;
// 通过了反射对象获取类对象
Teather teather = teatherClass.newInstance();
System.out.println(teather);
// 得到类对象中的属性
Field declaredField = teatherClass.getDeclaredField("age");
declaredField.set(teather,18);//通过set属性对象为Teather对象赋值
System.out.println(teather);
Field name = teatherClass.getDeclaredField("name");
// 允许访问私有属性
name.setAccessible(true);
name.set(teather,"张飞");
System.out.println(teather);
}
}
6. 获取方法类对象
1.获取本类中所有的方法：
反射类.getDeclaredMethods();
得到的是一个存放所有方法的数组
2.获取本类和父类中所有public修饰的方法
反射类..getMethods();
得到的是一个存放所有方法的数组
3.获取本类中指定的方法对象
反射类.getDeclaredMethod("方法名",方法参数);
4.获取本类及父类中指定名称的方法对象
反射类.getMethod("方法名", 方法参数);
public class Test4 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException {
// 获取反射类对象
Class<Hello> helloClass = Hello.class;
// 获取hello对象
Hello hello = helloClass.newInstance();
// 获取本类中所有的Method方法对象
Method[] declaredMethods = helloClass.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println(method);
}
Method sun= helloClass.getMethod("sun",int.class);
System.out.println(sun);
}
// 得到本类以及父类中的public修饰的方法对象
}
7：Method类中常用方法
invoke（对象，方法参数值）：执行方法体
获取的注解对象.value()
public class Test5 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
// 获取反射类对象
Class<Word> wordClass = Word.class;
// 获取hello对象
Word word = wordClass.newInstance();
Method sun= wordClass.getMethod("sun",int.class,String.class);
//invoke回调执行该方法 执行方法 word指的调用的方法对象
Object result = sun.invoke( word,15,"123");
System.out.println(result);
MyWord annotation = sun.getAnnotation(MyWord.class);
System.out.println(annotation.value());
}
}
8：获取构造对象
只能得到本类中public的构造函数
getConstructor
得到本类中所有的public的构造函数
getConstructors
public class Test06 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException {
Class<?> aClass = T.class;
// 它只能得到本类中public的构造函数
Constructor<?>[] constructor = aClass.getConstructors();
for (Constructor<?> declaredConstructor : constructor) {
System.out.println(declaredConstructor);
}
}
}
8.2：Constructor类中常用的方法
获取类中所有声明的构造器的方法
getDeclaredConstructors
获取类中声明的构造器的方法
getDeclaredConstructor
public static void main(String[] args) throws Exception {
Class<?> aClass = S.class;
//得到无参构造函数
// Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
// Object o = declaredConstructor.newInstance();
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);
Object world = declaredConstructor.newInstance("hello world");
}
}
标签：反射,String,对象,Class,笔记,class,获取,理解,public From： https://www.cnblogs.com/zyjxm/p/17621469.html