反射

UE4-(反射)反射采集 一、现在有两个反射采集形状:球体和盒体 通常将屏幕空间反射和反射捕获相结合,两者各有优缺点,结合使用是希望同个结合两者的优点来弥补缺点。 大多情况下使用球体反射采集: 效果:不管怎么移动相机位置,屏幕上都会有反射效果。 问题: 当反射采集与屏幕空间反射过渡时,反射画面中的物体位置会发生变化。 原因:当屏幕空间反射过渡到反射捕获,引擎会切换使用两者,但是屏幕空间反射的优先级始终更高。 解释:反射采集会采集一张360度的瞬时图像,用于反射效果。图像中的物体位置与屏幕空间反射出来的物体位 阅读详情
1反射的基石Class类
1.Java类用于描述一类事物的共性,该类事物有什么属性,没有什么属性,至于这个属性的值是什么,则是由这个类的实例对象来确定的,不同的实例对象有不同的属性值。Java程序中的各个Java类,它们是否属于同一类事物,是不是可以用一个类来描述这类事物呢?这个类的名字就是Class,要注意与小写class关键字的区别哦。Class类描述了哪些方面的信息呢?类的名字,类的访问属性,类所属于的包名,字段名称的列表、方法名称的列表,等等。学习反射,首先就要明白Class这个类。写如下代码进行对比理解:
/*Person p1 = new Person("zhangsan");
Person p2 = new Person("lisi");
*/
/*Class x1 = Vector类在内存里的字节码
Class x2 = Date类在内存里的字节码*/
Class x1 = Vector.class;
Class x2 = Date.class;

每个java类都是Class的一个实例对象,它们的内容不同,但是,它们的特征相同,譬如,都有方法,有字段,有父类,有包。
2. ******讲课时要一定画一张图:多个类的字节码装载入内存,在内存中加入一个个方块空间表示字节码,然后用一个个椭圆表示以这个字节码创建出来的实例对象,并用监视代码来说明字节码只被装载一次,而它构造的实例对象的构造方法被调用了多次。用如下代码更进一步说明Class的实例是什么?是一份字节码,一个类在虚拟机中通常只有一份字节码:
Date d1 = new Date();
Class clazz1 = d1.getClass();
Class clazz2 = Date.class;
Class clazz3 = null;
clazz3 = Class.forName("java.util.Date");

if(clazz1==clazz2)
{
System.out.println(clazz1.getName());
}
if(clazz1==clazz3)
{
System.out.println(clazz1.getName());
}
3.一个奇怪的问题:加载了字节码,并调用了其getMethods之类的方法,但是没有看到类的静态代码块被执行,只有在第一个实例对象被创建时,这个静态代码才会被执行。准确的说,静态代码块不是在类加载时被调用的,而是第一个实例对象被创建时才执行的。




反射的基石--Class类

对比提问: Person类代表人,它的实例对象就是张三,李四这样一个个具体的人, Java程序中的各个Java类属于同一类事物,描述这类事物的Java类名就是Class。对比提问:众多的人用一个什么类表示?众多的Java类用一个什么类表示?
人--Person
Java类--Class

Class类代表Java类,它的各个实例对象又分别对应什么呢?
对应各个类在内存中的字节码,例如,Person类的字节码,ArrayList类的字节码,等等。
一个类被类加载器加载到内存中,占用一片存储空间,这个空间里面的内容就是类的字节码,不同的类的字节码是不同的,所以它们在内存中的内容是不同的,这一个个的空间可分别用一个个的对象来表示,这些对象显然具有相同的类型,这个类型是什么呢?

如何得到各个字节码对应的实例对象( Class类型)
类名.class,例如,System.class
对象.getClass(),例如,new Date().getClass()
Class.forName("类名"),例如,Class.forName("java.util.Date");

九个预定义Class实例对象:
参看Class.isPrimitive方法的帮助
Int.class == Integer.TYPE

数组类型的Class实例对象
Class.isArray()
总之,只要是在源程序中出现的类型,都有各自的Class实例对象,例如,int[],void…

Demo:
  1. package cn.itcast;  
  2.   
  3. import java.util.Date;  
  4.   
  5. /** 
  6. * 测试三个字节码是否为同一个字节码 
  7. * @author partner4java 
  8. * 
  9. */  
  10. public class ReflectTest1 {  
  11.     public static void main(String[] args) throws ClassNotFoundException {  
  12.         Date date = new Date();  
  13.         Class date1 = date.getClass();  
  14.         Class date2 = Class.forName("java.util.Date");  
  15.         System.out.println("date1 == date2 ?" + (date1 == date2));  
  16.           
  17.         Class date3 = Date.class;  
  18.         System.out.println("date1 == date3 ?" + (date1 == date3));  
  19.           
  20. //      后台打印:  
  21. //      date1 == date2 ?true  
  22. //      date1 == date3 ?true  
  23.   
  24.     }  
  25.   
  26. }  





Class JDK文档:

public final class Class<T>extends Objectimplements Serializable, GenericDeclaration, Type, AnnotatedElementClass 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类,注释是一种接口。每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也表示为 Class 对象。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

以下示例使用 Class 对象来显示对象的类名:


void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}
还可以使用一个类字面值(JLS Section 15.8.2)来获得命名类型(或 void)的 Class 对象。例如:


System.out.println("The name of class Foo is: "+Foo.class.getName());



