Java 基础学习之反射机制三（取得类的结构）

拼搏现实的明天。 2024-04-17 21:32 61阅读 0赞

在实际开发中，通过反射取得类的实例是应用最多的地方，当然，反射机制所提供的功能远不止这些，还可以通过反射得到一个类的完整结构，那么这就要使用到 java.lang.reflect 包中的以下功能：  
（1）Constructor:表示类中的构造方法。  
（2）Field ：表示类中的属性。  
（3）Method: 表示类中的方法。  
这 3 个类都是 AccessibleObject 类的子类，如图：

AccessibleObject

Constructor

Field

Method

### Person 类 ###

package self.learn.reflect;
    
    public interface China {                           // 定义 China 接口
    	public static final String NATIONAL = "China";       // 定义全局常量 
        public static final String AUTHOR = "李清照"; 
        public void sayChina();                              // 无参抽象方法
        public String sayHello(String name, int age);        // 定义有参抽象方法
    }

package self.learn.reflect;
    
    public class Person implements China{              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
        public Person() { 
    		
    	}	
        public Person(String name) { 
    		this.name = name;
    	}	
    	public Person(String name, int age) { 
    		this(name);
    		this.setAge(age);
    	}		
    	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 void sayChina() {              // 覆写方法，输出信息
    		System.out.println("作者:"+AUTHOR+", 国籍"+NATIONAL);
    		
    	}
        public String sayHello(String name, int age) { 
        	return name+", 你好！我今年"+age+"岁了";
        }
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		//return "Person [name=" + name + ", age=" + age + "]";
    		return "姓名："+this.name+", 年龄："+this.age;
    	}    	
    }

# 1 取得所实现的全部接口 #

要取得一个类所实现的全部接口，则必须使用 Class 类中的 getInterfaces() 方法。此方法定义如下：

public Class[] getInterfaces()

getInterfaces() 方法 返回一个 Class 类的对象数组，然后直接利用 Class 类中的 getName() 方法取得类的名称。

#### 实例 1 代码：取得person 类实现的全部接口 ####

package self.learn.reflect;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) { 
    		Class<?> c = null;                // 指定泛型 
    		try { 
    			c = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		Class<?> c1[] = c.getInterfaces();           // 取得实现的全部接口
    		for(int i = 0; i < c1.length;i++) { 
    			System.out.println("实现的接口名称: "+c1[i].getName());
    		}		
    	}
    }

#### 运行结果截图： ####

![在这里插入图片描述][20190901165712612.png]

# 2 取得父类 #

一个类可以实现多个接口，但是只能继承一个父类，所以如果想要取得一个类的父类，可以直接使用 Class 类中的 getSuperClass()方法。此方法定义如下：

public Class<? super T> getSuperClass()

此方法返回的是 Class 实例，和之前的接口一样，可以通过 getName()方法取得类的名称。

#### 实例 2 代码：取得person 类的父类 ####

package self.learn.reflect;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) { 
    		Class<?> c1 = null;                // 指定泛型 
    		try { 
    			c1 = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		Class<?> c2 = c1.getSuperclass();               // 取得父类 
    		System.out.println("父类名称: "+c2.getName());		
    	}
    }

#### 运行结果截图： ####

![在这里插入图片描述][20190901171719462.png]  
Person 类在编写的时候没有明确的继承一个父类，所以默认继承 Object 类。

# 3 取得全部的构造方法 #

要取得一个类中的全部构造方法，则必须使用 Class 类中的 getConstructors()方法

#### 实例 3 代码：取得person 类的全部的构造方法 ####

#### 运行结果截图： ####

![在这里插入图片描述][20190901172609169.png]   上面的代码确实取得了全部的构造方法，取得时是直接通过输出 Constructor 对象得到的完整信息，是比较全的信息，。当然，用户也可以手工拼凑出信息。

#### 实例 4 代码：取得一个类的全部的构造方法 ####

package self.learn.reflect;
    
    import java.lang.reflect.Constructor;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) { 
    		Class<?> c1 = null;                // 指定泛型 
    		try { 
    			c1 = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		Constructor<?> cons[] = c1.getConstructors();          // 全部的构造方法 
    		for(int i = 0; i < cons.length; i++) {                  // 循环输出
    			Class<?> p[] = cons[i].getParameterTypes();        // 列出构造中的参数类型 
    			System.out.print("构造方法: ");	
    			System.out.print(cons[i].getModifiers()+" ");          // 取出权限
    			System.out.print(cons[i].getName());               // 输出构造方法名称
    			System.out.print("(");                             // 输出 (
    			for(int j = 0; j < p.length;j++) {                  // 循环输出
    				System.out.print(p[j].getName()+" arg"+i);              // 打印参数类型
    				if(j < p.length-1) { 
    					System.out.print(",");                     // 输出 ","
    				}
    			}
    			System.out.println("){ }");                          // 输出"){ }"
    		}			
    	}
    }

