Java反射的基本应用

反射机制,程序在运行时加载新的类,使程序更加灵活

public class HelooReflect {
    public static void main(String[] args) {
        // 获取类
        testClass();
    }
    private static void testClass() {
        // 创建一个学生类的对象
        Student student = new Student();
        try {
            // 开始获取类
            Class clazz1 = Student.class;
            Class clazz2 = student.getClass();
            Class clazz3 = Class.forName("com.bjsxt.java.clc.fanshe.Student");
            //判断类对象是否相等
            System.out.println(clazz1 == clazz2);
            System.out.println(clazz1 == clazz3);
            //常见 方法
            System.out.println("类的名字" + clazz1.getName());
            System.out.println("类的简称" + clazz1.getSimpleName());
            System.out.println("包的信息" + clazz1.getPackage().getName());
            System.out.println("获取包名" + clazz1.getPackage());
            System.out.println("获取修饰符" + clazz1.getModifiers());
            System.out.println("获取父类" + clazz1.getSuperclass());
            System.out.println("获取父类的超类" + clazz1.getGenericSuperclass());
            System.out.println("判断是否为接口" + clazz1.isInterface());
            System.out.println("获取类加载器" + clazz1.getClassLoader());

            //基本类型9=(8种基本数据类型的类+1void)
            System.out.println(int.class == Integer.class);//不等
            //判断是否是基本类型
            System.out.println(int.class.isPrimitive());
            System.out.println(Integer.class.isPrimitive());
            System.out.println("数组是引用类型" + int[].class.isPrimitive());
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

获取类的名字,方法,属性,构造器

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test2 {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("bean.User");
            // 获取类的名字
            clazz.getName();
            /**
             * 获取属性信息
             */
            // 只能获取public的属性
            Field[] fields1 = clazz.getFields();
            // 可以获得所有的属性
            Field[] fields2 = clazz.getDeclaredFields();
            // 输出获取到的属性的个数
            System.out.println(fields1.length);
            System.out.println(fields2.length);
            // 遍历获取到的属性
            for (Field field : fields2) {
                System.out.println("属性" + field);
            }
            // 获得属性的权限
            Field f = clazz.getDeclaredField("uname");
            System.out.println(f);
            /**
             * 获取方法的信息
             */
            Method[] methods = clazz.getDeclaredMethods();
            Method m01 = clazz.getDeclaredMethod("getUname", null);
            // 如果方法有参,则必须传递参数类型对应的class对象
            Method m02 = clazz.getDeclaredMethod("setUname", String.class);
            for (Method method : methods) {
                System.out.println("方法" + method);
            }
            /**
             *获取构造器信息
             */
            Constructor[] constructors = clazz.getDeclaredConstructors();
            Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
            System.out.println("获得构造器"+c);
            for (Constructor constructor : constructors) {
                System.out.println("构造器"+constructor);
            }

        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

通过反射操作类的属性,方法构造器

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import bean.User;
/**
 * @author clc
 *
 */
public class Test3 {
    public static void main(String[] args) {
        try {
            Class<User> clazz = (Class<User>) Class.forName("bean.User");
            // 通过反射API调用构造方法,构造对象
            // 其实调用了User的无参构造方法
            User u1 = clazz.newInstance();
            System.out.println(u1);
            // 有参调用构造器
            Constructor<User> c = clazz.getDeclaredConstructor(int.class, int.class, String.class);
            User u2 = c.newInstance(1234, 22, "clc");
            System.out.println(u2);
            // 通过反射调用普通方法
            User u3 = clazz.newInstance();
            Method method = clazz.getDeclaredMethod("setUname", String.class);
            // 相当于u3.setUname("clc3");
            method.invoke(u3, "clc3");
            System.out.println(u3);
            // 通过反射操作属性
            User u4 = clazz.newInstance();
            Field f = clazz.getDeclaredField("uname");
            // 设置属性不需要安全检查,可以直接访问
            f.setAccessible(true);
            // 通过反射直接设置属性
            f.set(u4, "clc4");
            // 通过反射直接读取属性值
            System.out.println(u4.getUname());
            System.out.println(f.get(u4));
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

辅助类User

package bean;
public class User {
    private int id;
    private int age;
    private String uname;
    @Override
    public String toString() {
        return "User [id=" + id + ", age=" + age + ", uname=" + uname + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + id;
        result = prime * result + ((uname == null) ? 0 : uname.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (age != other.age)
            return false;
        if (id != other.id)
            return false;
        if (uname == null) {
            if (other.uname != null)
                return false;
        } else if (!uname.equals(other.uname))
            return false;
        return true;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    public User(int id, int age, String uname) {
        super();
        this.id = id;
        this.age = age;
        this.uname = uname;
    }
    public User() {
        super();
    }
}

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import bean.User;

/**

* @author clc

*

*/

public class Test3 {

public static void main(String[] args) {

try {

Class<User> clazz = (Class<User>) Class.forName("bean.User");

// 通过反射API调用构造方法,构造对象

// 其实调用了User的无参构造方法

User u1 = clazz.newInstance();

System.out.println(u1);

// 有参调用构造器

Constructor<User> c = clazz.getDeclaredConstructor(int.class, int.class, String.class);

User u2 = c.newInstance(1234, 22, "clc");

System.out.println(u2);

// 通过反射调用普通方法

User u3 = clazz.newInstance();

Method method = clazz.getDeclaredMethod("setUname", String.class);

// 相当于u3.setUname("clc3");

method.invoke(u3, "clc3");

System.out.println(u3);

// 通过反射操作属性

User u4 = clazz.newInstance();

Field f = clazz.getDeclaredField("uname");

// 设置属性不需要安全检查,可以直接访问

f.setAccessible(true);

// 通过反射直接设置属性

f.set(u4, "clc4");

// 通过反射直接读取属性值

System.out.println(u4.getUname());

System.out.println(f.get(u4));

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InstantiationException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalAccessException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchMethodException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (SecurityException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalArgumentException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvocationTargetException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchFieldException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

时间： 2024-08-04 09:35:02

Java反射的基本应用的相关文章

Java反射

1. 介绍 反射是一种能够在程序运行时动态访问.修改某个类中任意属性和方法的机制. 具体:对于任意一个类,都能够知道这个类的所有属性和方法对于任意一个对象,都能够调用它的任意一个方法和属性 在运行时,当加载完类之后,JVM在堆内存中会自动产生一个Class类型的对象,这个对象包含了完整的类的结构信息 这个Class对象就像一面镜子,透过这个镜子看到类的结构 那么,如何得到这个Class对象呢?以下可否 Class c = new Class(); 答案是不行的,因为Class的构造函数定义为私有

Java 反射详解

反射反射,程序员的快乐,今天你快乐了吗?如果你不快乐,没关系,接下来让你快乐起来! 一.什么是反射? 通过百度百科我们可以知道,Java反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意方法和属性:并且能改变它的属性.而这也是Java被视为动态(或准动态,为啥要说是准动态,因为一般而言的动态语言定义是程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言.从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C

java反射机制（一）—— 利用反射机制实例化对象

一.Java有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载.探知.使用编译期间完全未知的classes.换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体.或对其fields设值.或唤起其methods.(度娘文库是这么说的) 二.这篇文章主要介绍一下通过反射机制去实例化一个类的对象,然后调用其方法.本文主要介绍两种方式,第一种就是通过构造函数来实例化,第二种就是通过Cl

java 反射 详解

本文来自:blog.csdn.net/ljphhj JAVA反射机制:   通俗地说,反射机制就是可以把一个类,类的成员(函数,属性),当成一个对象来操作,希望读者能理解,也就是说,类,类的成员,我们在运行的时候还可以动态地去操作他们. 理论的东东太多也没用,下面我们看看实践 Demo - Demo: package cn.lee.demo; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import

【java】java反射机制，动态获取对象的属性和对应的参数值，并属性按照字典序排序，Field.setAccessible()方法的说明【可用于微信支付 签名生成】

方法1:通过get()方法获取属性值 package com.sxd.test.controller; public class FirstCa{ private Integer num; private String name; private Boolean flag; public Integer getNum() { return num; } public void setNum(Integer num) { this.num = num; } public String getNam

java 反射类的理解与应用

本文主要解析的类是: ClassLodaer,Class,Field,Method,Constructor. 本文的目标很简单,只是对这些常用的反射类进行简单解释.对这些类中常用方法进行介绍. JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制.Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类:在运行时构造任意一个类的对象:在

Java 反射机制

使用 Java 反射机制可以在运行时期检查 Java 类的信息,检查 Java 类的信息往往是你在使用 Java 反射机制的时候所做的第一件事情,通过获取类的信息你可以获取以下相关的内容: Class 对象 类名 修饰符 包信息 父类 实现的接口 构造器 方法 变量 注解 除了上述这些内容,还有很多的信息你可以通过反射机制获得,如果你想要知道全部的信息你可以查看相应的文档 JavaDoc for java.lang.Class 里面有详尽的描述. 在本节中我们会简短的涉及上述所提及的信息,上述的

Java 反射，开发框架必备技能

通过反射技术我们将上面的统一资源定位付(URL) 映射到Class 相当于 class: news method: list parameter: 2 差不多就是下面样子 class News{ public String list(String catagory_id){ ... ... } } 我们只需要在框架核心中分析 url 然后调用对应的方法下载,于此同时将参数传递过去. Class<?> cls = Class.forName("cn.netkiller.reflect.

Java反射与代理

Java反射机制与动态代理,使得Java更加强大,Spring核心概念IoC.AOP就是通过反射机制与动态代理实现的. 1       Java反射 示例: User user = new User(); user.setTime5Flag("test"); Class<?> cls = Class.forName("com.test.User"); //接口必须public,无论是否在本类内部使用!或者使用cls.getDeclaredMethod()

Java反射机制浅析

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. "程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言".从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言.但是JAVA有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载.探知.使用