方法摘要
<U> Class<? extends U>
asSubclass(Class<U> clazz)
强制转换该 Class 对象,以表示指定的 class 对象所表示的类的一个子类。
T cast(Object obj)
将一个对象强制转换成此 Class 对象所表示的类或接口。
boolean desiredAssertionStatus()
如果要在调用此方法时,将要初始化该类,则返回将分配给该类的断言状态。
static Class<?> forName(String className)
返回与带有给定字符串名的类或接口相关联的 Class 对象。
static Class<?> forName(String name, boolean initialize, ClassLoader loader)
使用给定的类加载器,返回与带有给定字符串名的类或接口相关联的 Class 对象。
<A extends Annotation>
A
getAnnotation(Class<A> annotationClass)
如果存在该元素的指定类型的注释,则返回这些注释,否则返回 null。
Annotation[] getAnnotations()
返回此元素上存在的所有注释。
String getCanonicalName()
返回《Java Language Specification》中所定义的基础类的规范化名称。
Class[] getClasses()
返回一个包含某些 Class 对象的数组,这些对象表示属于此 Class 对象所表示的类的成员的所有公共类和接口,包括从超类和公共类继承的以及通过该类声明的公共类和接口成员。
ClassLoader getClassLoader()
返回该类的类加载器。
Class<?> getComponentType()
返回表示数组组件类型的 Class。
Constructor<T> getConstructor(Class... parameterTypes)
返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。
Constructor[] getConstructors()
返回一个包含某些 Constructor 对象的数组,这些对象反映此 Class 对象所表示的类的所有公共构造方法。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class[] getDeclaredClasses()
返回 Class 对象的一个数组,这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口,包括该类所声明的公共、保护、默认(包)访问及私有类和接口,但不包括继承的类和接口。
Constructor<T> getDeclaredConstructor(Class... parameterTypes)
返回一个 Constructor 对象,该对象反映此 Class 对象所表示的类或接口的指定构造方法。
Constructor[] getDeclaredConstructors()
返回 Constructor 对象的一个数组,这些对象反映此 Class 对象表示的类声明的所有构造方法。
Field getDeclaredField(String name)
返回一个 Field 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
Field[] getDeclaredFields()
返回 Field 对象的一个数组,这些对象反映此 Class 对象所表示的类或接口所声明的所有字段,包括公共、保护、默认(包)访问和私有字段,但不包括继承的字段。
Method getDeclaredMethod(String name, Class... parameterTypes)
返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[] getDeclaredMethods()
返回 Method 对象的一个数组,这些对象反映此 Class 对象表示的类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。
Class<?> getDeclaringClass()
如果此 Class 对象所表示的类或接口是另一个类的成员,则返回的 Class 对象表示该对象的声明类。
Class<?> getEnclosingClass()
返回基础类的立即封闭类。
Constructor<?> getEnclosingConstructor()
如果该 Class 对象表示构造方法中的一个本地或匿名类,则返回 Constructor 对象,它表示基础类的立即封闭构造方法。
Method getEnclosingMethod()
如果此 Class 对象表示某一方法中的一个本地或匿名类,则返回 Method 对象,它表示基础类的立即封闭方法。
T[] getEnumConstants()
如果此 Class 对象不表示枚举类型,则返回枚举类的元素或 null。
Field getField(String name)
返回一个 Field 对象,它反映此 Class 对象所表示的类或接口的指定公共成员字段。
Field[] getFields()
返回一个包含某些 Field 对象的数组,这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
Type[] getGenericInterfaces()
返回表示某些接口的 Type,这些接口由此对象所表示的类或接口直接实现。
Type getGenericSuperclass()
返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的直接超类的 Type。
Class[] getInterfaces()
确定此对象所表示的类或接口实现的接口。
Method getMethod(String name, Class... parameterTypes)
返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Method[] getMethods()
返回一个包含某些 Method 对象的数组,这些对象反映此 Class 对象所表示的类或接口(包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口)的公共 member 方法。
int getModifiers()
返回此类或接口以整数编码的 Java 语言修饰符。
String getName()
以 String 的形式返回此 Class 对象所表示的实体(类、接口、数组类、基本类型或 void)名称。
Package getPackage()
获取此类的包。
ProtectionDomain getProtectionDomain()
返回该类的 ProtectionDomain。
URL getResource(String name)
查找带有给定名称的资源。
InputStream getResourceAsStream(String name)
查找具有给定名称的资源。
Object[] getSigners()
获取此类的标记。
String getSimpleName()
返回源代码中给出的基础类的简称。
Class<? super T> getSuperclass()
返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的超类的 Class。
TypeVariable<Class<T>>[] getTypeParameters()
按声明顺序返回 TypeVariable 对象的一个数组,这些对象表示用此 GenericDeclaration 对象所表示的常规声明来声明的类型变量。
boolean isAnnotation()
如果此 Class 对象表示一个注释类型则返回 true。
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
如果指定类型的注释存在于此元素上,则返回 true,否则返回 false。
boolean isAnonymousClass()
当且仅当基础类是匿名类时返回 true。
boolean isArray()
判定此 Class 对象是否表示一个数组类。
boolean isAssignableFrom(Class<?> cls)
判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同,或是否是其超类或超接口。
boolean isEnum()
当且仅当该类声明为源代码中的枚举时返回 true。
boolean isInstance(Object obj)
判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。
boolean isInterface()
判定指定的 Class 对象是否表示一个接口。
boolean isLocalClass()
当且仅当基础类是本地类时返回 true。
boolean isMemberClass()
当且仅当基础类是成员类时返回 true。
boolean isPrimitive()
判定指定的 Class 对象是否表示一个基本类型。
boolean isSynthetic()
如果此类是复合类,则返回 true,否则 false。
T newInstance()
创建此 Class 对象所表示的类的一个新实例。
String toString()
将对象转换为字符串。



2反射

反射就是把Java类中的各种成分映射成相应的java类。例如,一个Java类中用一个Class类的对象来表示,一个类中的组成部分:成员变量,方法,构造方法,包等等信息也用一个个的Java类来表示,就像汽车是一个类,汽车中的发动机,变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法,来获得其中的变量,方法,构造方法,修饰符,包等信息,这些信息就是用相应类的实例对象来表示,它们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示,通过调用Class类的方法可以得到这些实例对象后,得到这些实例对象后有什么用呢?怎么用呢?这正是学习和应用反射的要点。



