黑马程序员_Java基础加强3-优快云博客

本文链接：https://blog.youkuaiyun.com/sensitivefish/article/details/38098465

本文深入探讨Java反射机制的特点、类与接口的映射、常用方法及其在数组操作、对象属性获取与设置等方面的应用。

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

---------------------- Android、Java开发期待与您交流！ ----------------------

Java反射

反射就是把Java类中各种成份映射成相应的Java类

具有以下特点：

1. 在运行中分析类的能力

2.在运行中查看对象

3.实现数组的操作的代码

反射有关的类

java.lang.Class

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

枚举是一种类，注解是一种接口。每个数组属于被映射成Class对象的一个类，所有具有相同元素类型和维数的数组共享该Class对象，基本的java类型（byte、char、int、float、short、double、long和boolean）和关键字void也表示为Class对象

常用方法：

static Class<t> forName(String className)：返回带有给定字符串名的类或接口的相关联的Class对象

ClassLoader getClassLoader()：返回给类的类加载器

Constructor[] getConstructors()：返回一个包含某些Constructor对象的数组，这些对象所反映此Class对象所表示的类的公有的构造方法

Constructor getConstructor(Class className)：返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。

Field[] getFields()：返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。

Field getField(String name)：返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段

Field[] getDeclaredFields()：返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

Method getMethod(String name,Class className)：返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法

Method[] getMethods()：返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共成员方法

Method[] getDeclaredMethods()：返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

boolean isArray()：判定此 Class 对象是否表示一个数组类。

boolean isEnum()：当且仅当该类声明为源代码中的枚举时返回 true

boolean isPrimitive()：判定指定的 Class 对象是否表示一个基本类型

InputStream getResourceAsStream(String fileName)：查找具有给定名称的资源。

T newInstance()：创建此 Class 对象所表示的类的一个新实例。如同用一个带有一个空参数列表的 new 表达式实例化该类。如果该类尚未初始化，则初始化这个类。

java.lang.reflect.Field

Object invoke(Object obj,Object arg,Object...args)：对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。

Object get(Object obj)：返回指定对象上此 Field 表示的字段的值

Class getType()：返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。

    Class getDeclaredClass()：返回表示类或接口的 <code>Class</code> 对象，该类或接口声明由此 <code>Field</code> 对象表示的字段。

void setAccessible(boolean flag)：将此对象的 accessible 标志设置为指示的布尔值。一般配合getDeclaredField(String varName)使用，只有flag值为true时调用Field对象的get方法才有效

java.lang.reflect.Mehtod

int getModifier()：以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符。应该使用 Modifier 类对修饰符进行解码

String getName()：以 String 形式返回此 Method 对象表示的方法名称。

Class[] getParameterTypes()：按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。如果底层方法不带参数，则返回长度为 0 的数组。

java.lang.reflect.Constructor

T newInstance(Object...initargs)：使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

import java.io.InputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;

public class ReflectTest {

	public static void main(String[] args) throws Exception {
		classType();
		// constructorReflect();
		ReflectField rf = new ReflectField(4, 6, 8, 10);
		// fieldReflect(rf);
		// replaceChar(rf,'e','d');
		// System.out.println(rf);
		char[] c = { 'h', 'a', 'p', 'p', 'y' };
		// reflectArray(c);
		
	}

	/**
	 * 返回此类的运行时类
	 * 
	 * @throws Exception
	 */
	public static void classType() throws Exception {
		String str = "friends";
		System.out.println("int.class:" + int.class);
		System.out.println("Integer.class:" + Integer.class);
		System.out.println("String.class:" + String.class);
		System.out.println("int[].class:" + int[].class);
		System.out.println("String[].class:" + String[].class);
		System.out.println("int[][].class:" + int[][].class);
		System.out.println("String.class.getSuperclass():"
				+ String.class.getSuperclass());
		System.out.println("Integer.class.getSuperclass():"
				+ Integer.class.getSuperclass());
		System.out.println("Object.class:" + Object.class);
		Class c1 = str.getClass();
		Class<String> c2 = String.class;
		Class c3 = Class.forName("java.lang.String");
		Class c4 = void.class;
		System.out.println("(c1 == c2):" + (c1 == c2));
		System.out.println("(c2 == c3):" + (c2 == c3));

		System.out.println("c1.isPrimitive:" + c1.isPrimitive());
		System.out
				.println("int.class.isPrimitive():" + int.class.isPrimitive());
		System.out.println("(int.class == Integer.class):"
				+ (int.class == Integer.class));
		System.out.println("(int.class == Integer.TYPE:"
				+ (int.class == Integer.TYPE));
		System.out.println("int[].class.isPrimitive():"
				+ int[].class.isPrimitive());
		System.out.println("int[].class.isArray():" + int[].class.isArray());

	}

