Java 基础学习之反射机制四（反射机制的深入应用、Array 类常用方法）

电玩女神 2024-04-17 22:14 61阅读 0赞

反射除了可以取得一个类的完整结构之外，还可以调用类中的指定方法或指定属性，并且可以通过反射完成对数组的操作。

### 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 通过反射调用类中的方法 #

1.  如果要使用反射调用类中的方法可以通过 Method 类完成，操作步骤如下：  
    （1）通过 Class 类的 getMethod(String name, Class.parameterTypes)方法取得一个 Method 对象，并设置此方法操作时所需的参数类型。  
    （2）之后才可以使用 invoke()方法进行调用，并向方法中传递要设置的参数。

#### 实例1 ：调用 Person 类中的 sayChina()方法 (不用传递参数) ####

package self.learn.reflect;
    
    import java.lang.reflect.Method;
    
    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();
    		}
    		try { 
    			Method met = c1.getMethod("sayChina");            // 此方法没有参数
    			met.invoke(c1.newInstance());                     // 调用方法，必须传递对象实例
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}		
    	}
    }

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

![在这里插入图片描述][20190902105123390.png]  
在使用 invoke()方法时必须传入一个类的实例化对象

#### 实例 2 ：调用 Person 类中的 sayHello()方法 (传递参数) ####

package self.learn.reflect;
    
    import java.lang.reflect.Method;
    
    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();
    		}
    		try { 
    			Method met = c1.getMethod("sayHello",String.class,
    					int.class);            // 此方法需传递两个参数
    			String rv = null;              // 接收方法返回值
    			rv =(String)met.invoke(c1.newInstance(),"杜甫",16); // 调用方法，必须传递对象实例,传入两个参数
    	        System.out.println(rv);	
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}		
    	}
    }

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

![在这里插入图片描述][20190902105708999.png]  
   上面的程序中，因为 sayHello()方法本身要接收两个参数，所以在使用 getMethod()方法调用的时候除了要知道调用的方法名称，也需要指定参数的类型，因为 sayHello()方法调用完成后存在返回值，而且返回值的类型是 String,所以使用了一个字符串接收返回的内容。

# 2 调用 setter 及 getter 方法 #

1.  在使用反射调用方法的操作中，最重要的也就是调用类中的 setter 和 getter 方法，这一点在 Java 的开发中随处可见。

#### 实例 3 ：调用 setter 及 getter 方法 ####