3Constructor类
Constructor类代表某个类中的一个构造方法

得到某个类所有的构造方法:
例子:Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法:
例子: Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
//获得方法时要用到类型

创建实例对象:
通常方式:String str = new String(new StringBuffer("abc"));
反射方式: String str = (String)constructor.newInstance(new StringBuffer("abc"));
//调用获得的方法时要用到上面相同类型的实例对象

Class.newInstance()方法:
例子:String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法,然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢?用到了缓存机制来保存默认构造方法的实例对象。





Constructor<T> JDK文档:
public final class Constructor<T>extends AccessibleObjectimplements GenericDeclaration, MemberConstructor 提供关于类的单个构造方法的信息以及对它的访问权限。

Constructor 允许在将实参与带有基础构造方法的形参的 newInstance() 匹配时进行扩展转换,但是如果发生收缩转换,则抛出 IllegalArgumentException。

方法摘要
boolean equals(Object obj)
将此 Constructor 对象与指定的对象进行比较。
<T extends Annotation>
T
getAnnotation(Class<T> annotationClass)
如果存在该元素的指定类型的注释,则返回这些注释,否则返回 null。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class<T> getDeclaringClass()
返回 Class 对象,该对象表示声明由此 Constructor 对象表示的构造方法的类。
Class<?>[] getExceptionTypes()
返回一组表示声明要抛出的异常类型的 Class 对象,这些异常是由此 Constructor 对象表示的基础构造方法抛出的。
Type[] getGenericExceptionTypes()
返回一组 Type 对象,这些对象表示声明要由此 Constructor 对象抛出的异常。
Type[] getGenericParameterTypes()
按照声明顺序返回一组 Type 对象,这些对象表示此 Constructor 对象所表示的方法的形参类型。
int getModifiers()
以整数形式返回此 Constructor 对象所表示构造方法的 Java 语言修饰符。
String getName()
以字符串形式返回此构造方法的名称。
Annotation[][] getParameterAnnotations()
按照声明顺序返回一组数组,这些数组表示通过此 Method 对象表示的方法的形参上的注释。
Class<?>[] getParameterTypes()
按照声明顺序返回一组 Class 对象,这些对象表示此 Constructor 对象所表示构造方法的形参类型。
TypeVariable<Constructor<T>>[] getTypeParameters()
按照声明顺序返回一组 TypeVariable 对象,这些对象表示通过此 GenericDeclaration 对象所表示的一般声明来声明的类型变量。
int hashCode()
返回此 Constructor 的哈希码。
boolean isSynthetic()
如果此构造方法是一个复合构造方法,则返回 true;否则返回 false。
boolean isVarArgs()
如果声明此构造方法可以带可变数量的参数,则返回 true;否则返回 false。
T newInstance(Object... initargs)
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。
String toGenericString()
返回描述此 Constructor 的字符串,其中包括类型参数。
String toString()
返回描述此 Constructor 的字符串。





4Field类
  1. Field类代表某个类中的一个成员变量  
  2.   
  3. ReflectPoint point = new ReflectPoint(1,7);  
  4. Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");  
  5. System.out.println(y.get(point));  
  6. //Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");  
  7. Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");  
  8. x.setAccessible(true);  
  9. System.out.println(x.get(point));  
  10.   
  11. Demo:  
  12. package cn.itcast;  
  13.   
  14. import java.io.Serializable;  
  15.   
  16. public class User implements Serializable {  
  17.     private String username;  
  18.     private String password;  
  19.     private static String ENCRYPT_TYPE = "MD5";  
  20.     public User(String username, String password) {  
  21.         super();  
  22.         this.username = username;  
  23.         this.password = password;  
  24.     }  
  25.     public String getUsername() {  
  26.         return username;  
  27.     }  
  28.     public void setUsername(String username) {  
  29.         this.username = username;  
  30.     }  
  31.     public String getPassword() {  
  32.         return password;  
  33.     }  
  34.     public void setPassword(String password) {  
  35.         this.password = password;  
  36.     }  
  37.     public static String getENCRYPT_TYPE() {  
  38.         return ENCRYPT_TYPE;  
  39.     }  
  40.       
  41.       
  42. }  
  43.   
  44. package cn.itcast;  
  45.   
  46. /** 
  47. * 改变了本不允许改变的字段 
  48. * 要看清楚,为什么ENCRYPT_TYPE字段,可以从String.class里面取,而password必须从User里面取 
  49. * @author partner4java 
  50. *  
  51. */  
  52. public class Field {  
  53.   
  54.     public static void main(String[] args) throws SecurityException,  
  55.             NoSuchFieldException, IllegalArgumentException,  
  56.             IllegalAccessException {  
  57.         get1();  
  58.     }  
  59.   
  60.     private static void get1() throws NoSuchFieldException,  
  61.             IllegalAccessException {  
  62.         User user = new User("partner4java", "123456");  
  63.         User user2 = new User("partner4java2", "1234562");  
  64.         java.lang.reflect.Field encryptType = user.getClass().getDeclaredField(  
  65.                 "ENCRYPT_TYPE");  
  66.         encryptType.setAccessible(true);  
  67.         System.out.println(encryptType.get(String.class));  
  68.   
  69.         encryptType.set(String.class, "MD6");  
  70.         System.out.println(user.getENCRYPT_TYPE());  
  71.         System.out.println(user2.getENCRYPT_TYPE());  
  72.   
  73.         System.out.println();  
  74.   
  75.         java.lang.reflect.Field passworld = user.getClass().getDeclaredField(  
  76.                 "password");  
  77.         passworld.setAccessible(true);  
  78.         System.out.println(passworld.get(user));  
  79.   
  80.         passworld.set(user, "654321");  
  81.         System.out.println(user.getPassword());  
  82.         System.out.println(user2.getPassword());  
  83.   
  84.         // 后台打印:  
  85.         // MD5  
  86.         // MD6  
  87.         // MD6  
  88.         //  
  89.         // 123456  
  90.         // 654321  
  91.         // 1234562  
  92.   
  93.     }  
  94.   
  95. }  

