java反射

最新推荐文章于 2021-11-10 08:45:00 发布

克豪

最新推荐文章于 2021-11-10 08:45:00 发布

阅读量156

点赞数 1

分类专栏： java 文章标签：反射

本文链接：https://blog.csdn.net/qq754772661/article/details/107760908

版权

java 专栏收录该内容

122 篇文章 0 订阅

订阅专栏

什么是反射

简单的来说，一般情况下，都是知道一个类，然后由类去创建对象

而反射就算反过来，有一个对象去获得类，去获取类的这个过程就叫做反射

然后获取了类之后，在用这个类对象去获取属性方法，并使用

值得注意的是采用了反射的情况代码运行速度比未使用反射的代码运行速度慢很多

获取Class类对象的方式

先定义两个类

class Father{
}

class Son extends Father{
}

通过类获取

 Class c1 = Son.class;
 System.out.println(c1);

class com.kehao.Son

通过对象获取

Son son = new Son();
Class c2 = son.getClass();
System.out.println(c2);

class com.kehao.Son

通过全类名获取

Class c3 = Class.forName("com.kehao.Son");
System.out.println(c3);

class com.kehao.Son

基本数据类型的TYPE属性

Class c4 = Integer.TYPE;
System.out.println(c4);

int

使用Class对象获取父类的Class对象

Class c5 = c1.getSuperclass();
System.out.println(c5);

class com.kehao.Father

获取类对象相关属性

先定义一个类

public class User {
    public String id;
    private String name;
    private int age;

    public User() {
    }
    
    private User(String name){
        this.name = name;
    }


    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    private void hello(){
        System.out.println("This is a private hello method!");
    }
}

获取Class对象

  Class cUser = Class.forName("com.kehao.User");

获取类的一些参数

比如类的名字等

String cUserName = cUser.getName();
String cUserSimpleName = cUser.getSimpleName();
System.out.println("getName:"+cUserName);
System.out.println("getSimpleName:"+cUserSimpleName);

getName:com.kehao.User
getSimpleName:User

获取成员变量

Field[] fields= cUser.getFields();//只会返回public成员变量
for(Field field:fields){
    System.out.println(field);
}

public java.lang.String com.kehao.User.id

Field[] declaredFields= cUser.getDeclaredFields();//返回所有的成员变量
for(Field field:declaredFields){
    System.out.println(field);
}

public java.lang.String com.kehao.User.id
private java.lang.String com.kehao.User.name
private int com.kehao.User.age

Field age = cUser.getDeclaredField("age");
System.out.println(age);

private int com.kehao.User.age

获取方法

返回所有的public的方法（包括父类的方法）

Method[] methods = cUser.getMethods();
for(Method method:methods){
    System.out.println(method);
}

public java.lang.String com.kehao.User.id
public java.lang.String com.kehao.User.id
private java.lang.String com.kehao.User.name
private int com.kehao.User.age
private int com.kehao.User.age
public java.lang.String com.kehao.User.toString()
public java.lang.String com.kehao.User.getName()
public void com.kehao.User.setName(java.lang.String)
public void com.kehao.User.setAge(int)
public int com.kehao.User.getAge()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

返回所有的方法（包括私有的方法,不包括父类的方法）

Method[] declaredMethods = cUser.getDeclaredMethods();
for(Method method :declaredMethods){
    System.out.println(method);
}

public java.lang.String com.kehao.User.toString()
public java.lang.String com.kehao.User.getName()
public void com.kehao.User.setName(java.lang.String)
private void com.kehao.User.hello()
public void com.kehao.User.setAge(int)
public int com.kehao.User.getAge()

返回具体的方法

Method getName = cUser.getMethod("getName");
System.out.println(getName);
Method setName = cUser.getMethod("setName", String.class);
System.out.println(setName);

public java.lang.String com.kehao.User.getName()
public void com.kehao.User.setName(java.lang.String)

获得构造器

Constructor[] constructors = cUser.getConstructors();//返回public构造器
for(Constructor constructor : constructors){
    System.out.println(constructor);
}

public com.kehao.User(java.lang.String,int)
public com.kehao.User()

Constructor[] declaredConstructors = cUser.getDeclaredConstructors();//返回所有构造器
for (Constructor constructor :declaredConstructors){
    System.out.println(constructor);
}

public com.kehao.User(java.lang.String,int)
private com.kehao.User(java.lang.String)
public com.kehao.User()

Constructor constructor = cUser.getConstructor(String.class,int.class);
System.out.println(constructor);

public com.kehao.User(java.lang.String,int)

创建对象并调用方法

创建对象

使用无参构造器创建对象

User user  = (User) cUser.newInstance();

使用有参构造器创建对象

