java--反射

最新推荐文章于 2024-09-02 22:29:33 发布
最新推荐文章于 2024-09-02 22:29:33 发布
阅读量235 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuanluwang/article/details/78946955
版权

package reflect;

 

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

 

public class Test {

         publicstatic void main(String[] args) {

                   //创建反射第一种：

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

                   Constructor[] con =c1.getConstructors();

                   for(Constructorc:con){

                            System.out.println(c);

                   }

                   //创建反射第二种：

                   Class cla=Person.class;

                   Constructor[]cons=cla.getConstructors();

                   for(Constructorc:cons){

                            System.out.println(c);

                   }

                   try{

                            /*

                             * 第三种方式：

                             * Class:正在运行的 Java 应用程序中的类和接口

                             * forName(类或接口的路径)：映射类或接口，即使在同一个包下，也需要定义包名.类名

                             *

                             */

                            //创建反射第三种：

                            Classclas=Class.forName("reflect.Person");

                            //获取包名    //getName():此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称

                            System.out.println(clas.getPackage());

                            System.out.println(clas.getPackage().getName());

                           

                            //获取有几个访问修饰符

                            System.out.println(clas.getModifiers());

                           

                            //获取当前类的父类

                            System.out.println(clas.getSuperclass());

                           

                            //获取接口名地址      [Ljava.lang.Class;@c3c749

                            System.out.println(clas.getInterfaces());

                           

                            //获取接口名  interface reflect.Play

                            System.out.println("***********");

                            Class[] c=clas.getInterfaces();

                            for(Classc2:c){

                                     System.out.println(c2);

                            }

                           

                            //获取声明的全部属性

                            System.out.println("$$$$$$$$");

                            Field[] f=clas.getDeclaredFields();

                            for(Fieldfi:f){

                                     System.out.println(fi);

                            }

                           

                            //获取声明的全部方法

                            System.out.println("#########");

                            Method[]me=clas.getDeclaredMethods();

                            for(Methodm:me){

                                     System.out.println(m);

                            }

                           

                            //构造器 然后实例化并考虑向下转型

                            System.out.println("***********");

                            Constructorconstr=clas.getConstructor(String.class,int.class,String.class);

                            Personperson=(Person) constr.newInstance("tara",48,"london");

                            System.out.println(person);

 

                            //构造器然后实例化并考虑向下转型

                            //通过反射获取有参构造方法

                            System.out.println("#########");

                            Constructor constr1=clas.getConstructor(String.class,int.class,String.class);

                            Person person1=(Person)constr1.newInstance("tara",48,"london");

                            Field fie=clas.getDeclaredField("name");//获取指定属性

                            fie.setAccessible(true); //访问修饰符的开关

                            fie.set(person1,"xiaobai");//set方法

                            System.out.println(person1);

                           

                            //通过反射获取无参构造方法

                            System.out.println("***********");

                            Person per=(Person)clas.newInstance();//向下转型

                            per.setName("mark"); //set方法

                            per.setAge(21);      //set方法

                            per.setAddress("bj");//set方法

                            System.out.println(per);

                           

                            //获取有参声明的方法                invoke调用实例化的对象

                            System.out.println("#########");

                            Method meth=clas.getDeclaredMethod("str", String.class);

                            System.out.println(meth.invoke(per,"hello"));

                            String s=(String)meth.invoke(per,"in.args");

                            System.out.println(s);

 

        //获取无参声明的方法         invoke调用实例化的对象

            Method met233 = clas.getDeclaredMethod("basketball");

            met233.invoke(per233);



案例一：

Book:

package Book;


public class Book {
private String name;
private double price;
private String publish;


public Book(String name, double price, String publish) {
this.name = name;
this.price = price;
this.publish = publish;
}
public Book() {

}




public void show(){
System.out.println("书名:"+this.name+",价格:"+this.price+",出版社:"+this.publish);
}




public String getName() {
return name;
}




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




public double getPrice() {
return price;
}




public void setPrice(double price) {
this.price = price;
}




public String getPublish() {
return publish;
}




public void setPublish(String publish) {
this.publish = publish;
}

@Override
public String toString() {
return "Book [name=" + name + ", price=" + price + ", publish="
+ publish + "]";
}


}


test:

package Book;


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;


import org.junit.Test;


import reflect.Person;


public class Jtest {
@Test
public void test(){
/*try {
File f=new File("C:/Users/Administrator/Workspaces/MyEclipse 8.5/Reflect/bookProperties.txt");
f.createNewFile();
FileWriter fw=new FileWriter("C:/Users/Administrator/Workspaces/MyEclipse 8.5/Reflect/bookProperties.txt");
BufferedWriter bw=new BufferedWriter(fw,1024);
bw.write("name=java");
bw.newLine();
bw.write("price=50");
bw.newLine();
bw.write("publish=清华大学出版社");
bw.close();
fw.close();
FileReader fr=new FileReader("C:/Users/Administrator/Workspaces/MyEclipse 8.5/Reflect/bookProperties.txt");
BufferedReader br=new BufferedReader(fr,1024);
String str;
while((str=br.readLine())!=null){//读取文件，按行读取
System.out.println(str);
}
//System.out.println(br);
br.close();
fr.close();

Class clas=Class.forName("Book.Book");

//无参构造
Book bk=(Book) clas.newInstance();//向下转型
bk.setName("java"); //set方法
bk.setPrice(50);      //set方法
bk.setPublish("清华大学出版社");//set方法
System.out.println(bk);

//有参构造
Constructor  constr233 = clas.getConstructor(String.class,double.class,String.class);
Book book233 = (Book)constr233.newInstance("java",50,"清华大学出版社");  //向下转型
//获取声明的属性
Field fie233 = clas.getDeclaredField("name");
fie233.setAccessible(true);//访问修饰符的开关
fie233.set(book233, "javaweb");
System.out.println(book233);

//获取无参声明的方法         invoke调用实例化的对象
Method met233 = clas.getDeclaredMethod("show");
met233.invoke(book233);

} catch (Exception e) {
System.out.println("打印错误");
e.printStackTrace();
}*/

//Properties:持久属性集 key=value
Properties p=new Properties();
try {
//读取配置文件book.properties;
p.load(new FileReader("d:/demo.properties"));
String name=p.getProperty("name");
String price=p.getProperty("price");
double i=Double.parseDouble(price);
String publish=p.getProperty("publish");
System.out.println(name);
System.out.println(i);
System.out.println(publish);

Class clas=Class.forName("Book.Book");
Constructor constr=clas.getConstructor(String.class,double.class,String.class);
Book book=(Book) constr.newInstance(name,i,publish);
System.out.println(book);

Method met233 = clas.getDeclaredMethod("show");
met233.invoke(book);

} catch (Exception e) {

e.printStackTrace();
}
}
}


案例二：

PrivateTest：


package PRtest;


public class PrivateTest {
private String name="hellokitty";


public PrivateTest(String name) {
this.name = name;
}


public String getName() {
return name;
}


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




@Override
public String toString() {
return "姓名："+this.name;
}


}

test:
package PRtest;


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;


public class ReflectTest {
public static void main(String[] args) {
try {
Class clas=Class.forName("PRtest.PrivateTest");
Constructor constr233 = clas.getConstructor(String.class);
PrivateTest pr233 = (PrivateTest)constr233.newInstance("hellokitty");  //向下转型
Field fie=clas.getDeclaredField("name");
fie.setAccessible(true);
fie.set(pr233,"jerry and tom");
// System.out.println(pr233);
String str=pr233.getName();
System.out.println(str);

} catch (Exception e) {
System.out.println("error");
e.printStackTrace();
}
}


}


案例三：

 Play：

package reflect;


public interface Play {
public abstract void basketball();


}

Person：

package reflect;


public class Person implements Play{
private String name;
private int age;
private String address;
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public Person() {
super();
}
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;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}

//返回该对象的字符串内容
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
}

public void study(){
System.out.println("学生学习");
}

public String str(String s){
return s;
}
@Override
public void basketball(){
System.out.println("篮球");

}


}

test:

package reflect;


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;


public class Test {
public static void main(String[] args) {
//创建反射第一种：
Class c1=new Person().getClass();
Constructor[] con = c1.getConstructors();
for(Constructor c:con){
System.out.println(c);
}
//创建反射第二种：
Class cla=Person.class;
Constructor[] cons=cla.getConstructors();
for(Constructor c:cons){
System.out.println(c);
}
try {
/*
* 第三种方式：
* Class:正在运行的 Java 应用程序中的类和接口
* forName(类或接口的路径)：映射类或接口，即使在同一个包下，也需要定义包名.类名
* 
*/
//创建反射第三种：
Class clas=Class.forName("reflect.Person");
//获取包名    //getName():此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称
System.out.println(clas.getPackage());
System.out.println(clas.getPackage().getName());

//获取有几个访问修饰符
System.out.println(clas.getModifiers());

//获取当前类的父类
System.out.println(clas.getSuperclass());

//获取接口名地址       [Ljava.lang.Class;@c3c749
System.out.println(clas.getInterfaces());

//获取接口名  interface reflect.Play
System.out.println("***********");
Class[] c=clas.getInterfaces();
for(Class c2:c){
System.out.println(c2);
}

//获取声明的全部属性
System.out.println("$$$$$$$$");
Field[] f=clas.getDeclaredFields();
for(Field fi:f){
System.out.println(fi);
}

//获取声明的全部方法
System.out.println("#########");
Method[] me=clas.getDeclaredMethods();
for(Method m:me){
System.out.println(m);
}

//构造器 然后实例化并考虑向下转型
System.out.println("***********");
Constructor constr=clas.getConstructor(String.class,int.class,String.class);
Person person=(Person) constr.newInstance("tara",48,"london");
System.out.println(person);

//通过反射获取有参构造方法
System.out.println("#########");
Constructor constr1=clas.getConstructor(String.class,int.class,String.class);
Person person1=(Person) constr1.newInstance("tara",48,"london");
Field fie=clas.getDeclaredField("name");//获取指定属性
fie.setAccessible(true); //访问修饰符的开关
fie.set(person1, "xiaobai");//set方法
System.out.println(person1);

//通过反射获取无参构造方法
System.out.println("***********");
Person per=(Person) clas.newInstance();//向下转型
per.setName("mark"); //set方法
per.setAge(21);      //set方法
per.setAddress("bj");//set方法
System.out.println(per);

//获取有参声明的方法                invoke调用实例化的对象
System.out.println("#########");
Method meth=clas.getDeclaredMethod("str", String.class);
System.out.println(meth.invoke(per, "hello"));
String s=(String) meth.invoke(per, "in.args");
System.out.println(s);

/**
* teacher:
*/

//getConstructor(参数类型为可变型参数：参数类型或参数个数是随着构造方法的参数类型和个数进行定义):获取映射中的构造方法
/*获取有参构造方法：
* 1.先获取参数类型和参数个数
* 2.通过newInstrance("有参")将对象属性赋值
* 
* 反射中newInstance代表的是创建对象
* 
*/
Constructor  constr233 = clas.getConstructor(String.class,int.class,String.class);
Person person233 = (Person)constr233.newInstance("张三",22,"北京");  //向下转型

//获取声明的属性
Field fie233 = clas.getDeclaredField("age");
//访问修饰符的开关，默认为false  如果需要通过反射直接修改属性，那么需要将权限开关设置为true
fie233.setAccessible(true);//访问修饰符的开关
fie233.set(person233, 27);//set方法
System.out.println(person233);

//通过反射获取无参构造方法
Person per233 = (Person)clas.newInstance();//向下转型
per233.setName("李四");
per233.setAge(21);
per233.setAddress("上海");
System.out.println(per233);

//获取有参声明的方法                invoke调用实例化的对象
Method meth233 = clas.getDeclaredMethod("str", String.class);
System.out.println(meth233.invoke(per233, "你好"));
String s233 = (String)meth233.invoke(per233, "你好");
System.out.println(s233);

//获取无参声明的方法         invoke调用实例化的对象
Method met233 = clas.getDeclaredMethod("basketball");
met233.invoke(per233);

} catch (Exception e) {
e.printStackTrace();
}

}

//创建反射第一种：
// Class cl = new Person().getClass();
// Constructor[] con = cl.getConstructors();
for(Constructor c:con){
System.out.println(c);
}

//第二种方式：
// Class cla = Person.class;
// Constructor[] cons = cla.getConstructors();
// for(Constructor c:cons){
// System.out.println(c);
// }


}

案例四：

Student:

package Student;
public class Student {
private String name;
private int age;

public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println(toString());
}


public Student() {
super();
System.out.println(toString());
}


@Override
public String toString() {
return "姓名："+this.name+",年龄："+this.age;
}



}