Field JDK说明:
public final class Fieldextends AccessibleObjectimplements MemberField 提供有关类或接口的单个字段的信息,以及对它的动态访问权限。反射的字段可能是一个类(静态)字段或实例字段。

Array 允许在执行 get 或 set 访问操作期间进行扩展转换,但如果将发生收缩转换,则抛出一个 IllegalArgumentException。

方法摘要
boolean equals(Object obj)
将此 Field 与指定对象比较。
Object get(Object obj)
返回指定对象上此 Field 表示的字段的值。
<T extends Annotation>
T
getAnnotation(Class<T> annotationClass)
如果存在该元素的指定类型的注释,则返回这些注释,否则返回 null。
boolean getBoolean(Object obj)
获得一个静态或实例 boolean 字段的值。
byte getByte(Object obj)
获得一个静态或实例 byte 字段的值。
char getChar(Object obj)
获得 char 类型或另一个通过扩展转换可以转换为 char 类型的基本类型的静态或实例字段的值。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class<?> getDeclaringClass()
返回表示类或接口的 Class 对象,该类或接口声明由此 Field 对象表示的字段。
double getDouble(Object obj)
获得 double 类型或另一个通过扩展转换可以转换为 double 类型的基本类型的静态或实例字段的值。
float getFloat(Object obj)
获得 float 类型或另一个通过扩展转换可以转换为 float 类型的基本类型的静态或实例字段的值。
Type getGenericType()
返回一个 Type 对象,它表示此 Field 对象所表示字段的声明类型。
int getInt(Object obj)
获得 int 类型或另一个通过扩展转换可以转换为 int 类型的基本类型的静态或实例字段的值。
long getLong(Object obj)
获得 long 类型或另一个通过扩展转换可以转换为 long 类型的基本类型的静态或实例字段的值。
int getModifiers()
以整数形式返回由此 Field 对象表示的字段的 Java 语言修饰符。
String getName()
返回此 Field 对象表示的字段的名称。
short getShort(Object obj)
获得 short 类型或另一个通过扩展转换可以转换为 short 类型的基本类型的静态或实例字段的值。
Class<?> getType()
返回一个 Class 对象,它标识了此 Field 对象所表示字段的声明类型。
int hashCode()
返回该 Field 的哈希码。
boolean isEnumConstant()
如果此字段表示枚举类型的元素,则返回 true;否则返回 false。
boolean isSynthetic()
如果此字段是复合字段,则返回 true;否则返回 false。
void set(Object obj, Object value)
将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
void setBoolean(Object obj, boolean z)
将字段的值设置为指定对象上的一个 boolean 值。
void setByte(Object obj, byte b)
将字段的值设置为指定对象上的一个 byte 值。
void setChar(Object obj, char c)
将字段的值设置为指定对象上的一个 char 值。
void setDouble(Object obj, double d)
将字段的值设置为指定对象上的一个 double 值。
void setFloat(Object obj, float f)
将字段的值设置为指定对象上的一个 float 值。
void setInt(Object obj, int i)
将字段的值设置为指定对象上的一个 int 值。
void setLong(Object obj, long l)
将字段的值设置为指定对象上的一个 long 值。
void setShort(Object obj, short s)
将字段的值设置为指定对象上的一个 short 值。
String toGenericString()
返回一个描述此 Field(包括其一般类型)的字符串。
String toString()
返回一个描述此 Field 的字符串。




5Method类
Method类代表某个类中的一个成员方法

得到类中的某一个方法:
例子: Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

调用方法:
通常方式:System.out.println(str.charAt(1));
反射方式: System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null,这有着什么样的意义呢?说明该Method对象对应的是一个静态方法!

jdk1.4和jdk1.5的invoke方法的区别:
Jdk1.5:public Object invoke(Object obj,Object... args)
Jdk1.4:public Object invoke(Object obj,Object[] args),即按jdk1.4的语法,需要将一个数组作为参数传递给invoke方法时,数组中的每个元素分别对应被调用方法中的一个参数,所以,调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

