1.reflex-反射

最新推荐文章于 2024-07-17 16:01:55 发布

code1997

最新推荐文章于 2024-07-17 16:01:55 发布

阅读量459

点赞数

分类专栏： javaee 文章标签： java 反射

本文链接：https://blog.csdn.net/qq_44739500/article/details/109340401

版权

javaee 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

反射

1 反射概述

1.1 什么是反射？

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

1.2 反射可以做什么？

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

1.3 为什么java可以称为准动态语言

Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

1.4 反射相关的API

java.lang.Class: 代表一个类
java.lang.reflect.Method: 代表类的方法
java.lang.reflect.Field: 代表类的成员变量
java.lang.reflect.Constructor: 代表类的构造器

1.5 疑问

1）通过new的方式或反射的方式都可以调用公共的结构，开发中用哪个？

建议使用new。

2）什么情况下使用反射？

反射的特征：动态性。编译的时候无法得知需要创建什么哪个类的对象。

3）反射机制与面向对象中的封装性是不是矛盾了？如何来看待两个技术？

不矛盾。封装性是建议要不要调用。反射解决能不能调用的问题。

2 反射的使用

2.1 关于java.lang.Class类的理解

1 类的加载过程

程序经过javac.exe后会生成一个或者多个字节码文件（.class结尾），然后我们使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程称之为类的加载。加载到内存中的类，我们称之为运行时的类。加载到内存中类的本身为Class的一个实例==>万事万物皆对象。

2.2 如何获取Class类的实例的方式

/**
 * 获取Class类的实例：加载到内存中的运行时类，会缓存一定的时间，在此时间内我们可以通过不同的方法来获取运行时类，即都是同一个。
 */
@Test
public void testClass() {
    //方式一：运行时类的属性：.class属性
    Class<Person> personClass1 = Person.class;
    //class com.atguigu.reflextionjava.Person
    System.out.println(personClass1);
    //方式二：运行时类的对象，调用getClass()
    Class<? extends Person> personClass2 = new Person().getClass();
    System.out.println(personClass2);
    //方式三：Class类的静态方法：Class.forName(全类名)==>使用的比较多
    Class<?> personClass3 = null;
    try {
        personClass3 = Class.forName("com.atguigu.reflextionjava.Person");
        System.out.println(personClass3);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    //方式四：使用类加载器：ClassLoader
    ClassLoader classLoader = ReflexTest.class.getClassLoader();
    Class<?> personClass4 = null;
    try {
        personClass4 = classLoader.loadClass("com.atguigu.reflextionjava.Person");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    //均为true：进一步表明获取是同一个对象
    System.out.println(personClass1 == personClass2);
    System.out.println(personClass1 == personClass3);
    System.out.println(personClass1 == personClass4);
}

2.3 哪些类型可以有Class对象

class:外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
interface：接口
[ ]：数组
enum：枚举
annotation：注解@interface
primitive type:基本数据类型
void

/*                                                                                *
 * Class实例可以是那些结构
 */
@Test
public void testClass2(){
    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;

    int[] a=new int[10];
    int[] b=new int[100];
    Class c10=a.getClass();
    Class c11=b.getClass();
    //只要数组的元素类型和维度一样，就是一个Class实例
    System.out.println(c10 == c11);
}

2.4 类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下步骤来对该类进行初始化。

2.5 ClassLoader的理解

类加载器作用是用来把类(class)装载进内存的。加载器分为以下几种。

系统类加载器
扩展类加载器
引导类加载器
自定义类加载器

/**
 * 对于自定义类，使用系统类加载器进行加载
 */
@Test
public void test1(){
    //对于自定义类，使用系统类加载器进行加载
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    //sun.misc.Launcher$AppClassLoader@18b4aac2
    System.out.println(classLoader);
    //调用系统类加载器的getParent()获取扩展类加载器：sun.misc.Launcher$ExtClassLoader@23fc625e
    System.out.println(classLoader.getParent());
    //"null":调用扩展类加载器的getParent()无法获取引导类加载器。引导类加载器负责加载java的核心类库，无法加载自定义类。
    System.out.println(classLoader.getParent().getParent());
    ClassLoader classLoader1 = String.class.getClassLoader();
    //"null":说明无法获取引导类加载器
    System.out.println(classLoader1);
}

2.6 加载配置信息的两种方式

fis = new FileInputStream(new File(“jdbc.properties”));
InputStream resource = classLoader.getResourceAsStream(“jdbc1.properties”);

/**
 * 加载配置信息的两种方式
 */
@Test
public void testClassLoader2(){
    Properties properties = new Properties();
    FileInputStream fis =null;
    try {
        //方式一：此时文件默认加载路径在当前的model下
        fis = new FileInputStream(new File("jdbc.properties"));
        properties.load(fis);
        String user = properties.getProperty("user");
        Object passworld = properties.getProperty("passworld");
        System.out.println(user);
        System.out.println(passworld);
        System.out.println("**********************");
        //方式二：ClassLoader来加载，默认路径为src下
        Properties properties1 = new Properties();
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream resource = classLoader.getResourceAsStream("jdbc1.properties");
        properties1.load(resource);
        String user1 = properties1.getProperty("user");
        Object passworld1 = properties1.getProperty("passworld");
        System.out.println(user1);
        System.out.println(passworld1);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

2.7 通过反射创建运行时类对象

/**
 * 实例化运行时对象
 * 1.要求：
 *   1）运行时类必须提供空参构造器
 *   2）空参构造器的访问权限得够。通常设置为public
 * 2.javaBean中要求提供一个public得空参构造器得原因
 */
@Test
public void testGetInstance(){
    Class<Person> personClass = Person.class;
    Person person = null;
    try {
        //new Instance():创建对应的运行时类对象,调用了空参构造器。
        person = personClass.newInstance();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    System.out.println(person);
}

2.8 通过反射获取运行时类得完整结构

2.8.1 获取属性

package com.atguigu.java2;

import com.atguigu.java1.Person;
import org.junit.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * 获取当前运行时类得属性结构
 * @author 龍
 */
public class FieldTest {
    @Test
    public void getField(){
        Class<Person> personClass = Person.class;
        //1.getFields():获取所有访问权限为public的属性
        Field[] fields = personClass.getFields();
        for (Field f:
                fields) {
            System.out.println(f);
        }
        //2.getDeclaredFields():获取运行时类中声明的所有属性
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field f :
                declaredFields) {
            System.out.println(f);
        }
    }

    /**
     * 权限修饰符  数据类型 变量名
     */
    @Test
    public void testGetFiled02(){
        Class<Person> personClass = Person.class;
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field f :
                declaredFields) {
            System.out.print(f+"=====");
            //1.获取权限修饰符。public为2，private为1。
            int modifiers = f.getModifiers();
            //1.1将数转换为具体的权限修饰符
            System.out.print(Modifier.toString(modifiers)+"\t");
            //2.获取数据类型
            Class<?> type = f.getType();
            System.out.print(type+"\t");
            //3.获取变量名
            String name = f.getName();
            System.out.println(name);
        }
    }
}

2.8.2 获取方法

public class MethodTest {
    @Test
    public void testGetMethod(){
        Class<Person> personClass = Person.class;
        //1.getMethods():获取当前运行时类及其所有父类的权限修饰符为public的方法
        Method[] methods = personClass.getMethods();
        for (Method m :
                methods) {
            System.out.println(m);
        }
        System.out.println("****************************");
        //2.getDeclaredMethods():获取当前运行时类当中声明的所有方法。
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method m :
                declaredMethods) {
            System.out.println(m);
        }
    }

    /**
     * @Xxx： 注解
     * 权限修饰符 返回值类型 方法名（参数） throws exception
     */
    @Test
    public void testGetMethod02(){
        Class<Person> personClass = Person.class;
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method m :
                declaredMethods) {
            //1.获取运行时注解。
            Annotation[] annotations = m.getAnnotations();
            for (Annotation a :
                    annotations) {
                System.out.println(a);
            }
            //2.获取权限修饰符
            int modifiers = m.getModifiers();
            System.out.print(Modifier.toString(modifiers)+"\t");
            //3.获取返回值类型
            Class<?> returnType = m.getReturnType();
            System.out.print(returnType+"\t");
            //4.获取方法名
            String name = m.getName();
            System.out.print(name+"(");
            //5.获取形参列表
            Class<?>[] parameterTypes = m.getParameterTypes();
            if (parameterTypes==null&&parameterTypes.length==0){
                System.out.print(")");
            }else {
                for (int i = 0; i < parameterTypes.length; i++) {
                    if (i==parameterTypes.length-1){
                        System.out.print(parameterTypes[i].getName()+"  args_"+i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName()+"  args_"+i+",");
                }
                System.out.print(")");
            }
            //6.抛出的异常
            Class<?>[] exceptionTypes = m.getExceptionTypes();
            if (!(exceptionTypes==null&&exceptionTypes.length==0)){
                //if (exceptionTypes.length>0){
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i==(exceptionTypes.length-1)){
                        System.out.println("throws "+exceptionTypes[i].getName());
                    }
                    System.out.print("throws "+exceptionTypes[i].getName()+",");
                }
            }
            System.out.println();
        }
    }
}