Constructor constructor = cUser.getConstructor(String.class,int.class);
User kehao = (User)constructor.newInstance("kehao", 20);

调用方法

Constructor constructor = cUser.getConstructor(String.class,int.class);
User kehao = (User)constructor.newInstance("kehao", 20);
System.out.println(kehao);

Method setName = cUser.getMethod("setName", String.class);
setName.invoke(kehao,"Liming");
System.out.println(kehao);

User{name=‘kehao’, age=20}
User{name=‘Liming’, age=20}

操作属性

Constructor constructor = cUser.getConstructor(String.class,int.class);
User kehao = (User)constructor.newInstance("kehao", 20);
System.out.println(kehao);

Field name = cUser.getDeclaredField("name");
name.set(kehao,"XiaoMIng");
System.out.println(kehao);

User{name='kehao', age=20}
Exception in thread "main" java.lang.IllegalAccessException: Class com.kehao.Test04 can not access a member of class com.kehao.User with modifiers "private"
   at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
   at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
   at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
   at java.lang.reflect.Field.set(Field.java:761)
   at com.kehao.Test04.main(Test04.java:30)

发生了报错，原因在于name是私有变量权限不够，但是反射可以忽视掉这个问题，强行修改变量值，修改代码如下

Constructor constructor = cUser.getConstructor(String.class,int.class);
User kehao = (User)constructor.newInstance("kehao", 20);
System.out.println(kehao);

Field name = cUser.getDeclaredField("name");
name.setAccessible(true);
name.set(kehao,"XiaoMIng");
System.out.println(kehao);

User{name=‘kehao’, age=20}
User{name=‘XiaoMIng’, age=20}

name.setAccessible(true);这句代码是用于开关安全检查的，当关闭安全检查的时候，代码运行速度也会相应的加块，但是比未使用反射机制的情况相比依然慢许多

获取泛型信息

获取参数中的泛型

public class Test05 {
    //参数中有泛型的函数
    public void test01(Map<String,User> map, List<User> list,int i){
        System.out.println("Demo.test01()");
    }
    
    public static void main(String[] args) throws Exception {
        Method test01 = Test05.class.getMethod("test01", Map.class,List.class,int.class);
        Type[] t = test01.getGenericParameterTypes();//返回所有的参数（也有不是泛型的参数）

        for (Type paramType : t) {
            System.out.println("Type:"+paramType);//输出所有的参数
            if(paramType instanceof ParameterizedType){//如果是带泛型的参数
                //获取泛型中的具体信息
                Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();
                for (Type genericType : genericTypes) {
                    System.out.println("泛型类型："+genericType);
                }
            }else {
                System.out.println("不是泛型类型的参数");
            }
        }
    }
}

Type:java.util.Map<java.lang.String, com.kehao.User>
泛型类型：class java.lang.String
泛型类型：class com.kehao.User
Type:java.util.List<com.kehao.User>
泛型类型：class com.kehao.User
Type:int
不是泛型类型的参数

获取返回值中的泛型

public class Test05 {
    //返回值中有泛型
    public Map<Integer,User> test02(){
        System.out.println("Demo.test02()");
        return null;
    }

    public static void main(String[] args) throws Exception{
        Method m2 = Test05.class.getMethod("test02", null);
        Type returnType = m2.getGenericReturnType();//得到返回值类型
        if(returnType instanceof ParameterizedType){
            Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();
            for (Type genericType : genericTypes) {
                System.out.println("返回值，泛型类型："+genericType);
            }
        }
    }
}

返回值，泛型类型：class java.lang.Integer
返回值，泛型类型：class com.kehao.User

获取注解信息

public class Test06 {
    public static void main(String[] args) throws Exception {
        Class cPerson = Person.class;
        Annotation[] annotations = cPerson.getAnnotations();
        for (Annotation annotation : annotations){
            System.out.println("循环："+annotation);
        }
        Annotation myTable = cPerson.getAnnotation(MyTable.class);
        System.out.println(myTable);
        System.out.println(((MyTable)myTable).value());

        Field name = cPerson.getDeclaredField("name");
        MyField nameAnnotation = name.getAnnotation(MyField.class);
        System.out.println(nameAnnotation);
        System.out.println(nameAnnotation.column());
        System.out.println(nameAnnotation.type());
        System.out.println(nameAnnotation.length());

    }
}

@MyTable("person_table")
class Person{
    @MyField(column = "col_name",type = "char",length = 20)
    private String name;
    @MyField(column = "col_age",type = "int",length = 20)
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyTable{
    String value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyField{
    String column();
    String type();
    int length();
}

循环：@com.kehao.MyTable(value=person_table)
@com.kehao.MyTable(value=person_table)
person_table
@com.kehao.MyField(column=col_name, type=char, length=20)
col_name
char
20