反射_2

时间：2020-06-03 15:42:59 阅读：45 评论：0 收藏：0 [点我收藏+]

标签：ram unit interface 详细信息 actual run 列表构造方法配置

反射
1.在运行期间，动态获取某个类的详细信息
2.在运行期间，动态创建任意类型的对象
3.在运行期间，动态的为对象赋值
4.在运行期间，动态的调用对象的任意方法

package test04;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.junit.Test;

/*
 反射
1.在运行期间，动态获取某个类的详细信息
2.在运行期间，动态创建任意类型的对象
3.在运行期间，动态的为对象赋值
4.在运行期间，动态的调用对象的任意方法


1.在运行期间，动态获取某个类的详细信息
步骤：
1.获取某个对象的Class对象
2.使用Class对象和java.lang.reflect包下面的其他类型的API


Class中的API:
1.包：package getPackage()
2.类的修饰符：int getModifiers()
3.类名：getName()
4.父类：getSuperclass()
5.接口：getInterfaces()
6.属性：Field[] getFields():该类及其所有超类的公共字段
      Field[] getFields(String name)
      Field[] getDeclaredFields() 该类的字段
      Field[] getDeclaredFields(String name)
7.构造器：Construct<?> getConstructors()
       Construct<?> getConstructors(Class<?> ... parameterTypes)
       Construct<?> getDeclaredConstructors()
       Construct<?> getDeclaredConstructors(Class<?> ... parameterTypes)
8.方法：Method[] getMethods()
      Method[] getMethods(String name,Class<?> ... parameterTypes)
      Method[] getDeclaredMethods()
      Method[] getDeclaredMethods(String name,Class<?> ... parameterTypes)
  

java.lang.reflect包
（1）package类型
包名：getName()
(2)Modifier类型
(3)Field类型
                 【修饰符】 数据类型 属性名
      set/get值
      
    属性名：getName()
    属性修饰符：getModifiers()
    属性类型：getType()
 (4)Constructor类型
                   【修饰符】 构造器名（形参列表）{}
       构造器名：getName()
       构造器修饰符：getModifiers()            
       构造器形参列表：getParameterTypes()
 (5)Method类型
       【修饰符】返回值类型 方法名 （【形参列表】） throws 异常列表{}
     被调用invoke
     
       方法名：getName()
       方法修饰符：getModifiers()            
       方法形参列表：getParameterTypes()
      方法返回值类型：getReturnType()
*/

public class test02 {
    @Test
    public void test2() throws Exception{
        //1.获取Class对象
        Class<?> c= Class.forName("AtStudent.Student");
        
        //2.获取包信息
        Package pk = c.getPackage();
        System.out.println(pk.getName());//AtStudent
        
        //3.获取Class的修饰符
        int mod = c.getModifiers();
        System.out.println(mod);//1
        System.out.println(Modifier.toString(mod));//public
        
        //4.获取类名
        System.out.println(c.getName());//AtStudent.Student
        
        //5.获取父类
        Class<?> parent = c.getSuperclass();
        System.out.println(parent.getName());//java.util.Date
        
        //6.获取父接口
        Class<?>[] interfaces = c.getInterfaces();
        for(Class<?> inter:interfaces) {
            System.out.println(inter);//interface java.io.Serializable
        }
        
        System.out.println(); 
        
        //7.获取属性
        Field[] alldeclaredFields = c.getDeclaredFields();
        for(Field field:alldeclaredFields) {
            
            //属性名
            System.out.println(field.getName()); 
            
            //属性的修饰符
            int fmod = field.getModifiers();
            System.out.println(Modifier.toString(fmod));//public
            
            //属性的数据类型
            Class<?> ftype = field.getType();
            System.out.println(ftype.getName());
        }
        
        System.out.println(); 
        
        //8.获取构造器
        Constructor<?>[] alldeclaredConstructors = c.getDeclaredConstructors();
        for (Constructor<?> constructor:alldeclaredConstructors ) {
            
            
            //构造器名
            System.out.println(constructor.getName()); 
            
            //构造器的修饰符
            int cmod = constructor.getModifiers();
            System.out.println(Modifier.toString(cmod));
            
            //构造器的形参列表
            Class<?>[] parameterTypes = constructor.getParameterTypes();
            for(Class<?> pt: parameterTypes) {
                System.out.println(pt.getName());
                
            }
        }
        
        //9.方法
        Method[] alldeclaredMethods = c.getDeclaredMethods();
        for (Method method:alldeclaredMethods) {
            //方法名
            System.out.println(method.getName()); 
            
            //方法的修饰符
            int cmod = method.getModifiers();
            System.out.println(Modifier.toString(cmod));
            
            //方法返回值类型
            Class<?> returnType = method.getReturnType();
            System.out.println(returnType);
            
            //方法的形参列表
            Class<?>[] parameterTypes = method.getParameterTypes();
            for(Class<?> pt: parameterTypes) {
                System.out.println(pt.getName());
            
            
        }
    
        
        
        
        
    }

}

package test04;

import java.lang.reflect.Constructor;

import org.junit.Test;

/*
反射
在运行期间，动态创建任意类型的对象
1.Class对象.newInstance()创建实例对象
      前提：类必须有无参构造方法
      （1）获取Class对象
      （2）Class对象.newInstance()
      
2.构造器创建实例对象
（1）获取Class对象
（2）获取构造器对象，获取其中一个
    Construct<?> getConstructors(Class<?> ... parameterTypes)
    parameterTypes：形参列表
（3）用构造器创建对象
   java.lang.reflect.Constructor类型中newInstance(initargs)
     initargs：实参类表
*/
public class test03 {
    
    