Demo:
  1. package cn.itcast;  
  2.   
  3. import java.lang.reflect.Constructor;  
  4. import java.lang.reflect.InvocationTargetException;  
  5. import java.lang.reflect.Method;  
  6.   
  7. /** 
  8. * 注意我只有一个无参的构造器 
  9. * 然后,每个test都是每一步递增的解决问题 
  10. * @author partner4java 
  11. * 
  12. */  
  13. public class RegUser {  
  14.     static{  
  15.         System.out.println("Class static area");  
  16.     }  
  17.       
  18.     public RegUser() {  
  19.         System.out.println("Constructor");  
  20.     }  
  21.       
  22.     public RegUser(String message) {  
  23.         System.out.println("Constructor " + message);  
  24.     }  
  25.       
  26.     public void regUser1() {  
  27.         System.out.println("class method regUser1");  
  28.     }  
  29.       
  30.     public static void regUser2(){  
  31.         System.out.println("static method regUser2");  
  32.     }  
  33.       
  34.     public static void main(String[] args) throws Exception {  
  35. //      test1();  
  36. //      test2();  
  37. //      test3();  
  38. //      test4();  
  39. //      test5();  
  40. //      test6();  
  41. //      test7();  
  42.     }  
  43.   
  44.     /** 
  45.      * 只执行了static静态块 
  46.      */  
  47.     private static void test1() {  
  48.         Class regUser = RegUser.class;  
  49. //      后台打印:  
  50. //      Class static area  
  51.   
  52.     }  
  53.   
  54.     /** 
  55.      * 只执行了static静态块 
  56.      */  
  57.     private static void test2() throws ClassNotFoundException {  
  58.         Class regUser = Class.forName("cn.itcast.RegUser");  
  59. //      后台打印:  
  60. //      Class static area  
  61.   
  62.     }  
  63.       
  64.     /** 
  65.      * 报错:不是一个已经初始化的class 
  66.      */  
  67.     private static void test3() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {  
  68.         Class regUser = RegUser.class;  
  69.         Method regUser1 = regUser.getMethod("regUser1", null);  
  70.         regUser1.invoke(regUser, null);  
  71. //      后台打印:  
  72. //      Exception in thread "main" java.lang.IllegalArgumentException: object is not an instance of declaring class  
  73. //      Class static area  
  74.     }  
  75.   
  76.     /** 
  77.      * 这个测试是去掉了有参的构造器 
  78.      */  
  79.     private static void test4() throws InstantiationException, IllegalAccessException {  
  80.         Class regUser = RegUser.class;  
  81.         regUser.newInstance();  
  82. //      后台打印:  
  83. //      Class static area  
  84. //      Exception in thread "main" java.lang.InstantiationException: cn.itcast.RegUser  
  85.     }  
  86.       
  87.     /** 
  88.      * 通过获取构造器,调用了构造器 
  89.      */  
  90.     private static void test5() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {  
  91.         Class regUser = RegUser.class;  
  92.         Constructor constructor = regUser.getConstructor(String.class);  
  93.         constructor.newInstance("Hello World!");  
  94. //      后台打印:  
  95. //      Class static area  
  96. //      Constructor Hello World!  
  97.   
  98.     }  
  99.       
  100.     /** 
  101.      * 执行了非静态的regUser1方法 
  102.      */  
  103.     private static void test6() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {  
  104.         Class regUser = RegUser.class;  
  105.         Constructor constructor = regUser.getConstructor(String.class);  
  106.           
  107.         RegUser regUserC = (RegUser) constructor.newInstance("Hello World!");  
  108.   
  109.         Method regUser1 = regUserC.getClass().getMethod("regUser1", null);  
  110.         regUser1.invoke(regUserC, null);  
  111. //      后台打印:  
  112. //      Class static area  
  113. //      Constructor Hello World!  
  114. //      class method regUser1  
  115.     }  
  116.       
  117.   
  118.     /** 
  119.      * 静态方法的调用,并不需要new出来一个class(或者说,并没有调用构造器,就本身存在了静态方法) 
  120.      */  
  121.     private static void test7() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {  
  122.         Class regUser = RegUser.class;  
  123.         Method regUser2 = regUser.getMethod("regUser2", null);  
  124.         regUser2.invoke(null, null);  
  125. //      后台打印:  
  126. //      Class static area  
  127. //      static method regUser2  
  128.   
  129.     }  
  130. }  


用反射方式执行某个类中的main方法:
目标:
写一个程序,这个程序能够根据用户提供的类名,去执行该类中的main方法。用普通方式调完后,大家要明白为什么要用反射方式去调啊?

问题:
启动Java程序的main方法的参数是一个字符串数组,即public static void main(String[] args),通过反射方式来调用这个main方法时,如何为invoke方法传递参数呢?按jdk1.5的语法,整个数组是一个参数,而按jdk1.4的语法,数组中的每个元素对应一个参数,当把一个字符串数组作为参数传递给invoke方法时,javac会到底按照哪种语法进行处理呢?jdk1.5肯定要兼容jdk1.4的语法,会按jdk1.4的语法进行处理,即把数组打散成为若干个单独的参数。所以,在给main方法传递参数时,不能使用代码mainMethod.invoke(null,new String[]{“xxx”}),javac只把它当作jdk1.4的语法进行理解,而不把它当作jdk1.5的语法解释,因此会出现参数类型不对的问题。

解决办法:
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ,编译器会作特殊处理,编译时不把参数当作数组看待,也就不会数组打散成若干个参数了



Method JDK文档:
public final class Methodextends AccessibleObjectimplements GenericDeclaration, MemberMethod 提供关于类或接口上单独某个方法(以及如何访问该方法)的信息。所反映的方法可能是类方法或实例方法(包括抽象方法)。

Method 允许在匹配要调用的实参与基础方法的形参时进行扩展转换;但如果要进行收缩转换,则会抛出 IllegalArgumentException。

方法摘要
boolean equals(Object obj)
将此 Method 与指定对象进行比较。
<T extends Annotation>
T
getAnnotation(Class<T> annotationClass)
如果存在该元素的指定类型的注释,则返回这些注释,否则返回 null。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class<?> getDeclaringClass()
返回表示声明由此 Method 对象表示的方法的类或接口的 Class 对象。
Object getDefaultValue()
返回由此 Method 实例表示的注释成员的默认值。
Class<?>[] getExceptionTypes()
返回 Class 对象的数组,这些对象描述了声明将此 Method 对象表示的基础方法抛出的异常类型。
Type[] getGenericExceptionTypes()
返回 Type 对象数组,这些对象描述了声明由此 Method 对象抛出的异常。
Type[] getGenericParameterTypes()
按照声明顺序返回 Type 对象的数组,这些对象描述了此 Method 对象所表示的方法的形参类型的。
Type getGenericReturnType()
返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象。
int getModifiers()
以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符。
String getName()
以 String 形式返回此 Method 对象表示的方法名称。
Annotation[][] getParameterAnnotations()
返回表示按照声明顺序对此 Method 对象所表示方法的形参进行注释的那个数组的数组。
Class<?>[] getParameterTypes()
按照声明顺序返回 Class 对象的数组,这些对象描述了此 Method 对象所表示的方法的形参类型。
Class<?> getReturnType()
返回一个 Class 对象,该对象描述了此 Method 对象所表示的方法的正式返回类型。
TypeVariable<Method>[] getTypeParameters()
返回 TypeVariable 对象的数组,这些对象描述了由 GenericDeclaration 对象表示的一般声明按声明顺序来声明的类型变量。
int hashCode()
返回此 Method 的哈希码。
Object invoke(Object obj, Object... args)
对带有指定参数的指定对象调用由此 Method 对象表示的基础方法。
boolean isBridge()
如果此方法是 bridge 方法,则返回 true;否则,返回 false。
boolean isSynthetic()
如果此方法为复合方法,则返回 true;否则,返回 false。
boolean isVarArgs()
如果将此方法声明为带有可变数量的参数,则返回 true;否则,返回 false。
String toGenericString()
返回描述此 Method 的字符串,包括类型参数。
String toString()
返回描述此 Method 的字符串。