2.8.3 获取构造器

public class ConstructorTest {
    /**
     * 获取指定的构造器并创建对象，用的比较少，更多的是使用new Instance
     */
    @Test
    public void testGetConstructor(){
        Class<Person> personClass = Person.class;
        try {
            Constructor<Person> declaredConstructor = personClass.getDeclaredConstructor(String.class);
            //保证可访问
            declaredConstructor.setAccessible(true);
            Person tom = declaredConstructor.newInstance("Tom");
            System.out.println(tom);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

操作的结构

package com.atguigu.java1;

import java.io.Serializable;

/**
 * @author 龍
 */
public class Creature<T> implements Serializable {
    private char gender;
    public double weight;
    private void breath(){
        System.out.println("生物呼吸");
    }
    public void eat(){
        System.out.println("生物出东西");
    }
}


package com.atguigu.java1;

import sun.security.timestamp.TSRequest;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 龍
 */
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER,ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}


package com.atguigu.java1;
/**
 * @author 龍
 */
public interface MyInterface {
    void info();
}


package com.atguigu.java1;

/**
 * @author 龍
 */
@MyAnnotation
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
    private String name;
    int age;
    public int id;
    public Person(){ }
    @MyAnnotation(value = "abc")
    private Person(String name){
        this.name=name;
    }
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是" + nation);
        return nation;
    }
    public String display(String interests,int age)throws NullPointerException,ClassCastException{
        return interests+age;
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }

    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

每日一考

1.获取Class实例的三种常见方式

Class class1=Person.class();

Class class2=new Person().getClass();

Class class3=Class.forName(“com.atguigu.refrextionjava.Person”);==>更好的体现动态性。

类加载器：ReflexTest.class.getClassLoader().load(“全类名”);

2.谈谈对Class类的理解

Class也是一个类，Class的一个实例对应着一个加载到内存中的一个运行时类。

3.创建Class对应的运行时类的对象的通用方法，代码实现

Object obj=clazz.new Instance();

4.如何调用show方法

class Usre{

public void show(){

System.out.println("我是一个中国人！");

}
}

代码实现：

User user=(User)clazz.getInstance();

Method m=clazz.getDeclaredMethod("show");

m.setAccessiable(true);

m.invoke(user);

code1997

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录