java反射的初理解
反射
获取类的方法:
Class<?> aClass1 = Class.forName("TestDemo.refection.User");//通过类路径获取
Class<User> userClass = User.class;//通过类名获取
User user = new User();
Class<? extends User> aClass = user.getClass();//通过实例对象获取
无论通过哪种方式获取，获取几个都是一个Class的实例：
Class<?> aClass1 = Class.forName("TestDemo.refection.User");
Class<?> aClass2 = Class.forName("TestDemo.refection.User");
Class<User> userClass = User.class;
User user = new User();
Class<? extends User> aClass = user.getClass();
System.out.println(aClass1.hashCode());
System.out.println(aClass2.hashCode());
System.out.println(userClass.hashCode());
System.out.println(aClass.hashCode());
/*
结果：
1360875712
1360875712
1360875712
1360875712
可以看出它们的hashCode都是一样的
*/
通过反射获取相应的Class类后，获取相应的方法、属性、构造器
public class Test04 {
public static void main(String[] args) throws Exception {
Class<?> aClass = Class.forName("TestDemo.refection.User1");
System.out.println(aClass.getName());//获取全类名
System.out.println(aClass.getSimpleName());//获取简单的类名
System.out.println("=========================================");
Field[] fields = aClass.getFields();//获取公有的属性
for (Field field : fields) {
System.out.println("public:" +field);
}
fields = aClass.getDeclaredFields();//获取全部（包括公有和私有）的属性
for (Field field : fields) {
System.out.println("getDeclaredFields:" +field);
}
System.out.println("=========================================");
System.out.println("获取所有公有的方法，包括父类的：");
Method[] methods = aClass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("获取自己所有的方法，包括私有的：");
methods = aClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("获取指定的公有的方法（包括父类的方法）：");
Method setName = aClass.getMethod("setName", String.class);
System.out.println(setName);
Method notify = aClass.getMethod("notify");
System.out.println(notify);
System.out.println("获取指定的全部的方法（包括父类的方法，包括私有的方法）：");
Method test = aClass.getDeclaredMethod("test");
System.out.println(test);
System.out.println("=========================================");
System.out.println("获取全部公有（自身的）的构造器：");
Constructor<?>[] constructors = aClass.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
System.out.println("获取全部（自身的，包括私有的）的构造器");
constructors = aClass.getDeclaredConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
System.out.println("获取指定的构造器（不包括私有的）：");
System.out.println(aClass.getConstructor());
System.out.println("获取指定的构造器（包括私有的）：");
System.out.println(aClass.getDeclaredConstructor(String.class));
}
}
class Fater1{
public Fater1(){}
}
class User1 extends Fater1{
private String name;
private int id;
public int age;
public User1() {
}
private User1(String name) {
this.name = name;
}
public User1(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
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;
}
private void test(){
System.out.println("私有方法");
}
@Override
public String toString() {
return "User1{" +
"name='" + name + '\'' +
", id=" + id +
", age=" + age +
'}';
}
}
/*
结果：
TestDemo.refection.User1
User1
=========================================
public:public int TestDemo.refection.User1.age
getDeclaredFields:private java.lang.String TestDemo.refection.User1.name
getDeclaredFields:private int TestDemo.refection.User1.id
getDeclaredFields:public int TestDemo.refection.User1.age
=========================================
获取所有公有的方法，包括父类的：
public java.lang.String TestDemo.refection.User1.toString()
public java.lang.String TestDemo.refection.User1.getName()
public int TestDemo.refection.User1.getId()
public void TestDemo.refection.User1.setName(java.lang.String)
public void TestDemo.refection.User1.setAge(int)
public int TestDemo.refection.User1.getAge()
public void TestDemo.refection.User1.setId(int)
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()
获取自己所有的方法，包括私有的：
public java.lang.String TestDemo.refection.User1.toString()
public java.lang.String TestDemo.refection.User1.getName()
public int TestDemo.refection.User1.getId()
public void TestDemo.refection.User1.setName(java.lang.String)
private void TestDemo.refection.User1.test()
public void TestDemo.refection.User1.setAge(int)
public int TestDemo.refection.User1.getAge()
public void TestDemo.refection.User1.setId(int)
获取指定的公有的方法（包括父类的方法）：
public void TestDemo.refection.User1.setName(java.lang.String)
public final native void java.lang.Object.notify()
获取指定的全部的方法（包括父类的方法，包括私有的方法）：
private void TestDemo.refection.User1.test()
=========================================
获取全部公有（自身的）的构造器：
public TestDemo.refection.User1(java.lang.String,int,int)
public TestDemo.refection.User1()
获取全部（自身的，包括私有的）的构造器
public TestDemo.refection.User1(java.lang.String,int,int)
private TestDemo.refection.User1(java.lang.String)
public TestDemo.refection.User1()
获取指定的构造器（不包括私有的）：
public TestDemo.refection.User1()
获取指定的构造器（包括私有的）：
private TestDemo.refection.User1(java.lang.String)
*/
反射创建对象实例（Constructor）、方法（Method）、属性（Field）：
public class Test05 {
public static void main(String[] args) throws Exception {
Class<?> aClass = Class.forName("TestDemo.refection.AAA");
System.out.println("创建一个对象的实例，使用的无参构造器：");
AAA aaa = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
System.out.println(aaa);
System.out.println("创建一个对象的实例，使用的有参构造器：");
AAA aaa1 = (AAA)aClass.getConstructor(int.class, String.class).newInstance(1,"水三丫");
System.out.println(aaa1);
System.out.println("创建一个对象的实例，使用的私有有参构造器：");
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(int.class);
//需要关闭权限，才可以使用私有的构造器
declaredConstructor.setAccessible(true);
AAA aaa2 = (AAA)declaredConstructor.newInstance(1);
System.out.println(aaa2);
System.out.println("===============================================");
System.out.println("反射使用一个公有方法：");
AAA aaa4 = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
aClass.getMethod("setName", String.class).invoke(aaa4,"水三丫");
System.out.println(aaa4);
System.out.println("反射使用一个公有方法：");
AAA aaa5 = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
Method test = aClass.getDeclaredMethod("test");
test.setAccessible(true);
test.invoke(aaa5);
System.out.println("================================================");
System.out.println("反射获取一个公有属性：");
AAA aaa6 = (AAA)aClass.newInstance();//如果没有无参构造器就会报错
Field field = aClass.getField("name");
field.set(aaa6,"水三丫");
System.out.println(aaa6);
System.out.println("反射获取一个私有属性：");
Field field1 = aClass.getDeclaredField("id");
field1.setAccessible(true);//关闭权限
field1.set(aaa6,1);
System.out.println(aaa6);
}
}
class AAA{
private int id;
public String name;
public AAA() {
}
private AAA(int id) {
this.id = id;
}
public AAA(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private void test(){
System.out.println("我是私有的方法");
}
@Override
public String toString() {
return "AAA{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
/*
结果：
创建一个对象的实例，使用的无参构造器：
AAA{id=0, name='null'}
创建一个对象的实例，使用的有参构造器：
AAA{id=1, name='水三丫'}
创建一个对象的实例，使用的私有有参构造器：
AAA{id=1, name='null'}
===============================================
反射使用一个公有方法：
AAA{id=0, name='水三丫'}
反射使用一个公有方法：
我是私有的方法
================================================
反射获取一个公有属性：
AAA{id=0, name='水三丫'}
反射获取一个私有属性：
AAA{id=1, name='水三丫'}
*/
反射获取泛型：
public class Test06 {
public static void main(String[] args) throws Exception {
Class<BB> bbClass = BB.class;
System.out.println("获取参数类型");
Method method = bbClass.getMethod("test01", Map.class, List.class);
//获取类型
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println(genericParameterType);
//获取单个真实的泛型
if(genericParameterType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
System.out.println("===========================================");
System.out.println("获取返回值类型");
Method test02 = bbClass.getDeclaredMethod("test02", List.class);
Type genericReturnType = test02.getGenericReturnType();
System.out.println(genericReturnType);
if(genericReturnType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
System.out.println("===========================================");
System.out.println("获取未定型的返回值类型");
Method test03 = bbClass.getDeclaredMethod("test03");
Type genericReturnType1 = test03.getGenericReturnType();
System.out.println(genericReturnType1);
}
}
class BB{
public void test01(Map<String,BB> map, List<BB> list){
System.out.println("test01");
}
public Map<String,BB> test02(List<BB> list){
System.out.println("test01");
return null;
}
public <T>T test03(){
return null;
}
}
/*
结果：
获取参数类型
java.util.Map<java.lang.String, TestDemo.refection.BB>
class java.lang.String
class TestDemo.refection.BB
java.util.List<TestDemo.refection.BB>
class TestDemo.refection.BB
===========================================
获取返回值类型
java.util.Map<java.lang.String, TestDemo.refection.BB>
class java.lang.String
class TestDemo.refection.BB
===========================================
获取未定型的返回值类型
T
*/
java反射的初理解的更多相关文章
- JAVA反射机制及理解
JAVA反射 往往当我们面对一项新的知识时,我们往往需要知道三个方面,它是什么,它能做什么,它比原有知识强在哪里,我们该怎么使用它.当你能够解决这些问题时,便意味着你已经对这项知识入门了. 首先: 反 ...
- Java反射的浅显理解
一.回顾反射相关的知识 1.在xml文件中使用反射的好处: 1)代码更加灵活,后期维护只需要修改配置文件即可 · 初学者一般习惯于在代码本身上直接修改,后期也可以修改配置文件达到相同的目的 · 修改配 ...
- 我对java反射机制的理解
我们平常怎么用一个使用类,怎么使用类的方法?其实就是创建一个对象,并且通过这个对象调用这个方法.不过这有一个问题,就是这个对象的载体就和这个对象产生了耦合,怎么降低两者间的耦合呢?java的反射机制就 ...
- java反射机制的理解
反射机制是什么概念?大多都有介绍,指的是程序在运行状态中,能够加载一个只有类名的类,加载完之后会在堆上产生一个Class对象.通过这个 Class对象可以获得类的属性.方法和其他类信息.之前对反射的应 ...
- Java反射的一些理解
1.Class对象 VS. 实例对象 在Java中我们一般是这样使用类的:编写类,然后new对象,再调用方法.这里new出来的对象暂且称之为实例对象(instance).其实在这之前还涉及到一个Cla ...
- JAVA反射机制_获取字节码文件对象
是在运行状态中,对于任意一个类 (class文件),都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性: 这种动态获取的信息以及动态调用对象的方法的功能称为java语 ...
- Java反射机制获取Class文件
JAVA反射机制是在运行状态中,对于任意一个类(class文件),都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象方法的功能称为 ...
- java反射机制 + Method.invoke解释 getMethod + 反射理解
功能: 通过读取另一个Dll去创建一个控件(Form,Button,TextBox,DataGridView),然后对当中一些属性进行检查. 创建控件的大致流程是,Assembly->Modul ...
- (转)JAVA反射机制理解
JAVA反射机制: 通俗地说,反射机制就是可以把一个类,类的成员(函数,属性),当成一个对象来操作,希望读者能理解,也就是说,类,类的成员,我们在运行的时候还可以动态地去操作他们. 理论的东东太多也没 ...
随机推荐
- 虚拟机：KVM
1. KVM 介绍 1.0 虚拟化简史 其中,KVM 全称是 基于内核的虚拟机(Kernel-based Virtual Machine),它是Linux 的一个内核模块,该内核模块使得 Linux ...
- Spring-Batch将CSV文件转为XML文件
1 介绍 用Spring Batch实现一个简单的需求,将csv文件转换成xml文件. csv文件如下:record.csv username, user_id, transaction_date, ...
- 安装Supervisor到CentOS（YUM）
Supervisor是一个Linux下进程管理工具. Supervisor是用Python开发的一套通用的进程管理程序,能将一个普通的命令行进程变为守护进程,并监控进程状态,异常退出时能自动重启,可以 ...
- 《Effective C++》阅读总结（三）:资源管理
C++中的资源管理非常重要,在将资源加载到内存后,便可以使用资源了,当我们不再需要资源时,我们要保证其正确的释放,才能将其占用的内存空间归还给操作系统,不正确的释放很容易造成内存泄漏.本章以资源管理类 ...
- IDEA初始化基础配置
0.前言 这篇博客是给认识的那帮新手搞的,刚进入IT行业的崽们 这个东西配置好了,也可以选择弄成在线文档,下一次安装IDEA时,有一个import导入配置,然后就可以自己配置好了( 虽然方便,但不建议 ...
- redis击穿,穿透,雪崩,分布式锁,api(jedis,luttuce)
击穿:(redis做缓存用,肯定发生了高并发,到达数据库查询) 设置key 的过期时间,过期后没有这个key,找不到了,就穿过了(其中一个key过期导致并发访问数据库) LRU (LRU,即:最近最少 ...
- JS：构造函数
定义:在JavaScript中,用new关键字来调用的函数,称为构造函数,构造函数首字母一般大写. 理解: 构造函数就是初始化一个实例对象,对象的prototype属性是继承一个实例对象. 创建对象, ...
- 关键字——this,super,static,final
this 理解为当前对象. //测试 public static void main(String[] args){ Person person = new Person(3, "xiaoM ...
- NHibernte 4.0.3版本中，使用Queryover().Where().OrderBy().Skip().Take()方法分页获取数据失败
问题代码如下: var result=repository.QueryOver<modal>() .Where(p=>p.Code==Code) .OrderBy(p=>p.I ...
- Java 向数组中添加元素
一般数组是不能添加元素的,因为他们在初始化时就已定好长度了,不能改变长度. 向数组中添加元素思路 第一步:把数组转化为集合 list = Arrays.asList(array); 第二步:向集合中添 ...