6数组的反射
具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

基本类型的一维数组可以被当作Object类型使用,不能当作Object[]类型使用;非基本类型的一维数组,既可以当做Object类型使用,又可以当做Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时的差异。

Array工具类用于完成对数组的反射操作。


--------------
附注:
Object[] 与String[]没有父子关系,Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成new String[]{“aaa”,”bb”};,Object x = “abc”能强制转换成String x = “abc”。
main.invoke(null, (Object)(new Object[]{“aaa”,“xxx”}));不能调用public static void main(String [] args)

1.
看Class类帮助文档开始部分的介绍。
String[] a1 = new String[8];
String[] a2 = new String[9];
String[][] a3 = new String[6][4];
().getName());
System.out.println(a3.getClass().getName());
System.out.println(a1.getClass() == a2.getClass());
System.out.println(a1.getClass() == a3.getClass());
2.
看getSuperClass方法的帮助
System.out.println(a1.getClass().getSuperclass().getName());
3.
int[] a = new int[3];
Object obj = a;
//Object[] obj1 = a //有错!
Object[] obj3 = a1
Object obj4 = a3;
if(obj4 instanceof String[][]){
System.out.println(obj1.getClass().isArray());
}
**在这里分析研究Arrays.asList()方法处理int[]和String[]时的差异,以及Arrays.deepToString()方法不能处理int[],但能处理String[]的原因。
4.
private static void printObject(Object obj) {
if(obj.getClass().isArray()){
int len = Array.getLength(obj);
for(int i=0;i<len;i++) {
System.out.println(Array.get(obj, i));
}
} else {
System.out.println(obj);
}
}
5.
需要取出每个元素对象,然后再对各个对象进行判断,因为其中每个具体元素的类型都可以不同,例如Object[] x = new Object[]{“abc”,Integer.Max}。
--------------



7反射的作用实现框架功能
框架与框架要解决的核心问题
我做房子卖给用户住,由用户自己安装门窗和空调,我做的房子就是框架,用户需要使用我的框架,把门窗插入进我提供的框架中。框架与工具类有区别,工具类被用户的类调用,而框架则是调用用户提供的类。

框架要解决的核心问题
我在写框架(房子)时,你这个用户可能还在上小学,还不会写程序呢?我写的框架程序怎样能调用到你以后写的类(门窗)呢?
因为在写才程序时无法知道要被调用的类名,所以,在程序中无法直接new 某个类的实例对象了,而要用反射方式来做。

综合案例
先直接用new 语句创建ArrayList和HashSet的实例对象,演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法,比较两个集合的运行结果差异。
然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象,比较观察运行结果差异。
引入了elipse对资源文件的管理方式的讲解。


附言:
什么是框架,例如,我们要写程序扫描.java文件中的注解,要解决哪些问题:读取每一样,在每一个中查找@,找到的@再去查询一个列表,如果@后的内容出现在了列表中,就说明这是一个我能处理和想处理的注解,否则,就说明它不是一个注解或者说至少不是一个我感兴趣和能处理的注解。接着就编写处理这个注解的相关代码。现在sun提供了一个apt框架,它会完成所有前期工作,只需要我们提供能够处理的注解列表,以及处理这些注解的代码。Apt框找到我们感兴趣的注解后通知或调用我们的处理代码去处理。
你做的门调用锁,锁是工具,你做的门被房子调用,房子是框架,房子和锁都是别人提供的。

程序中不处理异常,而是main方法声明抛出异常,便于大家可以集中看主要的关键代码。

Class类也提供getResourceAsStream方法的比喻:如果你每次都找我给你商店买可乐,那我还不如直接向你买可乐,即直接提供一个买可乐的方法给你。


public static void main(String[] args) throws Exception{
//应该先直接用ArrayList和HashSet,然后才引入从配置文件读,这样便于学员学习。
Properties props = new Properties();
//先演示相对路径的问题
//InputStream ips = new FileInputStream("config.properties");
/*一个类加载器能加载.class文件,那它当然也能加载classpath环境下的其他文件,既然它有如此能力,它没有理由不顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意:直接使用类加载器时,不能以/打头。*/
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/javaenhance/config.properties");
//Class提供了一个便利方法,用加载当前类的那个类加载器去加载相同包目录下的文件
//InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");
InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/javaenhance/config.properties");
props.load(ips);
Ips.close();

String className = props.getProperty("className");
Class clazz = Class.forName(className);

Collection collection = (Collection)clazz.newInstance();
//Collection collection = new ArrayList();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
collection.add(pt1);
collection.add(pt2);
collection.add(pt3);
collection.add(pt1);
System.out.println(collection.size());
} 
Java反射 Java的反射(reflection)机制是指在程序的运行状态中,借助取得任何类的内部信息,可以动态地构造任意一个类的对象,并能直接操作任意对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。反射主要用到java.lang.Class类和包下的一些类,是 Java 反射机制的核心包,提供了操作类及其成员(字段、方法、构造函数等)的类和接口。表示类的对象。提供了获取类的字段、方法、构造函数等方法。 阅读详情

相关推荐

正反射和负反射的含义:

​正反射和负反射的含义: 前两节我们讨论反射的过程中,一直使用电压数值来计算反射量的大小。使用电压数值来计算理想方波信号(上升时间为0)的上升沿引起的反射现象的确很方便,尽管在数值上是正确的,但是这种方式有可能会造成理解上的误区。问题的关键在于:使用数值是否合理?该如何处理数值? 接下来讨论一个很有趣的问题:理想方波下降沿的反射。如果传输线末端开路,驱动器输出阻抗小于传输线的特征阻抗,末端波形会是什么样的?下降沿后信号电平为0V,信号到达末端,由于末端开路,反射系数为1。如果使用电压数值计算,根据反射电

2401_87854160的博客 916

Java.lang.Class类 getEnclosingMethod()方法有什么功能呢?

Java.lang.Class类 getEnclosingMethod()方法的功能简介说明

qq_25073223的博客 1135

反射一、反射的基本概念

Java程序在编写完成之后,为了能够运行,首先会被编译为class文件。然后,在Java程序的运行过程当中,每当需要一个新的类,就需要将其对应的class文件加载到JVM虚拟机当中。加载class文件的叫作ClassLoader。 JDK具有多个层次的ClassLoader,最根上的那个叫作BootStrap ClassLoader,负责加载JDK中最核心的类。BootStrap ClassLo...

sun_lm的博客 2677

java 根据类名示例化类_Java类类getEnclosingMethod()方法及示例

java 根据类名示例化类 类类getEnclosingMethod()方法 (Class class getEnclosingMethod() method) getEnclosingMethod() method is available in java.lang package. getEnclosingMethod()方法在java.lang包中可用。 getEnclosingMethod...

cumt30111的博客 1352

关于反射探头的实时反射

用反射探头实现镜面反射 之前看到过一个日本人写的文章,关于如何使用Unity的反射探头来实现地板的镜面反射效果。 文章地址:http://nn-hokuson.hatenablog.com/entry/2016/10/17/202135。 核心代码很短,主要是根据下图所示实时更新反射探头的位置: 先贴一下位置计算的代码: using System.Collections; using Syste...

weixin_45979158的博客 1041

md6加密函数

这是针对MD5加密的改良版,增强型加密,弥补了MD5容易被破解的缺陷。

Java基础5大机制——反射机制详解(一)

一、反射的概述 JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象. 下面是详细说明: ...

qq_37080455的博客 879

Java上传文件错误java.lang.NoSuchMethodException的解决办法

今天小编就为大家分享一篇关于Java上传文件错误java.lang.NoSuchMethodException的解决办法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧

Java 反射之 GenericDeclaration