	public static void constructorReflect() throws Exception {
		String str = "friends";
		Constructor<String> constructor = String.class
				.getConstructor(StringBuffer.class);
		String str2 = (String) constructor.newInstance(new StringBuffer(
				"friends"));
		System.out.println(str2 == str);
		str2 = String.class.newInstance();
		System.out.println("str2:" + str2.length());
	}

	public static void fieldReflect(ReflectField rf) throws Exception {
		Field fieldW, fieldX, fieldY, fieldZ;
		fieldW = ReflectField.class.getField("w");
		System.out.println("w:" + fieldW.get(rf));
		fieldX = ReflectField.class.getDeclaredField("x");
		fieldX.setAccessible(true);
		System.out.println("x:" + fieldX.get(rf));
		fieldY = ReflectField.class.getDeclaredField("y");
		fieldZ = ReflectField.class.getDeclaredField("z");
	}

	/**
	 * 
	 * @throws Exception
	 */
	public static void methodReflect(Object obj, Object args) throws Exception {
		Method method = String.class.getDeclaredMethod("indexOf", int.class);
		System.out.println(method.invoke(obj, args));

	}

	/**
	 * 替换对象的字符串类型变量中的字符a为字符b
	 * 
	 * @param obj
	 * @param a
	 * @param b
	 * @throws Exception
	 */
	public static void replaceChar(Object obj, char a, char b) throws Exception {
		Field[] fields = obj.getClass().getFields();
		for (Field field : fields) {
			if (field.getType() == (String.class)) {
				String oldValue = (String) field.get(obj);
				String newValue = oldValue.replace(a, b);
				field.set(obj, newValue);
			}
		}

	}

	public static void reflectArray(Object obj) {
		Class cobj = obj.getClass();
		if (cobj.isArray()) {
			int len = Array.getLength(obj);
			for (int i = 0; i < len; i++)
				System.out.print(Array.get(obj, i) + "\t");
		} else {
			System.out.println(obj);
		}
	}

	public static void loadProperties(InputStream configFile) throws Exception {
		Properties props = new Properties();
		props.load(configFile);
		String className = props.getProperty("className");
		System.out.println("className:" + className);
		@SuppressWarnings("unchecked")
		Collection<ReflectField> co = (Collection<ReflectField>) Class.forName(
				className).newInstance();
		
		ReflectField rf = new ReflectField(3, 3);
		ReflectField rf2 = new ReflectField(5, 5);
		ReflectField rf3 = new ReflectField(3, 3);
		
		co.add(rf);
		co.add(rf2);
		co.add(rf3);
		co.add(rf);
		System.out.println("co.size:" + co.size());

		Collection<ReflectField> hashset = new HashSet<ReflectField>();
		hashset.add(rf);
		hashset.add(rf2);
		hashset.add(rf3);
		hashset.add(rf);
		// rf.x = 7;
		// hashset.remove(rf);
		System.out.println("hashset.size:" + hashset.size());

	}
}

public class ReflectField{
    public int w;
    int x;
	 private int y;
	 protected int z;
	 public String str = "cinema";
	 public String str2 = "phone";
	 public String str3 = "mintis";
	 public ReflectField(int x,int y){
	     this.x = x;
		 this.y = y;
	 }
	 public ReflectField(int w,int x,int y,int z){
	     this.w = w;
	     this.x = x;
		 this.y = y;
		 this.z = z;
	     }  
	public String toString(){
	     return str+"-"+str2+"-"+str3;
	}	 
	public int hashCode(){
	     final int prime = 31;
		 int result = 1;
		 result = prime*result + x;
		 result = prime*result + y;
		 return result;
	}
	public boolean equals(Object obj){
	     if(this == obj){
		     return true;
		 }
		 if(obj == null){
		     return false;
		 }
		 if(getClass()!=obj.getClass()){
		     return false;
		 }
		 final ReflectField other = (ReflectField)obj;
		 if(x!= other.x){
		     return false;
		 }
		 if(y!= other.y){
		     return false;
		 }
		 return true;
	}
	
}

---------------------- Android、Java开发期待与您交流！ ----------------------