java什么是反射技术，什么是java的反射
今天给各位分享java什么是反射技术的知识，其中也会对什么是java的反射进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
什么是java的反射
Java反射指的是对于任何的一个java类，我们都可以通过反射获取到这个类的所有属性和方法(包含私有的属性方法)，使用java反射我们也可以调用一个对象的任何方法。
我们知道Java是一门面向对象编程的语言，我们编程的时候，经常会将类的属性进行封装，然后提供public方法进行属性的设置和获取。类的属性我们通常会设置成private的私有属性，为的就是保护对象属性不被随意的修改和访问。但是反射机制却恰恰相反，通过反射，我们可以获取到这些被保护的属性和方法，并且可以修改和访问他们。
在java中我们可以使用object对象的getClass();方法获得Class的对象classObject;语法格式为 Class classObject= object.getClass();可以根据Class对象的方法获取object对象的相关属性和方法;
获取object对象的名字可以使用 classObject.getName();获取类的名称，获取到的结果包含包的名称;
获取object对象的包名称，可以使用classObject.getPackage();获取包的名称;
获取object对象的所有public属性，可以使用classObject.getFields();方法，返回列表是属性类Field[]对象列表;
获取object对象所有属性,可以使用classObject.getDeclaredFields();方法，返回的是所有属性列表(包含private属性);
获取object对象某个特定的属性,可以使用classObject.getField( fieldName);可以根据属性名称获取属性类的对象;
获取object对象private属性，可以使用classObject.getDeclaredField( fieldName);根据属性名获取属性对象信息;
获取object对象public方法，使用classObject.getMethods();可以获取到方法类Method[]对象列表;
获取object对象某个特定的public方法，使用classObject.getMethod( funName, Class... parameterTypes);根据方法名和方法参数类型列表，可以获取到方法类的对象;
获取object对象所有方法(包含private方法);使用classObject.getDeclaredMethods();可以获取所有的方法对象列表;
获取object对象某个特定方法(包含private方法)，使用classObject.getDeclaredMethod( funName, Class... parameterTypes);根据方法名和方法参数类型列表，可以获取到类的特定方法(包含private方法);
获取object对象类中所有的public构造方法，可以使用classObject.getConstructors();获取到构造类Constructor的对象列表;
获取object对象类中某个特定的构造方法，可以使用classObject.getConstructor( Class... parameterTypes);根据参数类型列表，获取指定的构造函数对象;
获取object对象类中所有的构造方法(包含private)，可以使用classObject.getDeclaredConstructors();获取到构造类Constructor的对象列表;
获取object对象类中某个特定的构造方法(包含private)，可以使用classObject.getDeclaredConstructor( Class... parameterTypes);根据参数类型列表，获取指定的构造函数对象;
java中反射的三种方法是
反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。
反射的好处：大大的增强了程序的扩展性。
反射的基本步骤：
1、获得Class对象，就是获取到指定的名称的字节码文件对象。
2、实例化对象，获得类的属性、方法或构造函数。
3、访问属性、调用方法、调用构造函数创建对象。
获取这个Class对象，有三种方式：
1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。
2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。
前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。
3：使用的Class类中的方法，静态的forName方法。
指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。
// 1.根据给定的类名来获得用于类加载
String classname="cn.itcast.reflect.Person";//来自配置文件
Class clazz= Class.forName(classname);//此对象代表Person.class
// 2.如果拿到了对象，不知道是什么类型用于获得对象的类型
Object obj= new Person();
Class clazz1= obj.getClass();//获得对象具体的类型
// 3.如果是明确地获得某个类的Class对象主要用于传参
Class clazz2= Person.class;
反射的用法：
1）、需要获得java类的各个组成部分，首先需要获得类的Class对象，获得Class对象的三种方式：
Class.forName(classname)用于做类加载
obj.getClass()用于获得对象的类型
类名.class用于获得指定的类型，传参用
2)、反射类的成员方法：
Class clazz= Person.class;
Method method= clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2});
method.invoke();
3)、反射类的构造函数：
Constructor con= clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...})
con.newInstance(params...)
4)、反射类的属性：
Field field= clazz.getField(fieldName);
field.setAccessible(true);
field.setObject(value);
获取了字节码文件对象后，最终都需要创建指定类的对象：
创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)：
1，调用空参数的构造函数：使用了Class类中的newInstance()方法。
2，调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数)进行对象的初始化。
综上所述，第二种方式，必须要先明确具体的构造函数的参数类型，不便于扩展。所以一般情况下，被反射的类，内部通常都会提供一个公有的空参数的构造函数。
------------------------------------------------------
//如何生成获取到字节码文件对象的实例对象。
Class clazz= Class.forName("cn.itcast.bean.Person");//类加载
//直接获得指定的类型
clazz= Person.class;
//根据对象获得类型
Object obj= new Person("zhangsan", 19);
clazz= obj.getClass();
Object obj= clazz.newInstance();//该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？请看method_2();
public static void method_2() throws Exception{
Class clazz= Class.forName("cn.itcast.bean.Person");
//既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。
//获取一个带参数的构造器。
Constructor constructor= clazz.getConstructor(String.class,int.class);
//想要对对象进行初始化，使用构造器的方法newInstance();
Object obj= constructor.newInstance("zhagnsan",30);
//获取所有构造器。
Constructor[] constructors= clazz.getConstructors();//只包含公共的
constructors= clazz.getDeclaredConstructors();//包含私有的
for(Constructor con: constructors){
System.out.println(con);
}
}
------------------------------------------------------
反射指定类中的方法：
//获取类中所有的方法。
public static void method_1() throws Exception{
Class clazz= Class.forName("cn.itcast.bean.Person");
Method[] methods= clazz.getMethods();//获取的是该类中的公有方法和父类中的公有方法。
methods= clazz.getDeclaredMethods();//获取本类中的方法，包含私有方法。
for(Method method: methods){
System.out.println(method);
}
}
//获取指定方法；
public static void method_2() throws Exception{
Class clazz= Class.forName("cn.itcast.bean.Person");
//获取指定名称的方法。
Method method= clazz.getMethod("show", int.class,String.class);
//想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数。
Object obj= clazz.newInstance();
method.invoke(obj, 39,"hehehe");//执行一个方法
}
//想要运行私有方法。
public static void method_3() throws Exception{
Class clazz= Class.forName("cn.itcast.bean.Person");
//想要获取私有方法。必须用getDeclearMethod();
Method method= clazz.getDeclaredMethod("method", null);
//私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式。
method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问。
}
//反射静态方法。
public static void method_4() throws Exception{
Class clazz= Class.forName("cn.itcast.bean.Person");
Method method= clazz.getMethod("function",null);
method.invoke(null,null);
}
java中的反射机制是什么,有什么作用啊
Method类中的方法的使用（含代码和注释）：
getMethods()获得本类及父类中的public权限修饰**符方法
getDeclaredMethods()专门获得调用该方法的对象的本类中的所有方法包括private权限修饰符**的方法
getDeclaredMethod(Stringname,class<?>...parameterTypes)
第一个参数：方法的名称
第二个参数：可变长度，写你要查找的那个方法的参数类型列表.class
getParameterCount()得到方法的参数个数123456
packageLessonForReflection03;importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;abstractclassCard{
privatevoidcreatRandomNumbers(intcount)//private关键字
{
}
publicvoidgetFullCardsNumbers(String[]random,Stringpre_numbers)
{
}
publicstaticvoidgetUserInfor()
{
}
publicabstractvoidgetUserInfor(Stringtel);
publicabstractvoidgetUserInfor(intsal1,intsal2)throwsArrayIndexOutOfBoundsException,ArithmeticException;}publicclassMethodInforGetter{
publicstaticvoidmain(String[]args)
{
Class<?>c1=Card.class;
System.out.println("-------------------------");
Method[]m1=c1.getMethods();//getMethods()获得本类及父类中的public方法！
for(Methodm:m1)
{
System.out.println(m);
}
System.out.println("-------------------------");
Method[]m2=c1.getDeclaredMethods();//getDeclaredMethods()专门获得本类中的所有方法包括private！
for(Methodm:m2)
{
System.out.println(m);
}
System.out.println("-------------------------");
/*
*getDeclaredMethod(Stringname,class<?>...parameterTypes)
*第一个参数：方法的名称
*第二个参数：可变长度，写你要查找的那个方法的参数类型列表
*
*getParameterCount()得到方法的参数个数
*/
try
{
Methodm3=c1.getDeclaredMethod("getUserInfor");
System.out.println(m3);
//getParameterCount()方法,获得方法参数个数
System.out.println(m3.getParameterCount());
System.out.println(Modifier.toString(m3.getModifiers()));//获得方法修饰符
System.out.println(m3.getReturnType());
System.out.println("-------------------------");
Methodm4=c1.getDeclaredMethod("getUserInfor",int.class,int.class);
//getExceptionTypes()可以获得初始化当前Method对象的给Class对象初始化的那个类的那个指定方法抛出的异常类型
Class<?>[]exception=m4.getExceptionTypes();
for(Class<?>e:exception)
{
System.out.println(e);
}
}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}
}}12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
Constructor类中的方法的使用www.xiaoyuani.com（含代码和注释）：
java.lang.reflect.Constructor:
Constructor[]getConstructor()获得本类里的public权限修饰符构造函数，不能获取父类的！
Constructor[]getDeclaredConstructor()获得本类中的所以构造函数！
Constructor<T>getConstructor(Class...parameterType)用参数决定获得本类中的某个的构造方法,只能获得public的
Constructor<T>getDeclaredConstructor(Class...parameterType)用参数决定获得本类中的某个构造方法
附：
JDK8.0之后新增的类：
Executable：
它是Method和Constructor的父类
常用方法：
getParameter()获得类中方法参数
getExceptionTypes()获得类中某个方法抛出异常类型
getMoidfiers()获得方法权限修饰符
Parameter:
封装并代表了参数实例123456789101112131415
packageLessonForReflection03;importjava.lang.reflect.Constructor;importjava.lang.reflect.Modifier;importjava.lang.reflect.Parameter;/*
*java.lang.reflect.Constructor
*
*Constructor[]getConstructor();获得本类里的public权限修饰符构造函数，不能获取父类的
*Constructor[]getDeclaredConstructor();得本类里的全部构造
*
*Constructor<T>getConstructor(Class...parameterType);用参数决定获得哪个构造方法
*Constructor<T>getDeclaredConstructor(Class...parameterType);
*
*/publicclassConstructorInforGetter{
publicstaticvoidmain(String[]args)
{
System.out.println("获得Cricle本类里的public权限修饰符构造函数，不能获取父类的Constructor[]getConstructor()");
System.out.println("子类继承不了父类中的构造方法和private");
//Constructor[]getConstructor()获得Cricle本类里的public权限修饰符构造函数，不能获取父类的
//子类继承不了父类中的构造方法和private
Class<Circle>c1=Circle.class;
Constructor<?>[]cons1=c1.getConstructors();
for(Constructor<?>cons:cons1)
{
System.out.println(cons);
//System.out.println(cons.getName());
}
System.out.println("-----------------------");
System.out.println("方法获得本类中的所有构造函数getDeclaredConstructor()");
Constructor<?>[]cons2=c1.getDeclaredConstructors();
for(Constructor<?>cons:cons2)
{
System.out.println(cons);
}
System.out.println("-----------------------");
try
{
System.out.println("方法用参数指定获得本类！构造方法,只能获取public的Constructor<T>getConstructor(Class...parameterType)");
Constructor<?>cons3=c1.getConstructor(int.class);
System.out.println(Modifier.toString(cons3.getModifiers()));
System.out.println(cons3);
System.out.println("-----------------------");
System.out.println("方法用参数指定获得本类！构造方法任何权限修饰符的都可以获得Constructor<T>getDeclaredConstructor(Class...parameterType)");
Constructor<?>cons4=c1.getDeclaredConstructor(String.class);
System.out.println(cons4);
System.out.println("-----------------------");
/*
*JDK8.0之后新增的类
*Executable：
*是Method和Constructor的父类
*方法：
*getParameter();
*getExceptionTypes();
*getModifiers();
*getTypeParameters();
*
*Parameter:
*封装并代表了参数实例
*/
System.out.println("获取类中方法的参数getParameters()");
Constructor<?>cons5=c1.getDeclaredConstructor(int.class,String.class);
Parameter[]p1=cons5.getParameters();
for(Parameterp:p1)
{
System.out.println(p);
}
}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}
}}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
代码中提到的Circle类和Shape类二者为继承关系：
packageLessonForReflection03;publicclassCircleextendsShape{
privateintr;
privateStringcolor;
publicCircle(intr,Stringcolor)
{
super();
this.r=r;
this.color=color;
}
publicCircle(intr)
{
super();
this.r=r;
}
protectedCircle(Stringcolor)
{
super();
this.color=color;
}
Circle()
{
super();
}}12345678910111213141516171819202122232425262728293031
packageLessonForReflection03;publicclassShape{
privateintper;
publicShape(intper)
{
super();
this.per=per;
}
publicShape()
{
super();
}}1234567891011121314151617
部分文字来源于：
咕嘟咖啡杨海滨老师—《java编程语言高级特性》
轻量化研习Java相关技术倡导者
“爱码学院”联合创始人自适应教学理念提出者践行者；多年开发及项目管理经历；出版《JavaEE企业级应用与开发》一书；10余年高校项目实践毕设指导经验；企业软培经验丰富
好了，文章到这里就结束啦，如果本次分享的java什么是反射技术和什么是java的反射问题对您有所帮助，还望关注下本站哦！