#### 运行结果截图： ####

![在这，里插入图片描述][20190901174026967.png]  
   从程序的运行结果中可以发现，已经取得了构造方法的方法名称及参数类型，但是在取得权限的时候却发现返回的是一个数字而不是 public,这是因为在整个 Java 中对于方法的修饰符是使用一定的数字表示出来的，如果要想把这个数字还原成用户可以看懂的关键字，则必须靠 Modifier 类完成，此类定义在 java.lang.reflect 包中。直接使用 Modifier 类的以下方法即可将修饰符还原：

public static String toString（int mod）

#### 实例 5 代码：使用 Modifier 还原修饰符 ####

package self.learn.reflect;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Modifier;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) { 
    		Class<?> c1 = null;                // 指定泛型 
    		try { 
    			c1 = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		Constructor<?> cons[] = c1.getConstructors();          // 全部的构造方法 
    		for(int i = 0; i < cons.length; i++) {                  // 循环输出
    			Class<?> p[] = cons[i].getParameterTypes();        // 列出构造中的参数类型 
    			System.out.print("构造方法: ");	
    			int mo = cons[i].getModifiers();
    			System.out.print(Modifier.toString(mo)+" ");          // 取出权限
    			System.out.print(cons[i].getName());               // 输出构造方法名称
    			System.out.print("(");                             // 输出 (
    			for(int j = 0; j < p.length;j++) {                  // 循环输出
    				System.out.print(p[j].getName()+" arg"+i);              // 打印参数类型
    				if(j < p.length-1) { 
    					System.out.print(",");                     // 输出 ","
    				}
    			}
    			System.out.println("){ }");                          // 输出"){ }"
    		}			
    	}
    }

#### 运行结果截图： ####

![在这里插入图片描述][2019090208580751.png]  
   从上面的程序运行结果中可以发现，使用 Modifier 将取出的修饰符数字还原成了用户可以看的懂的权限修饰符

# 4 取得全部方法 #

要取得一个类中的全部方法，可以使用 Class 类中的 getMethods()方法，此方法返回一个 Method 类的对象数组，而如果要想进一步取得方法的具体信息，例如，方法的参数，抛出的异常，则就必须依靠 Method 类，此类中的常用方法如表：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public int getModifiers()</code></td> 
   <td>普通</td> 
   <td>取得本方法的访问修饰符</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public String getName()</code></td> 
   <td>普通</td> 
   <td>取得方法的名称</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public Class&lt;?&gt;[] getParameterTypes()</code></td> 
   <td>普通</td> 
   <td>得到方法的全部参数类型</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>public Class&lt;?&gt;[] getReturnType()</code></td> 
   <td>普通</td> 
   <td>得到方法的返回值类型</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>public Class&lt;?&gt;[] getExceptionTypes()</code></td> 
   <td>普通</td> 
   <td>得到一个方法的全部抛出异常</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><code>public Object invoke( Object obj,Object...args)throws IllegalAccessException,IllegalArgumentException,InvocationTargetException</code></td> 
   <td>普通</td> 
   <td>通过反射调用类中的方法，此方法在后面将为读者介绍</td> 
  </tr> 
 </tbody> 
</table>

#### 实例 6 代码：取得一个类的全部方法定义 ####

package self.learn.reflect;
    
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) { 
    		Class<?> c1 = null;                // 指定泛型 
    		try { 
    			c1 = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		Method m[] = c1.getMethods();                          // 取得全部的方法 
    		for(int i = 0; i < m.length; i++) {                     // 循环输出
    			Class<?> r = m[i].getReturnType();                 // 得到方法的返回值类型
    			Class<?> p[] = m[i].getParameterTypes();           // 得到全部参数类型
    			int xx = m[i].getModifiers();                      // 得到方法的修饰符
    			System.out.print(Modifier.toString(xx)+" ");       // 还原修饰符
    			System.out.print(r.getName()+" ");                 // 得到方法名称
    			System.out.print("(");                             // 输出"("
    			for(int j = 0; j < p.length;j++) { 
    				System.out.print(p[j].getName()+" "+"arg"+j);  // 循环输出参数
    				if( j < p.length - 1 ) {                        // 判断是否输出","
    					System.out.print(",");
    				}
    			}
    		  Class<?> ex[] = m[i].getExceptionTypes();            // 得到全部的异常抛出
    		  if(ex.length>0) {                                     // 判断是否有异常
    			  System.out.print(") throws ");
    		  }else { 
    			  System.out.print(")");
    		}
    		 for(int k = 0; k < ex.length; k++) { 
    			 System.out.print(ex[k].getName());               // 输出异常信息
    			 if(k < ex.length - 1) {                           // 判断是否输出","
    				 System.out.print(",");
    			 }
    		 }
    		 System.out.println();                                // 换行
    		}			
    	}
    }

