Java学习之：反射-Class类

最新推荐文章于 2023-03-14 18:42:27 发布
最新推荐文章于 2023-03-14 18:42:27 发布
阅读量161 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43777322/article/details/90112376
版权

文章目录

1.认识反射

反射：对象的反向处理。根据对象倒推类的组成。
正向处理：先有类，然后产生对象

反射核心类Class类（专门描述其他类的组成）
Object类中取得对象的Class对象

public final native Class<?> getClass();

Class类作用：描述接口与类的组成
Class对象由JVM在第一次加载类时产生，并且全局唯一。

1.1取得任意类Class对象的方式

（1）对象.getClass() Object类提供

（2）类名称.class

（3）Class.forName(类全名称)

Date date = new Date();
System.out.println(date.getClass());

System.out.println(Date.class);

System.out.println(Class.forName("java.util.Date"));

1.2 类的实例化对象方式

第一种：通过类的构造方法实例化对象

第二种：
(1)Class类的newInstance()方法实例化对象
实际调用的是类中的无参构造，如果类中没有无参构造或者无参构造的权限不是public，此方法无法使用。(例如Integer类就没有无参构造)

(2)Constructer类的如下方法：
public T newInstance(Object ... initargs)
若类中没有无参构造，则只能调用Contructer类提供的newInstance()方法使用有参构造来实例化对象

第三种：序列化和反序列化

1.3反射与工厂设计模式

具体实现请看以下链接 https://blog.csdn.net/qq_43777322/article/details/90112629

2.反射和类操作

2.1取得父类&父接口信息

取得包信息 - Package(描述包信息的类)
public Package getPackage()；

取得类名：
(1)类的全限定名：包名+ 类名
classz.getName()
(2)类名
getSimpleName()
(3)取得父类的Class对象：
getSuperClass() : Class<? super T>

(4)取得实现的父接口Class对象
getInterfaces() : Class<?>[]

