正文

反射笔记（转载）

一袭白衣一  一袭白衣一  2022-09-04  139

关键词：

java 反射定义功能示例

概要：

Java反射机制详解

| |目录

1反射机制是什么

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2反射机制能做什么

反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。

3反射机制的相关API

通过一个对象获得完整的包名和类名

package net.xsoftlab.baike;
public class TestReflect {
    public static void main(String[] args) throws Exception {
        TestReflect testReflect = new TestReflect();
        System.out.println(testReflect.getClass().getName());
        // 结果 net.xsoftlab.baike.TestReflect
    }
}

实例化Class类对象

package net.xsoftlab.baike;
public class TestReflect {
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        Class<?> class2 = null;
        Class<?> class3 = null;
        // 一般采用这种形式
        class1 = Class.forName("net.xsoftlab.baike.TestReflect");
        class2 = new TestReflect().getClass();
        class3 = TestReflect.class;
        System.out.println("类名称   " + class1.getName());
        System.out.println("类名称   " + class2.getName());
        System.out.println("类名称   " + class3.getName());
    }
}

获取一个对象的父类与实现的接口

package net.xsoftlab.baike;
import java.io.Serializable;
public class TestReflect implements Serializable {
    private static final long serialVersionUID = -2862585049955236662L;
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
        // 取得父类
        Class<?> parentClass = clazz.getSuperclass();
        System.out.println("clazz的父类为：" + parentClass.getName());
        // clazz的父类为： java.lang.Object
        // 获取所有的接口
        Class<?> intes[] = clazz.getInterfaces();
        System.out.println("clazz实现的接口有：");
        for (int i = 0; i < intes.length; i++) {
            System.out.println((i + 1) + "：" + intes[i].getName());
        }
        // clazz实现的接口有：
        // 1：java.io.Serializable
    }
}

获取某个类中的全部构造函数 - 详见下例

通过反射机制实例化一个类的对象

package net.xsoftlab.baike;
import java.lang.reflect.Constructor;
public class TestReflect {
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("net.xsoftlab.baike.User");
        // 第一种方法，实例化默认构造方法，调用set赋值
        User user = (User) class1.newInstance();
        user.setAge(20);
        user.setName("Rollen");
        System.out.println(user);
        // 结果 User [age=20, name=Rollen]
        // 第二种方法 取得全部的构造函数 使用构造函数赋值
        Constructor<?> cons[] = class1.getConstructors();
        // 查看每个构造方法需要的参数
        for (int i = 0; i < cons.length; i++) {
            Class<?> clazzs[] = cons[i].getParameterTypes();
            System.out.print("cons[" + i + "] (");
            for (int j = 0; j < clazzs.length; j++) {
                if (j == clazzs.length - 1)
                    System.out.print(clazzs[j].getName());
                else
                    System.out.print(clazzs[j].getName() + ",");
            }
            System.out.println(")");
        }
        // 结果
        // cons[0] (java.lang.String)
        // cons[1] (int,java.lang.String)
        // cons[2] ()
        user = (User) cons[0].newInstance("Rollen");
        System.out.println(user);
        // 结果 User [age=0, name=Rollen]
        user = (User) cons[1].newInstance(20, "Rollen");
        System.out.println(user);
        // 结果 User [age=20, name=Rollen]
    }
}
class User {
    private int age;
    private String name;
    public User() {
        super();
    }
    public User(String name) {
        super();
        this.name = name;
    }
    public User(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

获取某个类的全部属性

package net.xsoftlab.baike;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class TestReflect implements Serializable {
    private static final long serialVersionUID = -2862585049955236662L;
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
        System.out.println("===============本类属性===============");
        // 取得本类的全部属性
        Field[] field = clazz.getDeclaredFields();
        for (int i = 0; i < field.length; i++) {
            // 权限修饰符
            int mo = field[i].getModifiers();
            String priv = Modifier.toString(mo);
            // 属性类型
            Class<?> type = field[i].getType();
            System.out.println(priv + " " + type.getName() + " " + field[i].getName() + ";");
        }
         
        System.out.println("==========实现的接口或者父类的属性==========");
        // 取得实现的接口或者父类的属性
        Field[] filed1 = clazz.getFields();
        for (int j = 0; j < filed1.length; j++) {
            // 权限修饰符
            int mo = filed1[j].getModifiers();
            String priv = Modifier.toString(mo);
            // 属性类型
            Class<?> type = filed1[j].getType();
            System.out.println(priv + " " + type.getName() + " " + filed1[j].getName() + ";");
        }
    }
}

获取某个类的全部方法

package net.xsoftlab.baike;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class TestReflect implements Serializable {
    private static final long serialVersionUID = -2862585049955236662L;
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
        Method method[] = clazz.getMethods();
        for (int i = 0; i < method.length; ++i) {
            Class<?> returnType = method[i].getReturnType();
            Class<?> para[] = method[i].getParameterTypes();
            int temp = method[i].getModifiers();
            System.out.print(Modifier.toString(temp) + " ");
            System.out.print(returnType.getName() + "  ");
            System.out.print(method[i].getName() + " ");
            System.out.print("(");
            for (int j = 0; j < para.length; ++j) {
                System.out.print(para[j].getName() + " " + "arg" + j);
                if (j < para.length - 1) {
                    System.out.print(",");
                }
            }
            Class<?> exce[] = method[i].getExceptionTypes();
            if (exce.length > 0) {
                System.out.print(") throws ");
                for (int k = 0; k < exce.length; ++k) {
                    System.out.print(exce[k].getName() + " ");
                    if (k < exce.length - 1) {
                        System.out.print(",");
                    }
                }
            } else {
                System.out.print(")");
            }
            System.out.println();
        }
    }
}

