标签：反射 String Class class reflect Employee public
反射：运行时动态访问类与对象的技术
创建对象的时间 从编译时变成运行时
反射的作用：
package fnshe;
/**
*接口
/
public interface Math {
public float ss(float a,float b);
}
package fnshe;
/**
*ADD实现
**/
public class ADD implements Math{
@Override
public float ss(float a, float b) {
return a+b;
}
}
package fnshe;
/**
*实现接口
**/
public class CHEN implements Math{
@Override
public float ss(float a, float b) {
return a*b;
}
}
package fnshe;
/**
*实现接口
**/
public class CHU implements Math {
@Override
public float ss(float a, float b) {
if(b!=0){
return a/b;
}else {
throw new RuntimeException("出书不能为0");
}
}
}
package fnshe;
/**
*实现接口
**/
public class JIAN implements Math{
@Override
public float ss(float a, float b) {
return a-b;
}
}
package fnshe;
import java.util.Scanner;
/**
*操作类
**/
public class Application {
public void caozuo() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Scanner scanner = new Scanner(System.in);
String op = scanner.nextLine();
float a=scanner.nextFloat();
float b=scanner.nextFloat();
Math o=(Math)Class.forName("fnshe."+op).newInstance();//动态创建对象
System.out.println(o.ss(a, b));
}
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Application application = new Application();
application.caozuo();
}
}
反射的四个核心类
1.Class类
2.Constructor构造方法类
3.Method类
4.Field成员变量类
Class是JVM中代表”类和接口“的类
Class对象具体包含了某个特定类的结构信息
通过Class对象可获取对应类的构造方法/方法/成员变量
Class类核心方法
| 方法 | 用途 |
|---|---|
| Class.forName() | 静态方法，用于获取指定Class对象 |
| classObj.newInstance() | 通过默认构造方法创建新的对象 |
| classObj.getConstructor() | 获得指定的public修饰构造方法Constructor对象 |
| classObj.getMethod() | 获取指定的public修饰方法Method对象 |
| classObj.getFiled() | 获取指定的public修饰成员变量Field对象 |
Constructor构造方法类
Constructor类时对java类中的构造方法的抽象
Contructor对象包含了具体类的某个构造方法的声明
通过Constructor对象调用带参构造方法创建对象
核心方法
| 方法 | 用途 |
|---|---|
| classObject.getConstructor() | 获取指定public修饰的构造方法对象 |
| constructorObj.newInstance() | 通过对应的构造方法创建对象 |
Method方法类
| 方法 | 用途 |
|---|---|
| classObj.getMethod() | 获取指定public修饰的方法对象 |
| methodObj.invoke() | 调用指定对象的对应方法 |
Field成员变量类
Field对应某个具体类中的成员变量的声明
Field对象使用classObj.getField()方法获取
通过Field对象可为某对象成员变量赋值/取值
| 方法 | 用途 |
|---|---|
| classObj.getField() | 获取指定public修饰的成员变量 |
| fieldObj.set() | 为某对象指定成员变量赋值 |
| fieldObj.get() | 获取某对象指定成员变量数值 |
getDeclared系列方法
getDeclaredConstructors(s)|method(s)|Field(s)获取对应对象
访问非作用域，会抛出异常
代码
package reflect.entity;
import javax.jws.soap.SOAPBinding;
/**
*Employee类
**/
public class Employee {
static {
System.out.println("Employee类已经被加载到jvm，并初始化");
}
private Integer eno;
public String ename;
private Float salary;
private String dname;
public Employee() {
System.out.println("Employee默认方法被执行...");
}
//注意点，所有参数类型都是引用类型
public Employee(Integer eno, String ename, Float salary, String dname) {
this.eno = eno;
this.ename = ename;
this.salary = salary;
this.dname = dname;
System.out.println("Employee带参方法被执行...");
}
public Integer getEno() {
return eno;
}
public void setEno(Integer eno) {
this.eno = eno;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public Float getSalary() {
return salary;
}
public void setSalary(Float salary) {
this.salary = salary;
}
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Employee{" +
"eno=" + eno +
", ename='" + ename + '\'' +
", salary=" + salary +
", dname='" + dname + '\'' +
'}';
}
//注意点，所有参数类型都是引用类型
public Employee updateSalary(Float val){
this.salary=this.salary+val;
System.out.println("调整薪资为"+this.salary+"元");
return this;
}
}
package reflect;
import reflect.entity.Employee;
/**
*创建对象
**/
public class ClassSample {
public static void main(String[] args) {
//Class.forName()方法将指定的类加载到jvm，并返回对应Class对象
//employeeClass包含reflect.entity.Employee所有成员
try {
Class employeeClass=Class.forName("reflect.entity.Employee");
System.out.println("Employee已被加载到jvm");
//newInstance()通过默认构造器创建新的对象
Employee employee= (Employee)employeeClass.newInstance();
/**
* 执行结果
* Employee类已经被加载到jvm，并初始化
* Employee已被加载到jvm
* Employee默认方法被执行...
*/
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
//实例化异常，抽象类，接口
e.printStackTrace();
} catch (IllegalAccessException e) {
//访问权限异常，当在作用域外访问对象方法或成员变量时抛出
e.printStackTrace();
}
}
}
package reflect;
import reflect.entity.Employee;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
*构造反方法
**/
public class ConstructorSample {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class employeeClass=Class.forName("reflect.entity.Employee");
//选定特定构造器
Constructor constructor = employeeClass.getConstructor(new Class[]{
Integer.class, String.class, Float.class, String.class
});
//给构造器传值
Employee employee = (Employee)constructor.newInstance(new Object[]{
100, "李磊", 300f, "研发部"
});
System.out.println(employee);//Employee{eno=100, ename='李磊', salary=300.0, dname='研发部'}
}
}
package reflect;
import reflect.entity.Employee;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 方法
**/
public class MethodSample {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class employeeClass=Class.forName("reflect.entity.Employee");
Constructor constructor = employeeClass.getConstructor(new Class[]{
Integer.class, String.class, Float.class, String.class
});
Employee employee = (Employee)constructor.newInstance(new Object[]{
100, "李磊", 300f, "研发部"
});
System.out.println(employee);
//选择特定方法
Method updateSalary = employeeClass.getMethod("updateSalary", new Class[]{Float.class
});
//执行方法
Employee employee1 = (Employee)updateSalary.invoke(employee,new Object[]{1000f});
System.out.println(employee1);
/**
* 执行结果
* Employee类已经被加载到jvm，并初始化
* Employee带参方法被执行...
* Employee{eno=100, ename='李磊', salary=300.0, dname='研发部'}
* 调整薪资为1300.0元
* Employee{eno=100, ename='李磊', salary=1300.0, dname='研发部'}
*/
}
}
package reflect;
import reflect.entity.Employee;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* 成员变量
**/
public class FieldSample {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
Class employeeClass=Class.forName("reflect.entity.Employee");
Constructor constructor = employeeClass.getConstructor(new Class[]{
Integer.class, String.class, Float.class, String.class
});
Employee employee = (Employee)constructor.newInstance(new Object[]{
100, "李磊", 300f, "研发部"
});
System.out.println(employee);
//public修饰
Field enameField = employeeClass.getField("ename");
enameField.set(employee,"李雷");
String ename = (String)enameField.get(employee);
System.out.println("ename="+ename);
}
}
package reflect;
import reflect.entity.Employee;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
*非public成员变量
**/
public class getDeclaredSample {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class employeeClass=Class.forName("reflect.entity.Employee");
Constructor constructor = employeeClass.getConstructor(new Class[]{
Integer.class, String.class, Float.class, String.class
});
Employee employee = (Employee)constructor.newInstance(new Object[]{
100, "李磊", 300f, "研发部"
});
Field[] fields = employeeClass.getDeclaredFields();
for (Field f:fields){
if(f.getModifiers()==1){
//public修饰
Object o = f.get(employee);
System.out.println(f.getName()+":"+o);
}else if(f.getModifiers()==2){
//private修饰
//拼装方法名getXxx
String methodNames="get"+f.getName().substring(0,1).toUpperCase()+f.getName().substring(1);
Method method = employeeClass.getMethod(methodNames);
//这边不能强转
Object invoke = method.invoke(employee);
System.out.println(f.getName()+":"+invoke);
}
}
}
}
关于Class类的getResource().getPath()方法
程序中配置文件如果放置在classes文件夹，那么我们就可以使用Class类的getResource().getPath()方法获取文件路径。
例如:
String path = DBUtil.class.getResource("/db.properties").getPath();
值得注意的文件是，如果发布程序的web容器(tomcat)安装的路径中存在空格
D:\Program Files\Apache Software Foundation\Tomcat 8.5
该方法将会得到URLEncode后的路径，类似这样。
D:/Program%20Files/Apache%20Software%20Foundation/Tomcat%208.5/
用上面这个绝对路径去获取所需要的文件的话，就会取不到文件。
比较稳妥的做法是将path进行一次URLDecode
path = URLDecoder.decode(path, chartset);
标签：反射,String,Class,class,reflect,Employee,public 来源： https://www.cnblogs.com/yhdxx/p/16557989.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。