java.lang.reflect.GenericDeclaration是Java反射包中,所有可以声明泛型类型的语法元素的父接口; public interface GenericDeclaration extends AnnotatedElement { /** * Returns an array of {@code TypeVariable} objects that ...

来啊 快活啊 1099

Java源码解析之GenericDeclaration详解

主要介绍了Java源码解析之GenericDeclaration详解。有句古话说得好,源码能使人快乐!这里分享给大家,供需要的朋友参考。

Endnote 导入参考文献的时候,格式错误太多了。et.al错误,国标GBT7714在endnote中的详细配置教程,适用于本科,硕士论文文献插入的模板

EndNote插入文献常遇到以下错误主要如下: 等、et al不分; 英文作者全名大写; 期刊名字使用了缩写(图片里没有体现;卷号、期号缺失时出现乱码,多了半个括号;页码范围略去了相同部分;没有悬挂缩进,本文全部解决,全网最细

sakura的博客 3万+

java md6_java加密解密研究6、MD算法家族

一、简述MD5算法是典型的消息摘要算法,其前身有MD2、MD3和MD4算法,它由MD4、MD3和MD2算法改进而来。不论是哪一种MD算法,它们都需 要获得一个随机长度的信息并产生一个123位的信息摘要。如果将这个128位的二进制摘要信息换算成十六进制,可以得到一个32位的字符串,故我们见到的 大部分MD5算法的数字指纹都是32为十六进制的字符串。MD算法家族的发展史:MD2算法:1989年,著名的...

weixin_33034651的博客 988

论文阅读------Exposure Fusion: A Simple and Practical Alternative to High Dynamic Range Photography

Mertens T, Kautz J, Van Reeth F. Exposure fusion: A simple and practical alternative to high dynamic range photography[C]//Computer graphics forum. Oxford, UK: Blackwell Publishing Ltd, 2009, 28(1): 161-171. 摘要 本文提出了一种将包围曝光的序列融合到高质量图像中的技术,而无需先转换为高动态范围(HD.

qq_25283239的博客 3398

Java 反射

反射(reflection)是 Java 中的一项特性,它允许程序在运行时查询和操作类的信息。即,在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能调用它的任意方法和属性。获取到方法和属性后,就可以对其进行修改。这种动态获取信息以及动态调用对象方法的功能也就是Java的反射机制

2301_76161469的博客 8778

基于Simplis仿真的UC2843芯片建模与关键参数优化指南

本文详细介绍了使用Simplis仿真工具为UC2843 PWM控制器进行行为级建模的方法与关键参数优化实践。通过精确搭建芯片内部振荡器、误差放大器及电流采样等核心模块,工程师可以深入理解其工作原理,并利用模型优化振荡频率、最大占空比及反馈环路等关键参数,从而提升开关电源设计的效率与可靠性。

efc1234567的博客 462

评价模型——层次分析法(AHP)与熵权法(EWM)

层次分析法是定性与定量结合的多准则决策、评价方法。将决策的有关元素分解成目标层、准则层和方案层,并通过人们的判断对决策方案的优劣进行排序,在此基础上进行定性和定量分析。它把人的思维过程层次化、数量化,并用数学为分析、决策、评价、预报和控制提供定量的依据。

好好学习 天天向上 2万+

UE4-(反射)平面反射

一、创建 注意:平面反射拖拽到场景后,会创建一大块平面,这个平面是临时创建的,当程序运行后,我们不会看到这个平面。 平面反射会捕获反射信息,只能用于平面反射效果,所以只适用于平整的对象,例如镜子,水池水面、窗户玻璃。任何尺寸较小表面平整的对象,都可以用平面反射覆盖。 二、属性 1.平面反射既可以实时渲染,也可以一次性捕获(属性面板中设置) 平面反射使用实时渲染,性能开销非常大,因为平面反射实际上将从反射方向再次对关卡进行渲染。所以要比屏幕空间反射更加精确。 对比: 左侧屏幕空间反射..

Stone的博客 1万+

unity shader 后处理实现水墨风格渲染「Low Poly 」变「水墨画 」

水墨风格渲染 这次学校的比赛打算做一个中国古代背景的游戏,所以尝试做了水墨风格的渲染。 主要按以下四步来实现的效果: 根据色调和饱和度调整饱和度。 对图像进行模糊 水墨风格的物体边缘 物体内画笔笔触的模拟 接下来我分别就这四步依次展开说明: 调整饱和度 这里我使用Post-Processing Stack 的Color Grading 来调节饱和度,通过使用Grading Curv...

九级铁甲蛹的博客 1万+

java反射&python反射

作为一只主学java,次学python的猿,反射的梗,怎能不知道 一、反射是什么: 维基百科上给出的定义:在计算机科学中,反射是指计算机程序在运行时(Run time)可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说,反射就是程序在运行的时候能够“观察”并且修改自己的行为。 以我浅薄的编程思想理解的反射: 反射可以让我们在不打开程序文件的情况下,清楚的知道该程序的内部结构...

远处 1476

大型我的世界RPG服务器开服全攻略:从环境配置到插件部署

搭建一个能支撑百人稳定在线的我的世界服务器,远不止选择服务端和安装插件那么简单。服务器架设涉及硬件选型、Java环境、端口放行、启动脚本与systemd守护等基础环节,而大型RPG玩法还依赖MythicMobs、Quests、LuckPerms等插件协同工作。理解这些技术组件的原理与配置逻辑,是确保长线运营的关键。对于希望打造原创剧情、职业副本和自定义Boss的团队而言,合理规划MySQL数据库、RCON批量管理及性能调优,能显著降低后期维护成本。本文围绕RPG服务器核心能力,从环境准备到插件部署,再到常见

weixin_27230891的博客 370

基于Simulink的发动机管理系统中的自适应增压控制系统设计

通过上述详细设计步骤,我们成功开发了一个基于Simulink的自适应增压控制系统。该系统不仅能够实时监测和预测发动机的运行状态,动态调整增压压力目标值,还具备实时监控、故障诊断和保护功能,确保系统的安全性和可靠性。此外,通过仿真实验和硬件在环测试,我们验证了系统的性能,并对其进行了优化,使其能够更好地满足实际应用需求。这个项目展示了如何利用MATLAB/Simulink的强大功能,结合控制理论和工程实践,开发出高效、可靠的自适应增压控制系统。

MHD0815的博客 221

如何创建反射以及通过反射拿到值

本文介绍了创建反射的三种方式,主要了解如何通过反射获取对象中的构造器、成员变量和成员方法。三种创建反射的方式熟练掌握,学会拿到对象的构造器、成员变量和成员方法,拿到这三个的方式差不多,方法不一样但都有规律,很容易记住。

qq_53118426的博客 1288

详细指南:如何在TI C2000基于C28x的微控制器上部署FreeRTOS_C语言实现

FreeRTOS是一个小型、开源、实时的嵌入式操作系统内核。它为多种微控制器和处理器提供了支持,包括ARM、AVR、MSP430和PIC等。小型和轻量级:适合资源受限的嵌入式系统。实时性:可以满足严格的实时要求。多任务支持:支持多任务并发执行。内存管理:提供了多种内存管理策略。模块化设计:用户可以根据需要选择所需的功能模块。TI C2000系列微控制器是专为实时控制应用设计的。高性能C28x核:提供了高速的浮点运算能力。丰富的外设:包括PWM、ADC、DAC、通信接口等。低功耗。

qq_38334677的博客 1607

java反射三种方法_反射及暴力反射

作者:逯小逯出自:SegmentFault 思否原文:segmentfault.com/a/1190000037432381反射一、概述(1)反射的定位是很重要的,JVM和底层框架都离不开反射(2)反射的原理是拿到你的class文件里的数据,进行数据的操作(CURD)(3)反射提供了丰富的方法,来操作类里的各种数据(属性/方法/构造)(4)REflection(反射)是Java程序开发语言的特征之...

weixin_39586353的博客 2390

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

反射 及 Reflections反射框架

一、类加载过程 要知道反射机制,还需要理解类的加载过程。总的来说,类加载的五个过程:加载、验证、准备、解析、初始化。 除了加载阶段,用户可以通过自定义的类加载器参与,其他阶段都完全由虚拟机主导和控制。 (1)装载 加载指的是把class字节码文件从各个来源通过类加载器装载入内存中。有两处需要说明一下: 字节码来源。一般的加载来源包括从本地路径下编译生成的.class文件,从jar包中的.cla...

1793

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

什么是反射,反射用途,spring哪些地方用到了反射,我们项目中哪些地方用到了反射

在Java中,反射(Reflection)是一种强大的工具,它允许程序在运行时类、接口、构造器、方法和字段等。反射是Java语言的一个重要特性,它为开发人员提供了许多灵活性,尤其是在构建框架和库时非常有用。

zhzjn的博客 1825

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

上一篇: 枚举
下一篇: jsp有哪些内置对象?作用分别是什么? 分别有什么方法?--好多公司笔试题(用不着也的学着背下)
partner4java
博客等级 码龄17年 481粉丝 183原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值