反射

最新推荐文章于 2024-10-27 21:59:21 发布

goforitaaa

最新推荐文章于 2024-10-27 21:59:21 发布

阅读量866

点赞数

CC 4.0 BY-SA版权

分类专栏： java高级编程文章标签： java反射

本文链接：https://blog.youkuaiyun.com/goforitaaa/article/details/82414166

java高级编程专栏收录该内容

3 篇文章

订阅专栏

本文深入解析Java反射机制，包括反射的基本概念、核心类介绍及其实现方式。文章详细阐述了如何利用反射操作类、字段、构造方法及方法，同时通过具体示例展示了反射在实际项目中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.反射定义：在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过某种机制来实现对自己行为的描述和监测，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

2.java类反射中的类

java类反射所需要的类，分别是：Field、Constructor、Method、Class、Object

Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。

Constructor类: 提供关于类的单个构造方法的信息，以及对它的访问权限，此类封装了反射类的构造方法。

Method类：提供关于类或者接口上单独某个方法的信息。此类封装反射类方法的一个类。

Class类：类的实例表示正在运行的java应用程序中的类和接口。

获得反射类的三种方法

  //获取反射类的三种方法
       Class c = null;
       //方法一,调用运行时类本身的.class属性
c = String.class;
       //方法二，通过运行时类的实例获取
       c = new String("").getClass();

//方法三 Class.forname全包名
c = Class.forName("java.lang.String");

Field类

getFields()访问的是获取可访问类型的字段

getField()返回指定字段

getDeclaredFields()访问的是所有的字段

getDeclaredField()访问的是某一个已声明的指定字段

建立实体类

package cn.edu.xatu.entity;

public class Student {
   private int id;
   private String name;
   private char M;
   @Override
   public String toString() {
       // TODO Auto-generated method stub
       return "name: " + name +" id:"+id+ "M: " +M;
   }
   public Student(String name){
       this.name = name;

   }
   public Student(){
       System.out.println("student:　默认构造");

   }
   public Student(int id, String name, char m) {
       super();
       this.id = id;
       this.name = name;
       M = m;
   }
   public String speak(String k){
       System.out.println(this.name +k);
       return k;

   }
   private int getId() {
       return id;
   }
   public void setId(int id) {
       this.id = id;
   }
   public String getName() {
       return name;
   }
   public void setName(String name) {
       this.name = name;
   }
   public char getM() {
       return M;
   }
   public void setM(char m) {
       M = m;
   }

}

Field类测试

//获取学生的反射类
       Class student = null;
       try {

           student = Class.forName("cn.edu.xatu.entity.Student");
       } catch (Exception e) {
           e.printStackTrace();
       }
//       getFields只能获取到public 类型的
// Field[] fiedls = student.getFields();
for (Field field : fiedls) {
System.out.println("getFields方法获取字段名字"+field.getName());
System.out.println("getFields方法获取字段类型"+field.getType().getName());
}
//获得所有声明的字段,破坏封装
Field[] f = student.getDeclaredFields();
for (Field field : f) {
//遍历每个字段获取每个字段的名字
System.out.println("getDeclaredFields获取字段:"+field.getName());
//获取字段的类型并输出名字
System.out.println("getDeclaredFields获取字段类型"+field.getType().getName());
}
//获取单个字段对象
Field f =student.getDeclaredField("name");
f.setAccessible(true);
System.out.println(f.getName());
//获取反射类字段的类型的名字
System.out.println(f.getType().getName());
       //新建对象
       Student s = new Student("张三");
//通过反射获取某个实例的某个字段
       String name = (String) f.get(s);
       System.out.println("name："+name);
//       System.out.println("通过get方法获取name:"+ s.getName());

Construceor类

public void test3(){
       Class c = null;
       try {
           c = Class.forName("cn.edu.xatu.entity.Student");
           //直接通过反射实例得到的是无参构造函数
       Object o = c.newInstance();
       } catch (Exception e) {
           e.printStackTrace();
       }
       try {

           Constructor f = c.getConstructor(int.class,String.class,char.class);
           //实例化构造,调用带参构造
           Object o =f.newInstance(21,"张三",'m');
           System.out.println(o);
       } catch (Exception e) {
           e.printStackTrace();
       }

   }

运行结果：

Method类

public void test4(){
       Class c = cn.edu.xatu.entity.Student.class;
       try {
           //通过反射构造实例
           Constructor f = c.getConstructor(int.class,String.class,char.class);
           Object o =f.newInstance(21,"张三",'m');
           //获取指定参数的方法
           Method m =c.getMethod("speak", String.class);
           //方法调用
       m.invoke(o, "在学习");
       } catch (Exception e) {

           e.printStackTrace();
       }

   }

运行结果：

反射的一个例子：

创建自己的属性文件键、值形式

package cn.edu.xatu.view;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
public class MyFrame extends JFrame {
   JMenuBar bar = new JMenuBar();
   JMenu menu = new JMenu("功能模块");
   public MyFrame(){
       bar.add(menu);
       this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
       setJMenuBar(bar);
       setSize(800,600);
       setVisible(true);
       //获取资源文件
       ResourceBundle bundle = ResourceBundle.getBundle("function");
       Enumeration<String> keys = bundle.getKeys();
       //获取资源文件的键
       while(keys.hasMoreElements()){
           String key = keys.nextElement();
           System.out.println(key);
           String name = bundle.getString(key);
           System.out.println(name);
       try {
           //获取该类的反射类
           Class c =    Class.forName(name);
           //对实现execute接口的类进行组装
           Class[] in = c.getInterfaces();
           for (Class class1 : in) {
               while("cn.edu.xatu.view.Function".equals(class1.getName())){
                   final Function o = (Function) c.newInstance();
                   JMenuItem m = new JMenuItem(o.getName());
                   menu.add(m);
                   m.addActionListener(
                           new ActionListener() {

                                   @Override
                                   public void actionPerformed(ActionEvent e) {
                                       o.execute(o.getName());

                                   }
                           }
                       );
                   break;
               }

           }



       } catch (Exception e) {

           e.printStackTrace();
       }
       }


   }
   public static void main(String[] args) {
       new MyFrame();

   }

}

接口函数

package cn.edu.xatu.view;

public interface Function {
   /**
   * 返回模块名
   * @return
   */
   public String getName();
   /**
   * 获取资源的功能
   */
public void execute(String name);

}

package cn.edu.xatu.view;

import javax.swing.JOptionPane;

public class WorkPlan implements Function {

   @Override
   public String getName() {

       return "工作管理计划";
   }

   @Override
   public void execute(String name) {
       this.getName();
       JOptionPane.showMessageDialog(null,"工作管理计划");

   }

}

package cn.edu.xatu.view;

import javax.swing.JOptionPane;

public class CET implements Function {

   @Override
   public String getName() {
       return "CET管理";
   }

   @Override
   public void execute(String name) {
       this.getName();
       JOptionPane.showMessageDialog(null,"CET管理计划");
   }

}

运行结果:

在自己的Frame类里面，读取资源文件，获取配置的全包名，通过发射new出实例，搭建自己所需要的一个功能平台，创建一个接口，根据需求扩展自己的需求，后期可以通过实现接口来增加不同的需求。本来功能的实现需要各个模块子功能的实现，主模块功能才能用，但是通过反射先将主模块功能建立，子功能基于接口实现不同的功能，可以先完成主功能在完成子功能，各自完成各自的，实现了依赖倒置。降低了模块与模块之间的耦合性。