2.2 反射与构造方法 - Constructor(描述类构造方法信息）

(1)取得类中指定参数类型的构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

(2)取得类中所有构造方法

public Constructor<?>[] getConstructors() throws SecurityException
取得类中所有权限为public的构造方法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
取得类中所有权限的构造方法

class Person{
    private String name;
    private  int age;

    private Person() {
    }

    protected Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

public class TestReflect {
    public static void main(String[] args) throws Exception {
        //通过类名取得Class类的对象
        Class classz = Person.class;
        //取得有参构造
        Constructor constructor =classz.getConstructor(String.class,int.class);
        //实例化对象
        //相当于调用Person person = new Person("张三"，18);
        Person person = (Person) constructor.newInstance("张三",18);
        System.out.println(person);
    }
}

2.3 反射与普通方法 - Method

2.3.1 取得类中指定名称与参数的普通方法

String name：方法名称
Class<?>… parameterTypes: 方法的参数类型

public Method getMethod(String name, Class<?>... parameterTypes)(Class类的方法)

public Method getDeclaredMethod(String name, Class<?>... parameterTypes)

2.3.2 取得类中所有普通方法

public Method[] getMethods() throws SecurityException
取得本类以及父类中所有权限为public的普通方法(包含静态方法)

public Method[] getDeclaredMethods() throws SecurityException
只能取得本类中所有方法(包含private方法）

2.3.3 调用普通方法

obj：类的实例化对象
args:普通方法参数

public Object invoke(Object obj, Object... args)

class Person{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class TestReflect {

    public static void main(String[] args) throws Exception {
/*        Person person =new Person();
        person.setName("张三");
        System.out.println(person.getName());*/
        //1.取得Class对象
        Class<Person>  cls = Person.class;
        //2.组装方法名称
        String setMethodName = "set" + initCap("a");
        String getMethodName = "get" + args[0];
        //3.取得Method对象
        Method setMethod = cls.getMethod(setMethodName,String.class);
        Method getMethod = cls.getMethod(getMethodName);
        //4.取得Person类的实例化对象，然后调用方法
        Person person = cls.newInstance();
        setMethod.invoke(person,"张三");
        System.out.println(getMethod.invoke(person));

    }
    private static String initCap(String str) {
        return str.substring(0,1).toUpperCase() + str.substring(1) ;
    }
}

2.4 反射与普通属性

2.4.1 取得类中指定名称属性

public Field getField(String name)
public Field getDeclaredField(String name)

2.4.2 取得类中所有属性

public Field[] getFields() throws SecurityException
取得本类以及父类中所有权限为public的属性(包含静态属性)

public Field[] getDeclaredFields() throws SecurityException
只能取得本类中所有方法(包含private方法）

class Person{
    public static String test;
    private String name;
    public int age;
}

class Student extends Person {
    private String school;
    public String className;
}

public class TestReflect {

    public static void main(String[] args) throws Exception {
        Class<Student> cls = Student.class;
        {
            Field[] fields = cls.getFields();
            for (Field field: fields) {
                System.out.println(field);
            }
        }
        System.out.println("-----------");
        {
            Field[] fields = cls.getDeclaredFields();
            for (Field field: fields) {
                System.out.println(field);
            }
        }
    }

}

2.4.3( Field类提供)设置与取得值

1.设置：
obj:类的实例化对象
value：要设置的值
public void set(Object obj, Object value)

2.取得：
obj:类的实例化对象
public Object get(Object obj)

3.取得属性类型
public Class<?> getType()

class Person{
    public int age;
}

public class TestReflect {
    public static void main(String[] args) throws Exception {
        Class<Person> cls = Person.class;
        //取得Field对象
        Field field = cls.getField("age");
        //产生Person实例化对象
        Person person = cls.newInstance();
        //set&get
        field.set(person,20);
        System.out.println(field.get(person));
        System.out.println(field.getType());
    }
}

2.5 动态破坏封装(反射特性)

在一次JVM进程中，下次想要破坏，还要再次设置 且只能通过反射调用
Constuctor,Method,Field类都继承AccessibleObject类，此类中有一个破坏封装的方法

//如果flag设置为true，就可以访问到被封装的
public void setAccessible(boolean flag) throws SecurityException

class Person{
    private int age;
}

public class TestReflect {
    public static void main(String[] args) throws Exception {
        //取得类对象
        Class<Person> cls = Person.class;
        //取得属性对象,因为age是私有的，所以getField()获取不到
        Field field = cls.getDeclaredField("age");
        //取得实例化对象
        Person person = cls.newInstance();
        //动态破坏封装
        field.setAccessible(true);
        field.set(person,20);
        System.out.println(field.get(person));
    }
}

只能通过反射调用：如果直接正向调用,person.age = 20;编译都无法通过

3. ClassLoader类加载器

3.1 定义

类加载：通过一个类的全名称来获取此类的二进制字节流

类加载器：实现类加载的功能模块

3.2 JDK内置三大加载器

3.2.1 BootStrap(启动类加载器)

(1)使用C++实现，是JVM自身的一部分，独立于JVM外部，并且无法被Java程序直接引用。

(2)负责将存放于于Java_HOME\lib目录下的能被JVM识别的所有类库(例如rt.jar - java基础类库)加载到JVM中。

3.2.2 ExtClassLoader扩展类加载器

(1)使用Java语言实现，可以被Java程序直接引用

(2)负责将Java_HOME\lib\ext (xml文件解析类，界面框架类)目录下的所有能被JVM识别的类库。

3.2.3 AppClassLoader(应用程序类加载器)

(1)使用Java程序实现，如果没有用户自定义类加载器，则AppClassLoader就是程序中默认的类加载器

(2)负责加载用户classPath指定的类库

3.2.4 三大加载器关系

除了BootStrap没有父加载器，其它类加载器
都有父加载器

3.3 类加载器的双亲委派模型（定义，工作流程，存在意义）

定义:
四个类加载器的层次关系
在这里插入图片描述
工作流程：
加载一个类都要经过顶层加载器，如果顶层加载器在它所加载的范围内
找不到该类，就会返回给子类加载器去加载。

意义：
双亲委派模型对于保证Java程序的稳定运行十分重要。
例如java.lang.Object，它存放在rt.jar中，由于双亲委派模型的存在，无论哪一类类加载器要加载此类，都会委派给BootStrap去进行加载，因此，Object类在程序的各种类加载器环境中都是同一个类。

比较两个类是否相等的前提条件：这两个类是由一个类加载器加载的
否则即使两个类来自同一个Class文件，被同一个JVM加载，这两个类也不相等

4.动态代理

代理类不在实现某一个接口，而是实现InvocationHandler接口。
只有实现了InvocationHandler接口的类才具备动态代理的功能

a易
关注
专栏目录
Java反射-Class类
sebeefe的博客
05-14 185
反射 思考：有没有方法，能在程序运行时去操作一个新建的类？ 反射可以做到,反射是java的一种操作类的机制，反射就是通过Class实例获取对应class的信息 反射基本框架 Class newclass= Class.forname(className); //获取类的Class对象（包括类的详细信息） //注意className必须是全限定名（全称） Constructor constructor = newclass.getConstructor(); // 通过Class 对象获取构造方法对象（
Java中的反射——Class类
Liuxiaoyang1999的博客
08-20 401
一、Class类 在目前为止我博客中写到的Java类中，见到的对象无非就是我们常见的那些有属性，与方法的实例化对象，但在Java中有一个类，它的实例化对象也是类，它就是Java中的Class类。 二、Class类的特点 1.该类在java.lang包中； 2.该类被final所修饰，即该类不可以被子类继承； 3.该类实现了Serializable接口； 4.该类的构造方法被priv...
Java基础-反射-Class
李思净的博客
10-29 261
class 类 class（包括interface）的本质是就是一种数据类型（Type）,class是由JVM在执行过程中动态加载的。JVM在第一次读取到某种class类型时，将其加载进内存。 每加载一种class，JVM就创建一个对应Class类型的实例，并关联起来。 以String类为例，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个...
Java Class类学习
阿汤的专栏
04-09 574
Class类是 import java.lang.reflect.*; public class ClassTest implements interfaceA { private int num; public void DointerfaceA() { System.out.println(""+num); } public ClassTest() { this
java Class类学习总结
Johnchy6112014的博客
01-30 128
1.我们编写一个java类，编译器会为该类生产.class文件，在JVM类加载时将该类加载到jvm内存方法区并为该类在jvm堆区产生一个Class对象，用来封装该类在方法区的数据和业务。 转载于:https://www.cnblogs.com/gaochenghui/p/5172230.html...
Java Class类与反射机制学习笔记
锦瑟年华,逐梦之人
10-03 356
类的加载 当一个程序使用某一个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三个步骤来实现对这个类的初始化。 加载 就是指将该类的 .class文件读入内存中，并为之创建一个Class对象( java.lang.class对象 )。这个Class对象就是用来表示 .class文件内容的东西。(.class文件内容一般包括成员变量、构造方法、成员方法)，任何类被使用时，系统都...
Java Class类详解
王如霜
01-30 2250
最近的Java学习中又学习了一遍工厂模式，其中写到这样一句代码Class.forName(className).newInstance()，当时没注意，但是最后程序报错了，在调试的过程中注意到该句有问题，于是开启了百度之旅，这次旅途还真是收获不少 一：Class类的简介        首先声明的是Class类是Java的一个类，与我们平时自定义的类一样，只不过名字较特殊，也是继承了Obje
JavaClassViewer：使用iava反射查看类文件的所有详细信息
02-15
Java类文件查看器/反射器 Java程序使用反射来查看类文件的详细信息。 它与jdk中的javap命令有点类似，但显示了更多有组织的细节。 安装 从下面的zip下载并解压缩代码/类文件。 用法 代码 将类目录yourDirectory/...
java反射 反编译：.class-->.java
03-23
Java反射机制是Java编程语言中一个非常重要的特性，它允许程序在运行时动态地获取类的信息并进行操作。反射机制的核心在于，它打破了程序在编译时的静态性，使得程序能够在运行时发现并调用类、接口、字段和方法等...
java-reflect:反射
05-16
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。...
java 反射Reflection；Class类
12-21
Java反射机制是在程序运行期间，通过类的全名（包括包名）获取该类的Class对象。一旦有了Class对象，就能获取到类的所有信息，如类的名称、方法、字段、构造器等。反射机制的核心在于`java.lang.Class`类，它是Java...
Java学习day034 反射（一）Class类、捕获异常、利用反射分析类的能力
12-21
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。在Java核心技术卷1中，反射被介绍为一种能够动态操纵代码的工具，尤其在JavaBeans和组件开发中广泛应用。通过反射，...
《疯狂java讲义》学习（4）：类（class）
泛泛之素
01-04 658
类 Java是面向对象的程序设计语言，类是面向对象的重要内容，我们可以把类当成一种自定义数据类型，可以使用类来定义变量，这种类型的变量统称为引用变量。也就是说，所有类是引用数据类型。 定义类 面向对象的程式设计过程有两个概念：类（class）和对象（object，也被称为实例，instance），类是对象的抽象。 Java语言里定义类的简单语法如下： public class Person { ...
Java反射之四大核心类
wzh_123_123的博客
05-15 758
一、反射1.反射指的是对象的反向处理操作，是根据对象来取得对象的来源信息。2.类的对象的三种产生模式 (1)任何类的对象可以通过Object类中的getClass()方法取得Class类对象。 (2)"类.class"：直接根据某个具体的类来取得Class类的对象。 (3)使用Class类提供的方法：public static Class&lt;?&gt; forName(String class...
spring学习1
weixin_67497686的博客
03-07 121
也就是说，Bean都是单例的，我们可以先把所有的单例Bean实例化出来，放到一个集合中去（我们可以称之为缓存），所有的单例Bean全部实例化完成后，以后我们再慢慢调用Setter方法给属性赋值。第一个阶段：在Spring容器加载的时候，实例化Bean，只要其中任意一个Bean实例化之后，马上进行“曝光”（不等属性赋值就曝光--我有对象了，你可以用我，虽现在没赋值，但我是唯一的，之后会赋值）当你扩展一个产品的时候，符合OCP原则，因为只需要添加两个类，一个类是具体产品类，一个类是具体工厂类。
java class类详解
最新发布
jacklin_01的博客
03-14 5637
这种方式在编译时就会受到检查(因此不需要置于try语句块中)，不仅可以应用于普通的类，也可以应用于接口、数组及基本数据类型。时会判断类是否已经加载，没有加载则会调用类加载器来加载类，已经加载过了，不会重复加载。在这个类的字节码被加载时，它们会接受验证，以确保其没有被破坏，并且不包含不良。当程序创建第一个对类的静态成员的引用时，就会加载这个类。如果尚未加载，默认的类加载器就会根据类的全限定名查找。创建类对象的时候也会被当作对类的静态成员的引用。代码块只会在第一次加载类的时候被调用，由输出结果得知，
java class类 用法_学习Java中Class类及其用法
weixin_30941657的博客
02-13 380
Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识，即所谓的RTTI。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。简单总结如下：Class类也是类的一种，只是名字和class关键字高度相似。Java是大小写敏...
java反射(二)：获取Class类的四种方式
弈缘人生
02-27 5369
我们创建了一个类，通过 编译(javac.exe),生成对应的.class文件，之后使用java.exe(JVM的类加载器来完成)加载此.class文件，此.class文件加载到内存以后，就是一个运行时类，存放在缓存区，这个运行时类就是一个 Class的实例。 java.lang.class是反射的源头。 它有如下几个特点： 1.每一个运行时类只加载一次 2.有了Class的实
Java学习之：抽象类举例代码
SNAYi
03-14 1212
abstract class Person{ private String name; private int age; public Person(){ } public String getName(){ return this.name; } publi...
Java核心技术：day034 反射入门 - Class类与异常处理
首先，Class类是Java反射的核心，它是Java运行时系统为每个对象维护的运行时类型标识的载体。通过调用Object类中的getClass()方法，可以获取一个特定对象的Class实例，如Employeee的Class实例。Class对象代表了一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值