这篇文章主要围绕java反射基础应用备注和java反射基础应用备注是什么展开，旨在为您提供一份详细的参考资料。我们将全面介绍java反射基础应用备注的优缺点，解答java反射基础应用备注是什么的相关问
这篇文章主要围绕java反射基础应用备注和java反射基础应用备注是什么展开，旨在为您提供一份详细的参考资料。我们将全面介绍java反射基础应用备注的优缺点，解答java反射基础应用备注是什么的相关问题，同时也会为您带来java 反射基础、Java 的反射基础技术、javaAPI_反射_反射基础 2、javaAPI_反射_反射基础1的实用方法。
本文目录一览：
java反射基础应用备注（java反射基础应用备注是什么）
反射机制应用很广泛。这里简单备注下
package com.shone.ailin;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Reflectdemo {
public static void main(String[] args) throws Exception {
printVar();
createInstance();
printAllVarName();
}
//打印所有成员变量名
private static void printAllVarName() {
// TODO Auto-generated method stub
Point p = new Point(1,3);
Field[] fields = p.getClass().getDeclaredFields();
for(int i=0;i<fields.length;i++) {
System.out.println("var["+i+"]="+fields[i].getName());
}
}
//打印成员变量的值
private static void printVar() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
Point p = new Point(1,4);
Field fX = p.getClass().getDeclaredField("x");
fX.setAccessible(true); //这里必须要加上 。不然会抛出异常。因为是私有成员变量，所以，需要暴力的反射
int x = (int)fX.get(p);
System.out.println("x="+x);
}
//创建实例化对象并调用方法
private static void createInstance() throws Exception, SecurityException {
Constructor<Point> con = Point.class.getConstructor(int.class,int.class);
try {
Point instance = con.newInstance(1,3);
Method m = instance.getClass().getDeclaredMethod("addCount", int.class,int.class);
m.setAccessible(true);
try {
int count = (int) m.invoke(instance,2,7);
System.out.println(count);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
}
}
}Point类
package com.shone.ailin;
public class Point {
private int x ;
public int y ;
public Point(int x ,int y ) {
// TODO Auto-generated constructor stub
super();
this.x = x;
this.y = y;
}
private int addCount(int x,int y) {
return x+y;
}
}
java 反射基础
package test.reflect;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
public class reflect {
public static void main(String[] args) {
try {
// 实例化类Object obj = Animal.class.newInstance();
String[] str = new String[]{};
/**
* 获取方法名称
*/
Method[] m=obj.getClass().getDeclaredMethods();
for (Method method : m) {
Annotation[] an= method.getAnnotations();
for (Annotation annotation : an) {
System.out.println("方法"+method.getName()+"的注解为:"+annotation);
}
/**
* 获取每一个方法中的参数
*/
Class[] paramTypes= method.getParameterTypes();
for (Class class1 : paramTypes) {
System.out.println("方法"+method.getName()+"的参数类型为:"+class1.getName());
}
System.out.println("方法名称："+method.getName());
}
/**
* 数组类型 的话类名前有[L
*/
Class paramClass = Class.forName("[Ljava.lang.String;");
String[] param = { "大象", "猴子", "人", "猫" };
/**
* 反射获取类中的方法
*/
Method method = Animal.class.getMethod("setAnimal", paramClass);
method.invoke(obj, (Object) param);
method = Animal.class.getMethod("getAnimal");
String[] get= (String[]) method.invoke(obj);
// 取值
for (int i = 0; i < get.length; i++) {
System.out.println(get[i]);
}
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Animal {
private String[] animal;
public String[] getAnimal() {
return animal;
}
@Deprecated
public void setAnimal(String[] animal) {
this.animal =animal;
}
private void eat(){
System.out.println("eat what?");
}
}
Java 的反射基础技术
今天本人给大家讲解一下 Java 的反射基础技术，如有不对的或者讲的不好的可以多多提出，我会进行相应的更改，先提前感谢提出意见的各位了！！！
什么是反射？
反射它是根据字节码文件可以反射出类的信息、字段、方法、构造方法等内容，还可以创建对象调用方法，我们称它为反射技术。
如何通过反射获取 Class 对象了？
它有三种方法，1. 通过 Class 获取类对象
2. 通过 getClass () 方法获取类对象
3. 通过 Class.forName (“完整类名”) 获取类对象
案例：通过反射获得 Class 对象的 3 种方法
Class c1 = ReflectionBasic.class;
Class c2 = new ReflectionBasic().getClass();
Class c3 = Class.forName("reflection.getClassObject.ReflectionBasic");
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);运行结果：
注意：Class.forName () 它除了能获取 Class 对象，还可以将获取的类对象自动加载到 JVM 虚拟机的内存中去 ，下面案例的运行结果可以看出代码输出的 static 静态代码块一个泛型的 C4 和 C5 对象，可是只有 C5 输出了 static，这就说明了使用 Class.forName () 可以将类对象加载到 JVM 虚拟机的内存中去。
案例：
//通过输出OtherTest反射对象
Class<?> c4 = OtherTest.class;
System.out.println("此输出对象是C4==============================="+c4);
Class<?> c5 = Class.forName("reflection.getClassObject.OtherTest");
System.out.println("此输出对象是C5==============================="+c4);class OtherTest{
static {
System.out.println("你好呀！！！宝宝们！！！");
}
}运行结果：
获取反射类的信息
在 java.lang.reflect 包下有很多反射类信息的类
反射类的信息
接口类：
public interface IReflection {
}父类：
public class Reflection {
}主类：
public class ReflectionInfo extends Reflection implements IReflection {
public static void main(String[] args) {
//创建类的对象
Class<?> c1 = ReflectionInfo.class;
//获取反射ReflectionInfo类的================================修饰符
int modifiers = c1.getModifiers();//得到的是一个整数那么我们就需要转换了
System.out.println(modifiers);
String sModifiers = Modifier.toString(modifiers);//转换后得到的信息
System.out.println(sModifiers);
System.out.println("以上是获取反射ReflectionInfo类的================================修饰符");
//获取反射ReflectionInfo类的================================完整类名
String name = c1.getName();
System.out.println(name);
//获取反射ReflectionInfo类的================================简易类名
String simpleName = c1.getSimpleName();
System.out.println(simpleName);
System.out.println("以上是获取反射ReflectionInfo类的================================完整类名和简易类名");
//获取反射ReflectionInfo类的================================完整父类名
Class<?> superclass = c1.getSuperclass();
System.out.println(superclass.getSuperclass());
//获取反射ReflectionInfo类的================================简易父类名
System.out.println(superclass.getSimpleName());
System.out.println("以上是获取反射ReflectionInfo类的================================完整父类名和简易父类名");
//获取反射ReflectionInfo类的================================接口，由于接口可以是多个我们需要通过遍历来输出出来
Class<?>[] interfaces = c1.getInterfaces();
if(interfaces.length>0){
for (int i = 0; i < interfaces.length;i++){
//获取反射ReflectionInfo类的================================完整接口名
System.out.println(interfaces[i]);
//获取反射ReflectionInfo类的================================简易接口名
System.out.println(interfaces[i].getSimpleName());
}
}
}
}运行结果：
通过反射技术访问字段（分 private 和 public 修饰）
错误案例：通过 getFile () 方法得到 private 属性的值，会报错
public class AccessFiled {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException {
//创建Class对象
Class<?> c1 = Company.class;
//返回返回的公共字段public
Field field = c1.getField("name");
//通过反射技术创建对象实例，默认调用无参构造哦
Object obj = c1.newInstance();//此方法相当于new一个Company对象
field.set(obj,"无名公司"); //设置name的字段值
System.out.println(obj);
System.out.println(field.get(obj));//输出name的字段值
//返回返回的公共字段public
Field fields = c1.getField("id");
//通过反射技术创建对象实例，默认调用无参构造哦
field.set(obj,"00001"); //设置name的字段值
System.out.println(field.get(obj));//输出name的字段值
}
}
class Company{
public String name;
private int id;
}运行结果：
正确案例：使用getDeclaredField()方法得到private修饰的id值，这个是可以得到任意修饰符修饰的字段
public class AccessFiled {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException {
//创建Class对象
Class<?> c1 = Company.class;
//返回返回的公共字段public
Field field = c1.getField("name");
//通过反射技术创建对象实例，默认调用无参构造哦
Object obj = c1.newInstance();//此方法相当于new一个Company对象
field.set(obj,"无名公司"); //设置name的字段值
System.out.println(obj);
System.out.println(field.get(obj));//输出name的字段值
//返回返回的公共字段public
Field fields = c1.getDeclaredField("id");
//通过反射技术创建对象实例，默认调用无参构造哦
field.set(obj,"00001"); //设置name的字段值
System.out.println(field.get(obj));//输出name的字段值
}
}
class Company{
public String name;
private int id;
}运行结果：
通过反射技术调用方法
public class CallObject {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//创建Class对象
Class<?> c1 = Company.class;
//反射shou()方法
Method method = c1.getMethod("show", null);//前面的参数是方法名。后面的是方法的返回值类型
//通过反射创建实例
Object obj = c1.newInstance();
System.out.println("无参==========="+method.invoke(obj,null ));
System.out.println(obj);
Method shous = c1.getMethod("shows",String.class);
shous.invoke(obj,"无名公司");
//反射shows()方法带（参数列表类型）
System.out.println("有参==========="+obj);;
}
}
class Company{
public String name;
private int id;
public void show(){
System.out.println("show=====方法");
}
public void shows(String name){
System.out.println("shows======方法");
this.name = name;
}
@Override
public String toString() {
return "Company{" +
"name=''" + name + ''\'''' +
", id=" + id +
''}'';
}
}运行结果：
Java 的反射基础讲解完毕，又不懂或者不理解的可以在评论区给本人留言，我会及时回复大家的。
javaAPI_反射_反射基础 2
反射基础知识 2 以及反射的相关应用
1. 通过反射运行配置文件内容
(1). 创建配置文件
class.txt
内容 [可修改]
className=cn.itcast.test.Worker
methodName=love
(2). 要使用的对象 [仅仅为测试方便]
// 学生类
public class Student {
public void love() {
System.out.println ("爱生活，爱 Java");
}
}
// 老师类
public class Teacher {
public void love() {
System.out.println ("爱生活，爱青霞");
}
}
// 工人类
public class Worker {
public void love() {
System.out.println ("爱生活，爱老婆");
}
}
(3). 测试类代码
public static void main(String[] args) throws Exception {
// 反射前的做法
// Student s = new Student();
// s.love();
// Teacher t = new Teacher();
// t.love();
// Worker w = new Worker();
// w.love();
// 反射后的做法
// 加载键值对数据
Properties prop = new Properties();
FileReader fr = new FileReader("class.txt");
prop.load(fr);
fr.close();
// 获取数据
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");
// 反射
Class c = Class.forName(className);
Constructor con = c.getConstructor();
Object obj = con.newInstance();
// 调用方法
Method m = c.getMethod(methodName);
m.invoke(obj);
}
2. 通过反射，越过泛型检查
(1). 要求:
我给你 ArrayList<Integer> 的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？
(2). 代码实现
public static void main(String[] args) throws NoSuchMethodException,
SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
// 创建集合对象
ArrayList<Integer> array = new ArrayList<Integer>();
// array.add("hello");
// array.add(10);
Class c = array.getClass (); // 集合 ArrayList 的 class 文件对象
Method m = c.getMethod("add", Object.class);
m.invoke (array, "hello"); // 调用 array 的 add 方法，传入的值是 hello
m.invoke(array, "world");
m.invoke(array, "java");
System.out.println(array);
}
3. 通过反射写一个通用的设置某一个对象的某个对象的某一个属性为指定的值。
(1). 使用的工具类
public void setProperty(Object obj, String propertyName, Object value)
throws NoSuchFieldException, SecurityException,
IllegalArgumentException, IllegalAccessException {
// 根据对象获取字节码文件对象
Class c = obj.getClass();
// 获取该对象的 propertyName 成员变量
Field field = c.getDeclaredField(propertyName);
// 取消访问检查
field.setAccessible(true);
// 给对象的成员变量赋值为指定的值
field.set(obj, value);
}
(2). 使用测试
public class ToolDemo {
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException {
Person p = new Person();
Tool t = new Tool();
t.setProperty (p, "name", "林青霞");
t.setProperty(p, "age", 27);
System.out.println(p);
System.out.println("-----------");
Dog d = new Dog();
t.setProperty (d, "sex", '' 男 '');
t.setProperty(d, "price", 12.34f);
System.out.println(d);
}
}
class Dog {
char sex;
float price;
@Override
public String toString() {
return sex + "---" + price;
}
}
class Person {
private String name;
public int age;
@Override
public String toString() {
return name + "---" + age;
}
}
4. 动态代理 [*****]
(1). 概述
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
举例：春季回家买票让人代买
动态代理：在程序运行过程中产生的这个对象
而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
(2).java 中的动态代理
在 Java 中 java.lang.reflect 包下提供了一个 Proxy 类和一个 InvocationHandler 接口，通过使用这个类和接口就可以生成动态代理
对象。JDK 提供的代理只能针对接口做代理。我们有更强大的代理 cglibProxy 类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
最终会调用 InvocationHandler 的方法
InvocationHandler
Object invoke(Object proxy,Method method,Object[] args)
注意事项:
Proxy 类中创建动态代理对象的方法的三个参数；
ClassLoader 对象，定义了由哪个 ClassLoader 对象来对生成的代理对象进行加载
Interface 对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就
宣称实现了该接口 (多态)，这样我就能调用这组接口中的方法了
InvocationHandler 对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个 InvocationHandler 对象上
每一个动态代理类都必须要实现 InvocationHandler 这个接口，并且每个代理类的实例都关联到了一个 handler，当我们通过代理对象调用
一个方法的时候，这个方法的调用就会被转发为由 InvocationHandler 这个接口的 invoke 方法来进行调用。
InvocationHandler 接口中 invoke 方法的三个参数：
proxy: 代表动态代理对象
method: 代表正在执行的方法
args: 代表调用目标方法时传入的实参
Proxy.newProxyInstance
创建的代理对象是在 jvm 运行时动态生成的一个对象，它并不是我们的 InvocationHandler 类型，
也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，
以 $ 开头，proxy 为中，最后一个数字表示对象的标号。
System.out.println(u.getClass().getName());
(3). 代码实现
// 一个接口
public interface UserDao {
public abstract void add();
public abstract void delete();
public abstract void update();
public abstract void find();
}
// 一个实现类
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println ("添加功能");
}
@Override
public void delete() {
System.out.println ("删除功能");
}
@Override
public void update() {
System.out.println ("修改功能");
}
@Override
public void find() {
System.out.println ("查找功能");
}
}
// 一个接口
public interface StudentDao {
public abstract void login();
public abstract void regist();
}
// 一个实现类
public class StudentDaoImpl implements StudentDao {
@Override
public void login() {
System.out.println ("登录功能");
}
@Override
public void regist() {
System.out.println ("注册功能");
}
}
// 创建一个动态代理对象类
public class MyInvocationHandler implements InvocationHandler {
private Object target; // 目标对象
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println ("权限校验");
Object result = method.invoke(target, args);
System.out.println ("日志记录");
return result; // 返回的是代理对象
}
}
// 测试类代码
public static void main(String[] args) {
UserDao ud = new UserDaoImpl();
ud.add();
ud.delete();
ud.update();
ud.find();
System.out.println("-----------");
// 我们要创建一个动态代理对象
// Proxy 类中有一个方法可以创建动态代理对象
// public static Object newProxyInstance(ClassLoader loader,Class<?>[]
// interfaces,InvocationHandler h)
// 我准备对 ud 对象做一个代理对象
MyInvocationHandler handler = new MyInvocationHandler(ud);
UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass()
.getClassLoader(), ud.getClass().getInterfaces(), handler);
proxy.add();
proxy.delete();
proxy.update();
proxy.find();
System.out.println("-----------");
StudentDao sd = new StudentDaoImpl();
MyInvocationHandler handler2 = new MyInvocationHandler(sd);
StudentDao proxy2 = (StudentDao) Proxy.newProxyInstance(sd.getClass()
.getClassLoader(), sd.getClass().getInterfaces(), handler2);
proxy2.login();
proxy2.regist();
}
javaAPI_反射_反射基础1
反射基础知识1
1.反射概述
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意
一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件
对应的Class类型的对象.
那么也就是说一个Class文件如果我们想去使用，也就是说它必须包含如下几个成员:
Class类：
成员变量 Field
构造方法 Constructor
成员方法 Method
2.获取class文件对象的三种方式
(1):Object类的getClass()方法
(2):数据类型的静态属性class
(3):Class类中的静态方法，但是传递的参数ClassName需要的是一个全路径
public static Class forName(String className)
(4).如何挑选使用
一般我们到底使用谁呢?
A:自己玩 任选一种，第二种比较方便
B:开发 第三种
为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。
(5).代码测试
//创建对象Person,省略
//测试代码
public static void main(String[] args) throws ClassNotFoundException {
// 方式1
Person p = new Person();
Class c = p.getClass();
Person p2 = new Person();
Class c2 = p2.getClass();
System.out.println(p == p2);// false
System.out.println(c == c2);// true
// 方式2
Class c3 = Person.class;
// int.class;
// String.class;
System.out.println(c == c3);
// 方式3
// ClassNotFoundException
Class c4 = Class.forName("cn.itcast_01.Person");
System.out.println(c == c4);
}
3.反射获取成无参构造
(1).相关方法(注意:返回的是构造方法对象)
public Constructor[] getConstructors():所有公共构造方法(修饰符为Public)
public Constructor[] getDeclaredConstructors():所有构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes):获取单个构造方法
参数表示的是：你要获取的构造方法的构造参数个数及数据类型的
class字节码文件对象
public T newInstance(Object... initargs):
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
其实就是Person p = new Person();
(2).代码测试
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 返回的是构造方法对象
Constructor con = c.getConstructor();
//调用方法声明
Object obj = con.newInstance();
System.out.println(obj);
}
4.反射获取带参构造并使用
(1).相关方法
同上无参构造方法
(3).代码测试
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取带参构造方法对象
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor con = c.getConstructor(String.class, int.class,String.class);
// 通过带参构造方法对象创建对象
// public T newInstance(Object... initargs)
Object obj = con.newInstance("林青霞", 27, "北京");
System.out.println(obj);
}
5.反射获取私有构造并使用
(1).相关方法
同上无参构造方法
(2).代码测试
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取私有构造方法对象
// NoSuchMethodException：每个这个方法异常
// 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。
Constructor con = c.getDeclaredConstructor(String.class);
// 用该私有构造方法创建对象
// IllegalAccessException:非法的访问异常。
// 暴力访问
con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
Object obj = con.newInstance("风清扬");
System.out.println(obj);
}
6.通过反射获取成员变量
(1).相关方法
Field[] getFields();获取公共的成员变量
Field[] getDeclaredFields();获取所有的变量
//获取单个
Field getField(String obj);
Field getDeclaredField
public void set(Object obj,Object value):将指定对象变量上此 Field 对象表示的字段设置为指定的新值
(2).代码实现
//person类代码
public class Person {
private String name;
int age;
public String address;
...
//省略部分代码
}
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 通过无参构造方法创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
System.out.println(obj);
// 获取单个的成员变量
// 获取address并对其赋值
Field addressField = c.getField("address");
// public void set(Object obj,Object value)
// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
System.out.println(obj);
// 获取name并对其赋值
// NoSuchFieldException
Field nameField = c.getDeclaredField("name");
// IllegalAccessException
nameField.setAccessible(true);
nameField.set(obj, "林青霞");
System.out.println(obj);
// 获取age并对其赋值
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 27);
System.out.println(obj);
}
7.反射获取成员方法
(1).获取所有方法
getMethods：获取自己的同时父类的也会拿出来
getDeclaredMethods:仅仅获取自己的所有的方法
(2).获取单个方法
public Method getMethod(String name,Class<?>... parameterTypes):第一个参数表示的方法名，第二个参数表示的是方法的参数的
class类型
public Object invoke(Object obj,Object... args)：返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际
参数
getDeclaredMethod
(3).暴力访问
method.setAccessible(true);
(4).代码实现
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取单个方法并使用
// public void show()
// public Method getMethod(String name,Class<?>... parameterTypes)
// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
Method m1 = c.getMethod("show");
// obj.m1(); // 错误
// public Object invoke(Object obj,Object... args)
// 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
m1.invoke(obj); // 实质就是调用obj对象的m1方法
System.out.println("----------");
// public void method(String s)
Method m2 = c.getMethod("method", String.class);
m2.invoke(obj, "hello");
System.out.println("----------");
// public String getString(String s, int i)
Method m3 = c.getMethod("getString", String.class, int.class);
Object objString = m3.invoke(obj, "hello", 100);
System.out.println(objString);
// String s = (String)m3.invoke(obj, "hello",100);
// System.out.println(s);
System.out.println("----------");
// private void function()
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
我们今天的关于java反射基础应用备注和java反射基础应用备注是什么的分享已经告一段落，感谢您的关注，如果您想了解更多关于java 反射基础、Java 的反射基础技术、javaAPI_反射_反射基础 2、javaAPI_反射_反射基础1的相关信息，请在本站查询。
本文标签：