#### 运行结果截图： ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]  
   从程序的运行结果可以发现，程序不仅将 Person 类的方法输出，也把从 Object 类中继承而来的方法同样进行了输出。

> **开发工具是利用反射的原理**  
>    在 IDE 进行程序开发的时候，基本都是带随笔提示功能的，即使用一个“.”就可以找到一个类的全部方法，实际上 这个功能就是利用反射方式完成的。

# 5 取得全部属性 #

在反射操作中同样也可以取得一个类中的全部属性，但是在取得属性的时候有以下两种不同操作。  
（1）得到实现的接口或父类中的公共属性：public Field\[\] getFields() throws SecurityException。  
（2）得到本类中的全部属性：public Field\[\] getDeclareFields() throws SecurityException。  
以上方法返回的都是 Field 的数组，每一个 Field 对象就表示类中的一个属性，要想取得属性的进一步信息，就需要使用如表方法：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public Object get(Object obj)throws IllegalArgumentException,IllegalAccessException</code></td> 
   <td>普通</td> 
   <td>得到一个对象中属性的具体内容</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public void set(Object obj,Object value)throws IllegalArgumentException,IllegalAccessException</code></td> 
   <td>普通</td> 
   <td>设置指定对象中属性的具体内容</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public int getModifiers()</code></td> 
   <td>普通</td> 
   <td>得到属性的修饰符</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>public String getName()</code></td> 
   <td>普通</td> 
   <td>返回此属性的名称</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>public boolean isAccessible()</code></td> 
   <td>普通</td> 
   <td>判断此属性是否可被外部访问</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><code>public void setAccessible(boolean flag) throws SecurityException</code></td> 
   <td>普通</td> 
   <td>设置一个属性是否可被外部访问</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><code>public static void setAccessible(AccessibleObject[] array,boolean flag) throws SecurityException</code></td> 
   <td>普通</td> 
   <td>将一组属性设置是否可被外部访问</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><code>public String toString()</code></td> 
   <td>普通</td> 
   <td>返回 Field 类的信息</td> 
  </tr> 
 </tbody> 
</table>

#### 实例 7 代码：取得 Person 类中的属性 ####

package self.learn.reflect;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) { 
    		Class<?> c1 = null;                // 指定泛型 
    		try { 
    			c1 = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		{                                                       // 普通代码块
    			Field f[] = c1.getDeclaredFields();                // 取得本来属性
    			for(int i = 0; i < f.length; i++) {                 // 循环输出
    				Class<?> r = f[i].getType();                   // 取得属性的类型
    				int mo = f[i].getModifiers();                  // 取得修饰符数字
    				String priv = Modifier.toString(mo);           // 取得属性修饰符
    				System.out.print("本类属性: ");
    				System.out.print(priv+" ");                    // 输出修饰符
    				System.out.print(r.getName()+" ");             // 输出属性类型
    				System.out.print(f[i].getName());              // 输出属性名称
    				System.out.println(";");                       // 换行
    			}			
    		}
    		System.out.println("-------------------");
    		{                                                       // 普通代码块
    			Field f[] = c1.getFields();                        // 取得父类公共属性 
    			for(int i = 0; i < f.length; i++) { 
    				Class<?> r = f[i].getType();                   // 取得属性的类型
    				int mo = f[i].getModifiers();                  // 取得修饰符数字
    				String priv = Modifier.toString(mo);           // 取得属性修饰符
    				System.out.print("父类属性: ");
    				System.out.print(priv+" ");                    // 输出修饰符
    				System.out.print(r.getName()+" ");             // 输出属性类型
    				System.out.print(f[i].getName());              // 输出属性名称
    				System.out.println(";");                       // 换行
    			}						
    		}		
    	}
    }

#### 运行结果截图： ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70 1]

[20190901165712612.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/19de0087e7c74e7f8ad05092190bdf43.png
[20190901171719462.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/b33cbca337934146a818d407ff3ca111.png
[20190901172609169.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/210f3abdb4a84cce963c4c1779f8ac08.png
[20190901174026967.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a4f09253ba5244abb045e8cfc3d478f6.png
[2019090208580751.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/b76de7e96899411b869c42c36f64a1fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/af7db648aa18490e9630107687b17a47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/be388193df6a46c7834dec210763ebb6.png