Test：

package Student;


import java.lang.reflect.Constructor;


public class NewInstanceTest {
public static void main(String[] args) {
try {
Class clas=Class.forName("Student.Student");
Constructor constr=clas.getConstructor(String.class,int.class); 
Student stu=(Student) constr.newInstance("anli",15);
System.out.println(stu.toString());


} catch (Exception e) {

e.printStackTrace();
}
}


}

案例五：

Student ：

package Study;


public class Student {
private String name;
private int age;
private String address;


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





public Student() {
super();
}

public void study(String name, int age, String address){
System.out.println("姓名："+this.name+",年龄："+this.age+",地址："+this.address);
}
}



test：

package Study;


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;




public class jTest {
public static void main(String[] args) {
try {
File f=new File("C:/Users/Administrator/Workspaces/MyEclipse 8.5/Reflect/stu.txt");
f.createNewFile();
FileWriter fw=new FileWriter("C:/Users/Administrator/Workspaces/MyEclipse 8.5/Reflect/stu.txt");
BufferedWriter bw=new BufferedWriter(fw,1024);
bw.write("学生学习");
bw.close();
fw.close();

FileReader fr=new FileReader("C:/Users/Administrator/Workspaces/MyEclipse 8.5/Reflect/stu.txt");
BufferedReader br=new BufferedReader(fr,1024);
String str;
while((str=br.readLine())!=null){//读取文件，按行读取
System.out.println(str);
}
br.close();
fr.close();

Class clas=Class.forName("Study.Student");
Constructor constr233 = clas.getConstructor(String.class,int.class,String.class);
Student stu=(Student) constr233.newInstance("zs",32,"London"); //向下转型
//获取有参声明的方法         invoke调用实例化的对象
Method met233 = clas.getDeclaredMethod("study",String.class,int.class,String.class);
System.out.println(met233.invoke(stu,"zs",32,"London"));


} catch (Exception e) {
System.out.println("exception!!!!!!");
e.printStackTrace();
}
}


}