    @Test
    public void test2() throws Exception {
        //1.获取Class对象
        Class<?> c= Class.forName("AtStudent.Student");
        
        //2.获取构造器对象
        
        Constructor<?> constructor = c.getDeclaredConstructor(String.class,int.class);
        
        //3.用构造器创建对象
        Object obj = constructor.newInstance("zhang",20);
        System.out.println(obj);//Student [name=zhang, age=20]
    }
    
    
    @Test
    public void test1() throws Exception {
        //1.获取Class对象
        Class<?> c= Class.forName("AtStudent.Student");
        
        //2.创建Student对象
        Object obj = c.newInstance();
        System.out.println(obj);//Student [name=zhang, age=0]
    }

}

package test04;

import java.lang.reflect.Field;

import org.junit.Test;

/*
反射
在运行期间，动态的为对象赋值或者获取属性值
1.获取Class对象
2.获取Field属性对象
3.创建Student对象
4.为属性赋值 set()
5.获取属性的值get()
*/
public class test04 {
    
    @Test
    public void test1() throws Exception {
        //1.获取Class对象
        Class<?> c= Class.forName("AtStudent.Student");
        
        //2.获取Field属性对象
        Field name_field = c.getDeclaredField("name");
        name_field.setAccessible(true);
        
        //3.创建Student对象
        Object stu = c.newInstance();
        
        //4.为属性赋值
        
        name_field.set(stu, "wang");
        
        //5.获取属性的值
        Object object = name_field.get(stu);
        
        
        
        System.out.println(object);
    }
    
}

package test04;

import java.lang.reflect.Method;

import org.junit.Test;

/*
反射

在运行期间，动态的调用对象的任意方法
1.获取Class对象
2.获取Method对象
   c.getDeclaredMethod(name, parameterTypes)
   name:方法名
   parameterTypes：形参列表
3.创建Student对象：如果是静态方法，不需要创建实例对象
  c.newInstance()
4.调用方法 invoke:如果是静态方法，实例对象可以是Null
   
   

*/

public class test05 {
    
    
    
    //静态方法
    @Test
    public void test2() throws Exception {
        //1.获取Class对象
        Class<?> c= Class.forName("AtStudent.Student");
        
        //2.获取Method对象
        Method method = c.getDeclaredMethod("test", int.class);
        
        
        //3.调用方法
        method.invoke(null, 10);
        
        
        
        
    }
    
    
    
    //非静态方法
    @Test
    public void test1() throws Exception {
        //1.获取Class对象
        Class<?> c= Class.forName("AtStudent.Student");
        
        //2.获取Method对象
        Method method = c.getDeclaredMethod("setName", String.class);
        
        //3.创建Student对象
        Object stu = c.newInstance();
        
        //4.调用方法
        method.invoke(stu, "zhao");
        
        System.out.println(stu);
        
    }

}

package test04;

//获取父类泛型

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class test06 {
    
    public static void main(String[] args) {
        //1.Son对象
        Class<?> c=Son.class;
        
        //2.获取父类
        Class<?> parent = c.getSuperclass();
        System.out.println(parent);//class test04.Father
        
        //2.获取泛型父类
        Type parent_type = c.getGenericSuperclass();
        System.out.println(parent_type);//test04.Father<java.lang.String, java.lang.Integer>
        
        ParameterizedType p =(ParameterizedType) parent_type;
        System.out.println(p);//test04.Father<java.lang.String, java.lang.Integer>
        
        //获取泛型实参        
        Type[] types=p.getActualTypeArguments();
        for(Type type:types) {
            System.out.println(type);
        }
        
    }

}


abstract class Father<T,U>{
    
}
class Son extends Father<String,Integer>{
    
}

package test04;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/*
 获取注解信息
1.申明
2.使用
3.读取
*/

public class test07 {
    public static void main(String[] args) {
        //读取Myclass上面的注解
        
        //1.获取Myclass的class对象
        Class<?> c= Myclass.class;
        
        
        //2.获取Myclass上面的注解
        MyAnntation my= c.getAnnotation(MyAnntation.class);
        
        //3.获取注解的配置参数的值
        String value = my.value();
        System.out.println(value);//zhang san
        
    }

}


//使用注释
@MyAnntation("zhang san")
class Myclass{
    
}


//申明注解信息
@Retention(RetentionPolicy.RUNTIME)  //使注解能有效到代码运行时
@interface MyAnntation{
    String value();
}

反射_2

标签：ram unit interface 详细信息 actual run 列表构造方法配置

原文地址：https://www.cnblogs.com/hapyygril/p/13037639.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行