package self.learn.reflect;
    
    import java.lang.reflect.Method;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) { 
    		Class<?> c1 = null;                // 指定泛型 
    		Object obj = null;                 // 声明一个对象
    		try { 
    			c1 = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		try { 
    			obj = c1.newInstance();                           // 实例化操作对象
    		} catch (InstantiationException e) { 
    			e.printStackTrace();
    		}catch (IllegalAccessException e) { 
    			e.printStackTrace();
    		}	
    		setter(obj,"name","武则天",String.class);              // 调用 setter 方法
    		setter(obj, "age", 30,int.class);                   
    		System.out.print("姓名：");                  
    		getter(obj, "name");                                   // 调用 getter 方法
    		System.out.print("年龄："); 
    		getter(obj, "age"); 
    	}
    	/** * * @param obj 操作的对象 * @param att 操作的属性 * @param value 设置的值 * @param type 参数类型 */
    	public static void setter(Object obj,String att,Object value,Class<?> type) {  // 调用 setter 方法
    		try { 
    			Method met = obj.getClass().getMethod("set"+initStr(att), type); // 设置方法参数类型
    			met.invoke(obj, value);         // 调用方法
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	public static void getter(Object obj,String att) {  // 调用 getter 方法
    		try { 
    			Method met = obj.getClass().getMethod("get"+initStr(att)); // 此方法不需要参数
    			System.out.println(met.invoke(obj));         // 输出方法的返回值
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    	public static String initStr(String old) { 
    		String str = old.substring(0,1).toUpperCase()+old.substring(1);
    		return str;
    	}
    }

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

![在这里插入图片描述][20190902113253484.png]  
   上面程序完成了调用类中 setter 及 getter 方法的功能，下面分步骤将本程序的实现思路为读者说明：  
（1）设置方法名称时，本程序是直接使用的属性名称，例如 name 或 age。但是实际上的方法名称时 setName()、getName()、setAge()、getAge(),这样，所有的属性名称的首字母需要大写，所以为了解决这样的问题，单独设置了一个方法 initStr() ，通过此方法将字符串中的首字母大写。首字母大写之后再增加 set 及 get 字符串以找到对应的方法。  
（2）调用 setter()方法时，传入了实例化对象、要操作的属性名称（在方法中会将首字母大写）、要设置的参数内容以及具体的参数类型，这样做是为了满足 getMethod()和 invoke()方法的使用要求。  
（3）在调用 getter 方法时，也同样传入了一个实例化对象，因为其本身不需要接收任何的参数，所以只传入了属性名称（在方法中会将首字母大写），并在此方法中将内容打印输出。  
   以上的程序是在反射调用方法时的重要应用，读者一定要掌握其原理。因为在日后的开发中，很多系统会为开发者实现好以上功能。

# 3 通过反射操作属性 #

在反射操作中虽然可以使用 Method 调用类中的 setter 及 getter 方法设置和取得属性，但是这样操作毕竟比较麻烦，所以在反射机制中也可以直接通过 Field 类操作类中的属性，通过 Field 类提供的 set()和 get()方法就可以完成设置和取得属性内容的操作。但是在操作之前首先需要注意的是，在类中的所有属性已经都设置成私有的访问权限，所以使用 set()和 get(）方法的时候首先要先使用 Field 类中的 setAccessible(true) 方法将需要操作的属性设置成可以被外部访问。

#### 实例 4 ：直接操作类中的属性 ####

package self.learn.reflect;
    
    import java.lang.reflect.Field;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) throws Exception { 
    		Class<?> c1 = null;                // 指定泛型 
    		Object obj = null;                 // 声明一个对象
    		c1 = Class.forName("self.learn.reflect.Person");   // 传入要实例化类的完整的包.类名称
    		obj = c1.newInstance();                            // 实例化 Class 对象
    		Field nameField = null;                            // 表示 name 属性
    		Field ageField = null;                             // 表示 age 属性
    		nameField = c1.getDeclaredField("name");           // 取得 name 属性
    		ageField = c1.getDeclaredField("age");             // 取得 age 属性
    		nameField.setAccessible(true);                     // 将 name 属性设置成可被外部访问
    		ageField.setAccessible(true);                      // 将 age 属性设置成可被外部访问
    		nameField.set(obj, "李信");                         // 设置 name 属性内容
    		ageField.set(obj, 16);
    		System.out.println("姓名："+nameField.get(obj));     // 通过 get 取得内容
    		System.out.println("姓名："+ageField.get(obj));     // 通过 get 取得内容
    		}		
    }

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

![在这里插入图片描述][20190902151715917.png]  
   从上面的操作形式上观察，可以清楚地发现，明显比之前使用 setter 或 getter 方法操作属性的代码更加简单、方便。但是，使用反射操作属性时最好通过 setter(）和 getter()方法，不要直接操作属性。

# 4 通过反射操作数组 #

反射机制不仅能用在类上，还可以应用在任意的引用数据类型上，当然，这本身就包括了数组，即可以使用反射操作数组。可以通过 Class 类的以下方法取得一个数组的 Class 对象，

public Class<?> getComponentType()

在反射操作包 java.lang.reflect 中使用 Array 类表示一个数组，可以通过此类进行取得数组的长度，取得数组内容的操作。Array 类的常用方法如表：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public static get(Object array,int index) throws IllegalArgumentException,ArrayIndexOutOfBoundsException</code></td> 
   <td>普通</td> 
   <td>根据下标取得数组的内容</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public static Object newInstance(Class&lt;?&gt; componentType,int length) throws NegativeArraySizeException</code></td> 
   <td>普通</td> 
   <td>根据已有的数组类型开辟新的数组对象</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public static set(Object array,int index,Object value) throws IllegalArgumentException,ArrayIndexOutOfBoundsException</code></td> 
   <td>普通</td> 
   <td>修改指定位置的内容</td> 
  </tr> 
 </tbody> 
</table>

#### 实例 5 ：取得数组信息并修改内容 ####

package self.learn.reflect;
    
    import java.lang.reflect.Array;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) throws Exception { 
    		int temp[] = { 1,2,3};                             // 声明一个整型数组
    		Class<?> c = temp.getClass().getComponentType();  // 取得数组的 Class 对象
    		System.out.println("类型: "+c.getName()); // 得到数组的类型名称
    		System.out.println("长度: "+Array.getLength(temp));// 得到数组的长度
    		System.out.println("第一个内容: "+Array.get(temp, 0)); // 得到第一个内容
    		Array.set(temp, 0, 6);                                  // 修改第一个内容
    		System.out.println("第一个内容: "+Array.get(temp, 0)); // 得到第一个内容 
    		}		
    }

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

![在这里插入图片描述][20190902162042667.png]  
   在应用中还可以通过 Array 类根据已有的数组类型来开辟新的数组对象，下面就使用 Array 完成一个可以修改已有数组大小的功能。

#### 实例 6 ：修改数组大小 ####

package self.learn.reflect;
    
    import java.lang.reflect.Array;
    
    public class GetClassDemo01 { 
    
    	public static void main(String[] args) throws Exception { 
    		int temp[] = { 1,2,3};                             // 声明一个整型数组
    		int newTemp[] = (int[])arrayInc(temp,5);          // 扩大数组长度
    		print(newTemp);                                   // 打印数字信息
    		System.out.println("\n-------------------"); 
    		String t[] = { "lxh","mldn","mldnjava"};           // 声明一个字符串数组
    		String nt[] = (String[])arrayInc(t, 8);             // 扩大数组长度
    		print(nt);
    		}
    
    	public static Object arrayInc(Object obj, int len) {   // 修改数组大小
    		Class<?> c = obj.getClass();                      // 通过数组得到 Class 对象
    		Class<?> arr = c.getComponentType();              // 得到数组的 Class 对象
    		Object newO = Array.newInstance(arr, len);        // 重新开辟新的数组大小
    		int co = Array.getLength(obj);                    // 取得数组长度
    		System.arraycopy(obj,0,newO,0,co);                // 复制数组长度 
    		return newO;
    	}
    	public static void print(Object obj) {                 // 输出数组
    		Class<?> c = obj.getClass();                      // 通过数组得到 Class 对象
    		if(!c.isArray()) {                                 // 判断是否是数组
    			return;                                       // 不是则返回
    		}
    		Class<?> arr = c.getComponentType();              // 取得数组的 Class
    		System.out.println(arr.getName()+" 数组长度是: "      // 输出数组信息
    						+Array.getLength(obj));
    		for(int i = 0; i < Array.getLength(obj); i++) { 
    			System.out.print(Array.get(obj, i)+"、");
    		}
    	}
    }

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

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

[20190902105123390.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/3de11b27cc384377b8ea3ac2f4d63e51.png
[20190902105708999.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a0351bcc291f4270a6317ee72120facd.png
[20190902113253484.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/5afd64834dee48b6b31187930475d869.png
[20190902151715917.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/ca4f5b7b4a19434783ce8415044be352.png
[20190902162042667.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1e70e0b3e37e44cca0c2b15f003e614b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/da38161ba4884369ab829b5e3b6a6bb2.png