chuanluwang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java--反射机制原理、几种Class获取方式及应用场景
JustinQin
08-24 3万+
目录学习背景一、Java反射机制是什么？1.1 反射原理1.2 举例说明二、Java反射机制中获取Class的三种方式及区别？2.1 三种方式及区别2.2 代码演示区别三、Java反射机制的应用场景有哪些？3.1 应用场景3.2 应用场景实现3.2.1 简单工厂模式3.2.2 简单工厂模式优化（应用场景）3.2.1 代理模式中动态代理（应用场景） 学习背景 学习Java的小伙伴，可能听过Java反射机制，但是熟悉又有点陌生，本文主要是通过思考面试中经常被问到的几个Java反射机制的问题，再通过理论知识结合代
Java-反射机制（超详解）
热门推荐
weixin_52533007的博客
05-11 4万+
Java反射机制概述一、Java反射机制概述1. Java Reflection2. 动态语言 vs 静态语言二、 理解Class类并获取Class的实例1. 概述2. 方法3. 哪些类型可以有Class对象？4. 获取Class类的实例(四种方法)三、类的加载与ClassLoader的理解1. 类的加载过程2. 什么时候会发生类初始化？3. 类加载器的作用4. JVM中不同类型的类的加载器5.6. Properties：用来读取配置文件。四、 创建运行时类的对象五、获取运行时类的完整结构1. 获取当前
java-反射详解
张刚的博客
01-11 2431
java反射常用API，获取Class对象、newInstance方法、Field方法操作字段、invoke、getMethod方法 动态调用指定方法
Java--反射
诺言的博客
03-01 538
1.反射技术 运行时动态访问对象属性的技术。 2.Class对象 2.1 类的实例化 创建对象的四种方式 方式 举例 new关键字 new Car(); clone(Object的方法) c.clone() 序列化(Serialable)/反序列化 ObjectInputStream/ObjectOutputStream 反射Class对象 clazz.newInstance(); 3.Filed类--描述类中的属性(数值域) 4...
java-反射机制-源码
04-12
Java反射机制是Java编程语言中的一个强大工具，它允许运行时动态访问类的信息，包括类名、属性、方法以及构造器等。通过反射，我们可以在程序执行过程中创建和操作任何类的对象，即使在编译时未知其具体类型。这种...
fantj2016#java-reader#10. Java反射---泛型1
07-25
而不是创建一个Object列表，你可以参数化java.util.List来创建一个String String列表，如下所示：当通过反射在运行时检查可参数化类型本
java-reflection-Xiangjie.rar_java 反射
09-24
Java反射是Java编程语言中的一个强大工具，它允许程序在运行时检查类、接口、字段和方法的信息，并能动态地创建对象和调用方法。在深入理解Java反射之前，我们首先要明白什么是反射机制。反射机制是指在运行状态中，...
java习题-反射-chap15.pdf
03-19
Chp15 反射Key Point ●Class 对象及其基本操作●Method 对象以及invoke 方法●标注练习 1. （类对象）要获得类对象，有三种不同的方式，分别为_____________________、___________________、_____________________...
java-fanshejizhi.rar_java 反射
09-24
Java反射机制是Java编程语言中的一个核心特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。这种能力使得Java开发者能够在运行时动态地获取类的信息（如类名、方法名、参数类型等）并调用...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3115
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1147
浅析synchronized锁升级的原理与实现
操作系统原子操作
zzt_is_me的博客
08-28 8617
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 386
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5641
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 825
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 5762
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
java后端开发-Mybatis连接数据库步骤
最新发布
weixin_73355603的博客
09-02 1543
🎙座右铭：得之坦然，失之淡然。💎擅长领域：前端是的，我需要您的：是我持续下去的动力！先看看目录，是不是IDEA的配置，数据库mysql或者其他的数据库这套方法都适合的。
C++的内存模型
qhu1600417010的博客
08-28 1169
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
Java反射机制详解与应用示例
"深入理解Java反射机制" Java反射机制是Java编程语言的一个重要特性，它允许运行时的程序动态地获取类的信息并调用其方法，增强了代码的灵活性和可扩展性。通过反射，开发者可以在运行时创建和操控任何类的对象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值