通过反射机制调用某个类的方法

package net.xsoftlab.baike;
import java.lang.reflect.Method;
public class TestReflect {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
        // 调用TestReflect类中的reflect1方法
        Method method = clazz.getMethod("reflect1");
        method.invoke(clazz.newInstance());
        // Java 反射机制 - 调用某个类的方法1.
        // 调用TestReflect的reflect2方法
        method = clazz.getMethod("reflect2", int.查看详情  
转载：java中的反射机制反射，当时经常听他们说，自己也看过一些资料，也可能在设计模式中使用过，但是感觉对它没有一个较深入的了解，这次重新学习了一下，感觉还行吧！       一，先看一下反射的概念：   ...  查看详情  
转载：通过反射操作类的私有属性原文地址：http://blog.csdn.net/qustmeng/article/details/54691933 对于类的私有属性，如果没有提供公用方法去修改它，我们可以通过反射方法实现。下面为简单例子importjava.util.ArrayList;importjava.util.List;publicclassA{	privateList<Integer>list  查看详情  
反射笔记1. getFields()和getDeclaredFields()的区别　　getFields()和getDeclaredFields()返回Field对象，通过field.getName()获取名称。　　getFields()只能获取声明为public的字段，包括父类的。　　getDeclaredFields()能获取声明的所有字段，包括public，protecte...  查看详情  
java讲课笔记36：初探反射机制文章目录零、本讲学习目标一、认识反射（一）Java反射机制（二）Java反射的动态性质（三）如何理解Java反射的原理（四）利用反射可实现的功能二、Java反射常用API三、使用反射的基本步骤四、利用反射获取类的信息（一）获...  查看详情  
狂神说java笔记--反射和注解部分笔记(代码片段)传送门==>B站遇见狂神说–反射和注解笔记和练习只是跟着视频整理的;但是有的知识点并没有整理进来.ml1.什么是注解2.内置注解3.元注解4.自定义注解5.反射概述6.获得反射对象7.获取Class类的方式8.所有类型的Class对象9.类...  查看详情  
笔记：反射反射库提供了大量操作Java代码的工具集，以便编写能够通道操作Java代码的程序，能够分析类能力的程序称为反射（reflective）。Class						类在程序运行期间，Java运行时系统始终为所有的对象维护一个称为运行时的类型标识，这个...  查看详情  
java学习笔记-反射机制1. JAVA反射机制的概念 2.怎样实例化一个Class对象    Class.forName(包名.类名);  对象.getClass();  类.class;  ============================代码==========================  查看详情  
反射简单笔记1.反射基本概念： 01.定义：反射是指在程序运行期间，能够观察和修改类或者类的对象的属性和行为的特性！  02.作用：001.在运行期间获取类的修饰符，包名，类名，实现的接口，继承的父类。002.在运行期间获取类...  查看详情  
反射的笔记1.反射基本概念： 01.定义：反射是指在程序运行期间，能够观察和修改类或者类的对象的属性和行为的特性！  02.作用：001.在运行期间获取类的修饰符，包名，类名，实现的接口，继承的父类。002.在运行期间获取类...  查看详情  
扫盲-反射的概念...作者获得授权，非商业转载请注明出处。首先看书要理解反射，很难完全理解，这关系到Java的语言特性，jvm的内存细节，当初我看反射，就像高票答案那样，照着写一遍，结果是你并没有理解，你只是照猫画虎，要想真正理解...  查看详情  
javaweb学习笔记11_xml&反射解析XML总结（SAX、Pull、Dom三种方式）反射的简单介绍：反射1、什么是反射技术？动态获取指定类以及类中的内容(成员)，并运行其内容。应用程序已经运行，无法在其中进行new对象的建立，就无法使用对象。这时可以根据配置...  查看详情  
java学习笔记之反射...和使用一些在编译阶段并不确定的类型，这一机制被称为反射（Reflection）或自省（Introspection）。Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或...  查看详情  
javase学习笔记之反射技术（二十四）反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。 反射的...  查看详情  
转载.netremoting学习笔记信道目录.NETRemoting学习笔记（一）概念.NETRemoting学习笔记（二）激活方式.NETRemoting学习笔记（三）信道参考：♂风车车.Net.NETFramework远程处理基础结构提供下列信道实现：IpcChannelTcpChannelHttpChannelIpcChannelIPCChannel是.NETFramework2.0里面新增...  查看详情  
java学习注解和反射超详细笔记(代码片段)...注解1、注解入门2、内置注解3、自定义注解,元注解二、反射机制1、Java反射机制概念1.1静态&动态语言1.2反射机制概念1.3反射机制研究与应用1.4反射机制优缺点1.5实现2、理解Class类并获取Class实例2.1class类介绍2.2获取Class类的实...  查看详情  
java基础笔记141.反射.Class:反射类任何一个类都有一个Class反射类.(影子)java.lang.reflect.*;	Field:字段类	Method:方法类类	Constructor:构造方法类.	2.获取反射类//1.获取反射类类名.class		Classclazz1=People.class;		//2.通过全类名		Classclazz2=Class.forName("demo.People  查看详情  
go语言学习笔记—进阶—反射：反射的类型对象（reflect.type）—什么是反射？反射的定义反射是指在程序运行时，对程序本身进行访问和修改的能力。在编译程序时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分；在运行程序时，程序又无法获取自身信息支持反射的...  查看详情  

      



     

       
        
     
        
      
    

      
        
          免责声明：如内容涉及版权或违规等问题，请在尽快内联系我们pp114#vip.qq.com，我们将在第一时间删除内容。