反射
1.Java反射机制概述
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射。
1.静态语言和动态语言
2.反射机制功能
- 任运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
-
3.反射API
java.lang.Class:代表一个类
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构选器
2.理解Class类并获取Class实例
1.基本展示
public class Person {
private String name;
public int age;private Person(String name, int age) {
this.name = name;
this.age = age;
}public Person(String name) {
this.name = name;
}public Person() {
}public String getName() {
return name;
}public void setName(String name) {
this.name = name;
}public int getAge() {
return age;
}public void setAge(int age) {
this.age = age;
}@Override
public String toString() {
return “Person{“ +
“name=’” + name + ‘\’’ +
“, age=” + age +
‘}’;
}
public void show(){
System.out.println(“展示方法show”);
}
private String showNation(String nation){
System.out.println(“showNation 方法”);
return nation+”展示”;
}
}
public class ReflectionTest {// 反射之后对与Person的操作 //目前不能操作私有方法 变量
@Test
public void test() throws Exception{
//1.
Class clazz = Person.class;
//1.通过反射创建person对象
// Constructor cons =clazz.getConstructor(String.class,int.class); //获得public 不能获得私有的？？
Constructor cons =clazz.getConstructor(String.class);Object obj = cons.newInstance("name");<br /> Person p = (Person) obj;<br /> System.out.println(p.toString());<br /> //2.通过反射，调用对象指定的属性，方法<br /> Field age = clazz.getDeclaredField("age");<br /> Field name=clazz.getDeclaredField("name");<br /> age.set(p,20);<br />// name.set(p,"namee");<br /> System.out.println(p.toString());<br /> Method method = clazz.getMethod("show");<br /> method.invoke(p);<br /> method = clazz.getMethod("showNation", String.class);<br />// method.invoke(p,"showname");<br /> }<br /> // 通过反射 调用Person类中的 思又构造器和变量 方法<br /> @Test<br /> public void test1() throws Exception {<br /> Class clazz =Person.class;Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class,int.class);<br />// Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);<br /> constructor.setAccessible(true);<br /> //构造函数<br /> Person person = constructor.newInstance("zhangsan",156);<br /> System.out.println(person.toString());// 变量<br /> Field name = clazz.getDeclaredField("name");<br /> name.setAccessible(true);<br /> name.set(person,"lisi");<br /> Field age = clazz.getDeclaredField("age");<br /> age.set(person,15);<br /> System.out.println(name.get(person));<br /> System.out.println(age.get(person));//方法<br /> Method show = clazz.getDeclaredMethod("show");<br /> show.invoke(person);<br /> Method shownation = clazz.getDeclaredMethod("showNation",String.class);<br /> shownation.setAccessible(true);<br /> shownation.invoke(person,"测试");
}
}
疑问1.通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个?
建议:直接new的方式。
什么时候会使用:反射的方式。反射的特征:动态性
疑问2:反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术?
不矛盾。封装建议你用什么方法，(公有)，私有方法为内部的，不需要外部调用。而反射是能不能调用的问题。
2.关于java.lang.Class类的理解
1.类的加载过程:
程序经过javac.exe命令以后，会生成一个或多个字节码文件(.cLass结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为CLass的一个实例。 比如Person类就是Class的对象。
2.换句话说，Class的实例就对应着一个运行时类。
//万事万物皆对象?对象.xxx,FiLe , URL,反射,前端、数据库操作。
3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。
3.获取Class的实例方式
@Test
public void test3() throws ClassNotFoundException {
//方式1：调用运行时类的属性.class
// Class clazz1 = com.test.Person.class;
Class clazz1 = Person.class;
System.out.println(clazz1);
//方式二：通过运行时类的对象
Person person = new Person();
com.test.Person person2 =new com.test.Person();
Class clazz2 = person.getClass();
Class clazz2_1 = person2.getClass();
System.out.println(clazz2_1);
System.out.println(clazz2);
//方式三：调用Class的静态方法：forName(String classPath);
Class clazz3 = Class.forName(“com.java.Person”);
System.out.println(clazz3);
System.out.println(clazz1==clazz2);<br /> System.out.println(clazz1==clazz3);<br /> System.out.println(clazz2==clazz3);//方式四：使用类的加载器<br /> ClassLoader classLoader=ReflectionTest.class.getClassLoader();<br /> Class clazz4=classLoader.loadClass("com.java.Person");<br /> System.out.println(clazz4);<br /> }
4.那些类型可以有class对象
( 1) class:
外部类，成员(成员内部类，静态内部类)，局部内部类，匿名年部类
(2) interface:接口
(3) []:数组
(4) enum:枚举
(5) annotation:注解@interface
(6) primitive type:基本数据类型
( 7) void
@Test
public void test4() {
Class c1 =Object.class;
Class c2 =Comparable.class;
Class c3 =String[].class;
Class c4 =int[][].class;
Class c5 =ElementType.class;
Class c6 =Override.class;
Class c7 =int.class;
Class c8 =void.class;
Class c9 =Class.class;
System.out.println(c9);
int[] a = new int[10];
int[] b = new int[100];
Class c10 =a.getClass();
Class c11 =b.getClass();
//只要元素类型与维度一样，就是同一个cLass
System.out.println(c10 == c11);
}
3.类的加载与ClassLoader的理解
1.类的加载
2.简介
image-20201109112053812
public class ClassLoadingTest {
public static void main(String[] args) {
System.out.println(A.m);
System.out.println(new A().n);
}
}
class A{
static {
m=300;
}
static int m =100;
{
n=200;
}
int n=500;
}
//第二步:链接结束后m=0
//第三步:初始化后，m的值由
// 这个A的类构造器
//
// m = 300;
// m = 100;
// }
3.类加载器的作用:
- 类加载的作用:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
- 类缓存:标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存）一段时间。不过JvM垃圾回收机制可以回收这些Class对象。
- 系统类加载器，sun.misc.Launcher$AppClassLoader@18b4aac2
扩展类加载器，sun.misc.Launcher$ExtClassLoader@f6f4d33
引导类加载器，null。 @Test
public void test1(){
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
System.out.println(classLoader);
System.out.println(classLoader.getParent());
ClassLoader classLoader1 = ClassLoaderTest.class.getSuperclass().getClassLoader();
System.out.println(classLoader1);
}4.加载配置文件
@Test
public void test2() throws IOException {
Properties pro = new Properties();
//读取配置文件一 识别位置在model目录下
/FileInputStream fis = new FileInputStream(“src/pro.properties”);
pro.load(fis);/
// pro.load(ClassLoaderTest.class.getClassLoader().getResourceAsStream(“pro.properties”));//读取配置文件二 识别位置在src下<br /> ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();<br /> InputStream inputStream=classLoader.getResourceAsStream("pro.properties");<br /> pro.load(inputStream);System.out.println(pro.getProperty("name"));<br /> System.out.println(pro.getProperty("password"));<br /> }
4.创建运行时类的对象
1.newInstance():
newInstance();调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器
要想此方法正常的创建运行时类的对象，要求:
1.运行时类必须提供空参的构造器
2.空参的构造器的访问权限得够。通常，设置为public.
Classclazz = Person.class;
Person person =clazz.newInstance();
System.out.println(person.toString());
//反射的动态性，框架中大量运用，在运行时创建需要用到的类对象。
Class clazz3 = Class.forName(“com.java.Person”);
//也可以的通过构造器.newInstance();
5.获取运行时娄的完整结构
1.Field 测试
public class FieldTest {
@Test
public void test1(){
Class clazz = Person.class;
//获取属性结构
//getFields(); 获取当前运行时类以及父类的public访问权限
Field[] fields =clazz.getFields();
for(Field field :fields){<br /> System.out.println(field);<br /> }<br /> //getDeclaredFields() 获取当前运行时类中声明的所有属性，不包含父类。<br /> Field[] fields1 = clazz.getDeclaredFields();<br /> for(Field field :fields1){<br /> System.out.println(field);<br /> }<br /> }//权限修饰符 数据类型 变量名 = 变量值<br /> @Test<br /> public void test2(){<br /> Class clazz = Person.class;<br /> Field[] fields1 = clazz.getDeclaredFields();<br /> for(Field field :fields1){<br /> //1.权限修饰符<br />// System.out.println("权限修饰符");<br /> int modifier = field.getModifiers();<br /> System.out.println(modifier);<br /> System.out.println(Modifier.toString(modifier)+"\t");<br /> //2.数据类型<br />// System.out.println("数据类型");<br /> Class type =field.getType();<br />// System.out.println(type.toString());<br /> System.out.print(type.getName()+"\t");<br /> //3.变量名<br /> String fname = field.getName();<br /> System.out.print(fname);<br /> }<br /> }
2.Method测试
public class MethodTest {
@Test
public void test1(){
Class clazz = Person.class;
//获取所有的方法 获取当前类和父类中public修饰的方法
Method[] methods = clazz.getMethods();
for(Method m:methods){
System.out.println(m);
}
System.out.println("=============");<br /> //获取当前运行时类中所有声明的方法 不包含父类<br /> Method[] methods1 = clazz.getDeclaredMethods();<br /> for(Method m:methods1){<br /> System.out.println(m);<br /> }<br /> }//@注解<br /> //获取方法的具体结构 权限修饰符 返回值类型 方法名 形参列表 thorws exception<br /> @Test<br /> public void test2(){<br /> Class clazz = Person.class;<br /> Method[] methods1 = clazz.getDeclaredMethods();<br /> for(Method m:methods1){<br />// System.out.println(m);<br /> //1.获取方法声明的注解<br /> Annotation[] annotations = m.getAnnotations();<br /> for (Annotation a:annotations){<br /> System.out.print(a+"\t");<br /> }//2.权限修饰符<br /> int modifier = m.getModifiers();<br /> System.out.print(modifier+"\t");<br /> System.out.print(Modifier.toString(modifier)+" 权限 \t");<br /> //3.返回值类型<br /> Class type = m.getReturnType();<br /> System.out.print(type.getName()+"\t");<br /> //4.方法名<br /> System.out.print(m.getName());<br /> //5.形参列表<br /> Class[] classes=m.getParameterTypes();<br /> System.out.print("(");<br /> for (Class c:classes){<br /> System.out.print(c.getName()+" arg "+" \t");<br /> }<br /> System.out.print(")");<br /> //6.抛异常<br /> Class[] classex =m.getExceptionTypes();<br /> for (Class c:classex){<br /> System.out.print(c.getName()+"\t");<br /> }<br /> System.out.println("===========================");<br /> }}<br />}
3.Constructor 测试
4.父类及父类泛型
public class OtherTest {
@Test
public void test1(){
Class clazz = Person.class;
//运行时的父类
Class superclass = clazz.getSuperclass();
System.out.println(superclass);
//获取带泛型的父类<br /> Type genericSuperClass =clazz.getGenericSuperclass();<br /> System.out.println(genericSuperClass);<br /> //获取带泛型的父类的泛型<br /> ParameterizedType parameterizedType= (ParameterizedType) genericSuperClass;<br /> Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();<br /> System.out.println(actualTypeArguments[0].getTypeName());}<br />}
5.实现接口，所在包，注解
6.调用运行时类的指定结构
public class ReflectionTest {
/*
*/<br /> @Test<br /> public void test1() throws Exception{<br /> Class clazz = Person.class;<br /> //创建运行是对象<br /> Person p = (Person) clazz.newInstance();<br /> //获取指定的属性<br /> Field id = clazz.getField("id");<br /> //当前属性可以访问<br /> id.setAccessible(true);<br /> id.set(p,5);<br /> int pid = (int) id.get(p);<br /> System.out.println(id.get(p));<br /> System.out.println();//获取运行时类指定变量名的属性<br /> Field age = clazz.getDeclaredField("age");<br /> age.setAccessible(true);<br /> age.set(p,2);<br /> int page = (int) age.get(p);<br /> System.out.println(page);//获取运行时类的方法<br /> Method display=clazz.getDeclaredMethod("display",String.class,int.class);<br /> display.setAccessible(true);<br /> Object o=display.invoke(p,"dasda",1456);<br /> System.out.println(o);System.out.println("调用静态方法");<br /> Method showDesc=clazz.getDeclaredMethod("showDesc");<br /> showDesc.setAccessible(true);<br />// Object returnval=showDesc.invoke(clazz);<br /> Object returnval=showDesc.invoke(null);<br /> System.out.println(returnval);//运行时类指定的构造器<br /> Constructor constructor = clazz.getDeclaredConstructor(String.class);<br /> constructor.setAccessible(true);<br /> Person person = (Person) constructor.newInstance("tom");<br /> System.out.println(person);<br /> }<br />}
7.反射的应用:动态代理
若有收获，就点个赞吧
0 人点赞
