编程语言
首页 > 编程语言> > java 反射

java 反射

作者:互联网

类对象

类对象:类加载的产物,封装了一个类的所有信息(类名,父类,接口,属性,方法,构造方法)

每一个类加载到内存之后都对应一个class对象

每个类有且只有一个class对象

获取类对象

  1. 通过类的对象获取类对象

    • Student s = new Student();

    • Class<?> c = s.getClass();

  2. 通过类名获取类对象

    • Class<?> c = 类名.class;

  3. 通过静态方法获取类对象(记得抛出异常)[推荐使用]

    • Class<?> c = Class.forName("包名.类名");

反射

常用方法

常见操作

附:person类

public class person implements Serializable,Cloneable {
   public String name;

   public person() {
  }

   public person(String name) {
       this.name = name;
  }

   public void eat(){
       System.out.println(this.name+"在吃饭");
  }

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

   public void eat(String food){
       System.out.println(this.name+"在吃"+food);
  }

   private void sleep(){
       System.out.println(this.name + "在睡觉");
  }

   public static void quiet(){
       System.out.println("保持安静");
  }
}

使用反射获取类的名字,包名,父类,接口

public class Demo1 {
   public static void main(String[] args) throws Exception{
       reflectOpe1();
  }
   public  static void reflectOpe1() throws Exception{
       //1 获取类对象person
       Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
       //获得类的全名称
       System.out.println(class1.getName());
       //得到包名(getPackage() 返回包的类对象)
       System.out.println(class1.getPackage().getName());
       //获取父类()(getSuperclass() 返回父类的类对象)
       System.out.println(class1.getSuperclass().getName());
       //获取接口(getInterfaces() 返回数组)
       Class<?>[] classes = class1.getInterfaces();
       System.out.println(Arrays.toString(classes));
  }
}

使用反射获取类的构造方法并创建对象

public class Demo1 {
   public static void main(String[] args) throws Exception{
       reflectOpe2();
  }

   public  static void reflectOpe2() throws Exception{
       Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
       //获取类的构造方法Constructor(getConstructors()返回数组)
       Constructor<?>[] cons = class1.getConstructors();
       for (Constructor<?> con : cons){
           System.out.println(con.toString());
      }
       //获取类中的无参构造
       Constructor<?> con = class1.getConstructor();
       Object zhangsan = (person)con.newInstance();
       System.out.println(zhangsan.toString());
       //简便方法
       person wangwu = (person) class1.newInstance();
       System.out.println(wangwu.toString());

       //获取类中的带参构造
       Constructor<?> con2 = class1.getConstructor(String.class);
       person xiaoli = (person) con2.newInstance("小李");
       System.out.println(xiaoli.toString());
  }
}

使用反射获取类中的方法并调用

public class Demo1 {
   public static void main(String[] args) throws Exception{
       reflectOpe3();
  }

   public  static void reflectOpe3() throws Exception{
       Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");

       //获取方法
       //getMethods() 获取公开的方法 包括继承的方法
       Method[] methods = class1.getMethods();
       for (Method method : methods) {
           System.out.println(method.toString());
      }
       //getDeclaredMethods() 获取所有方法,不包含继承的
       Method[] Methods2 = class1.getDeclaredMethods();
       for (Method method : Methods2) {
           System.out.println(method.toString());
      }

       //获取单个方法
       //调用无参无返回值
       Method eatMethod = class1.getMethod("eat");
       person zhangsan = (person) class1.newInstance();
       eatMethod.invoke(zhangsan);

       //无参有返回值
       Method toStringMethod = class1.getMethod("toString");
       Object result = toStringMethod.invoke(zhangsan);
       System.out.println(result);

       //带参
       Method eatMethod2 = class1.getMethod("eat",String.class);
       eatMethod2.invoke(zhangsan,"鸡腿");

       //获取私有方法
       Method privateMethod = class1.getDeclaredMethod("sleep");
       //设置访问权限无效
       privateMethod.setAccessible(true);
       privateMethod.invoke(zhangsan);

       //获取静态方法
       Method staticMethod = class1.getMethod("quiet");
       staticMethod.invoke(null);

  }
}

反射调用任何对象的通用方法

public class Demo1 {
   public static void main(String[] args) throws Exception{
       Properties properties = new Properties();
       //原本的方法
       properties.setProperty("name","zhangsan");
       System.out.println(properties.toString());
       //invokeAny()
       invokeAny(properties,"setProperty",new Class[]{String.class,String.class},"username","张三");
       System.out.println(properties.toString());
  }

   public static Object invokeAny(Object obj,String methodName,Class<?>[] types,Object...args) throws Exception{
       //obj是对象名,methodName是方法名,types是方法参数,args是参数的数据
       //获取类对象
       Class<?> class1 = obj.getClass();
       //获取方法
       Method method = class1.getMethod(methodName,types);
       //调用
       return method.invoke(obj,args);
  }
}

使用反射获取类中的属性

public class Demo1 {
   public static void main(String[] args) throws Exception{
       reflectope4();
  }
   public static void reflectope4() throws Exception{
       //获取类对象
       Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
       //获取属性(字段) 公开的字段,父类继承的字段
       Field[] fields = class1.getFields();
       System.out.println(fields.length);
       //获取属性(字段) 所有字段 不包含继承
       Field[] fields1 = class1.getDeclaredFields();
       System.out.println(fields1.length);

       //获取name属性
       Field namefield = class1.getDeclaredField("name");
       namefield.setAccessible(true);//设置权限
       //赋值 正常调用
       person zhangsan = (person) class1.newInstance();
       namefield.set(zhangsan,"张三");//相当于zhangsan.name = "张三";
       //获取值
       System.out.println(namefield.get(zhangsan));
  }
}

标签:反射,java,System,person,println,out,public,class1
来源: https://www.cnblogs.com/SummeRr/p/15615406.html