`
DavyJones2010
  • 浏览: 154024 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

Java SE: Reflection Introduction (RTTI)

阅读更多

1. Get Class object (Three possible ways)

        1) Using Class.forName(className). The static method of Class class

package edu.xmu.service;

import org.junit.Test;

public class UserServiceTest
{

	@Test
	public void test()
	{
		try
		{
			Class<?> userServiceClazz = Class.forName("edu.xmu.service.UserService");
			
			System.out.println(userServiceClazz.getName());
		} catch (ClassNotFoundException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

         2) Fetch the Class reference by calling a method that's part of the Object root class: getClass()

package edu.xmu.service;

import org.junit.Test;

public class UserServiceTest
{
	@Test
	public void test()
	{
		UserService userService = new UserService();
		Class<?> userServiceClazz = userService.getClass();
		System.out.println(userServiceClazz.getName());
	}
}

         3) Using class literals

package edu.xmu.service;

import org.junit.Test;

public class UserServiceTest
{
	@Test
	public void test()
	{
		Class<?> userServiceClazz = UserService.class;
		System.out.println(userServiceClazz.getName());
	}
}

 

2. Instantiate Object Using Constructor (Two possible approaches)

        1) Using newInstance() method in Class object for non-param constructor

package edu.xmu.service;

import org.junit.Test;

public class UserServiceTest
{
	@Test
	public void test() throws InstantiationException, IllegalAccessException
	{
		Class<?> userServiceClazz = UserService.class;
		UserService userService = (UserService) userServiceClazz.newInstance();
		userService.addUser();
	}
}

         2) Using getConstructor(paramClasses) in Class object. Then use newInstance(paramValues) in Constructor instance.

package edu.xmu.service;

import java.lang.reflect.Constructor;

import org.junit.Test;

public class UserServiceTest
{
	@Test
	public void test() throws Exception
	{
		Class<?> userServiceClazz = UserService.class;
		Class<?>[] paramClasses = new Class<?>[] {String.class};
		Object[] paramValues = new Object[] {"Davy"};
		
		Constructor<?> cons = userServiceClazz.getConstructor(paramClasses);
		
		UserService userService = (UserService) cons.newInstance(paramValues);
		
		userService.addUser();
	}
}

    Comments:

        1) When we regard UserService as an interface, and the real Object created from cons.newInstance(...) as an implementation. Then that would be much more useful.

 

3. Get Methods and Invoke Methods

        1) Possible ways to get Methods from Class object

package edu.xmu.service;

import java.lang.reflect.Method;

import org.junit.Test;

public class UserServiceTest
{
	@Test
	public void test() throws Exception
	{
		Class<?> userServiceClazz = UserService.class;

		Object userService = userServiceClazz.newInstance();

		// Gets all public methods of the class including methods that derived
		// from parents
		// Method[] methods = userServiceClazz.getMethods();
		// for (Method method : methods)
		// {
		// System.out.println(method.getName());
		// }

		// Gets all methods of the class including methods that are private and
		// protected, excluding methods that derived from parents
		// Method[] methods = userServiceClazz.getDeclaredMethods();
		// for (Method method : methods)
		// {
		// System.out.println(method.getName());
		// }

		// getMethod(...) can only get method that is public in current class or
		// its parent class
		// userServiceClass.getMethod("addUser", new Class<?>[] {});
		// Get method by methodName and method Params Types.
		Method method = userServiceClazz.getDeclaredMethod("getUser",
				new Class<?>[] { String.class });
		// As the getUser method is private so we have to setAccessible(true) to
		// suppress access checking
		method.setAccessible(true);
		// Then invoke the method, userService is the instance in which the
		// method will be invoked
		method.invoke(userService, new Object[] { "Davy" });
	}
}

         2) Possible ways to invoke a method in an object (Refer to Upper Example)

 

4. Get Fields From Class Object and Get Field Value From Specific Instance

package edu.xmu.service;

import java.lang.reflect.Field;

import org.junit.Test;

public class UserServiceTest
{
	@Test
	public void test() throws Exception
	{
		Class<?> userServiceClazz = UserService.class;

		UserService userService = (UserService) userServiceClazz.newInstance();
		userService.setUsername("Davy");
		
		Field[] fields = userServiceClazz.getDeclaredFields();
		for(Field field : fields)
		{
			field.setAccessible(true);
			System.out.println(field.get(userService));
		}
	}
}

 

5. Get Annotations

package edu.xmu.service;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import org.junit.Test;

public class UserServiceTest
{
	@Test
	public void test() throws Exception
	{
		Class<?> userServiceClazz = UserService.class;
		
		Method method = userServiceClazz.getDeclaredMethod("getUser", new Class<?>[]{String.class});
	
		Annotation[] annotations = method.getAnnotations();
		for(Annotation annotation : annotations)
		{
			System.out.println(annotation.annotationType());
		}
		// Annotations' length would be zero!
		// Think about the reason!
		// Because the annotation @SuppressWarnings is not @Retention(RetentionPolicy.RUNTIME)
		// It's more likely the RetentionPolicy.SOURCE or RetentionPolicy.COMPILE
		// We can only capture the annotation who is annotated as @Retention(RetentionPolicy.RUNTIME)!
	}
}

 

P.S

        1) Classes used

package edu.xmu.service;

public class UserService
{
	private String username;

	public UserService()
	{
	}
	
	public UserService(String username)
	{
		System.out.println(username);
	}

	public void addUser()
	{
		System.out.println("User added!");
	}

	@SuppressWarnings("unused")
	private void getUser(String username)
	{
		System.out.println("User got!");
	}

	protected void delUser()
	{
		System.out.println("User deleted!");
	}

	public String getUsername()
	{
		return username;
	}

	public void setUsername(String username)
	{
		this.username = username;
	}

}
分享到:
评论

相关推荐

    RTTI.zip_DELPHI RTTI_delphi_rtti

    Delphi的运行时类型信息(Runtime Type Information,简称RTTI)是其强大的特性之一,它允许程序员在程序运行时获取对象或类的类型信息。在Delphi中,RTTI可以帮助我们进行动态类型检查、反射操作以及自动生成代码等...

    Delphi的RTTI机制文档

    **Delphi的RTTI机制详解** RTTI,全称Runtime Type Information(运行时类型信息),是编程语言中的一种特性,允许程序在运行时获取对象的类型信息。在Delphi中,RTTI是一个强大的工具,它使得开发者能够在运行时...

    了解魔术般的技巧:RTTI初学者指南.flv

    了解魔术般的技巧:RTTI初学者指南.flv

    个人收集的RTTI机制

    运行时类型信息(Runtime Type Information,简称RTTI)是C++语言中的一种特性,它允许在程序运行时查询对象的类型信息。RTTI是C++的多态性的一个重要组成部分,尤其是在面向对象编程中,它提供了强大的动态类型检查...

    C++test FOR TEST RTTI

    在C++编程语言中,RTTI(Run-Time Type Information,运行时类型信息)是一个强大的特性,它允许程序在运行期间检查对象的实际类型。C++test FOR TEST RTTI 是一个可能的测试工具或教程,旨在帮助开发者理解和运用...

    RTTI:Rtti(反思)实践

    在编程领域,RTTI(Run-Time Type Information,运行时类型信息)是一种强大的特性,它允许程序在运行时检查和操作对象的实际类型。RTTI通常在面向对象的语言中使用,如C++或Pascal,用于增强代码的灵活性和动态性。...

    Thinking_in_java(chapter10).pdf

    传统RTTI:在编译和运行时都完全知道类型的具体信息,如Java中的instanceof运算符。 b. 反射:仅依靠运行时信息发掘类型信息,提供了类型动态操作的能力,如通过Class类的对象来发现和使用类的信息。 知识点二:...

    RTTI.rar_ RTTI_rtti

    运行时类型识别(Runtime Type Information,简称RTTI)是C++语言中的一种特性,它允许在程序运行期间获取对象的实际类型信息。RTTI是C++为面向对象编程提供的一项强大工具,尤其在多态性编程中,能够帮助我们实现更...

    举例讲解Java的RTTI运行时类型识别机制

    Java的RTTI(Runtime Type Information,运行时类型信息)机制是Java语言的一个重要特性,它允许程序在运行时检查对象的实际类型。RTTI使得在编译时未知类型的对象能够在运行时进行适当的处理,从而增强了代码的灵活...

    Java进阶教程之运行时类型识别RTTI机制

    在Java编程中,运行时类型识别(Runtime Type Identification,简称RTTI)是一种关键特性,它允许程序在运行时检查对象的实际类型。RTTI是Java多态性的重要基础,使得代码能够根据对象的实际类型执行不同的操作。...

    RTTI.rar_DELPHI RTTI

    在编程领域,特别是使用Delphi语言时,RTTI(运行时类型信息,Runtime Type Information)是一个非常重要的概念。RTTI允许程序在运行时获取对象的类型信息,这为动态编程和反射提供了强大的支持。本示例源码是针对...

    强类型系统 RTTI 类型识别

    在面向对象的编程语言中,例如 C++、Java、Delphi 等,RTTI 都提供了对类型识别的支持。在 C++ 中,RTTI 并不是什么新的东西,它早在十多年以前就已经出现了。但是,大多数开发人员,包括许多高层次的 C++ 程序员,...

    RTTI.rar_rtti

    运行时类型信息(Runtime Type Information,简称RTTI)是C++语言中的一种特性,它允许在程序运行期间查询对象的类型信息。RTTI是C++为了实现多态性而引入的重要工具,尤其在处理基类指针指向派生类对象的情况时,...

    rtti.rar_Run Time

    运行时类型识别(RTTI,Run-Time Type Identification)是C++编程语言中的一项特性,它允许程序员在程序运行过程中查询对象的实际类型信息。这在处理多态性、动态类型检查和设计模式中扮演着重要角色。RTTI通常与虚...

    Java的RTTI和反射机制代码分析

    Java的RTTI(运行时类型识别)和反射机制是两种强大的工具,它们允许程序在运行时检查和操作类的信息及对象。RTTI是Java的一种特性,它使得在编译后的程序中仍然可以在运行时获取对象的实际类型信息。这在处理多态性...

    MFC RTTI代码(博客中使用资源)

    在C++编程中,RTTI(Run-Time Type Information,运行时类型信息)是一种特性,它允许程序员在程序运行时查询对象的实际类型。MFC(Microsoft Foundation Classes)是微软提供的一个C++类库,用于构建Windows应用...

    rtti.zip_rtti_zip

    在编程领域,特别是使用Delphi这种面向对象的编程语言时,`RTTI`(Run-Time Type Information)是一项非常重要的特性。RTTI允许程序在运行时获取类型信息,这对于动态操作对象、实现反射、代码生成以及元编程等高级...

    C++和Java多态的区别

    - **运行时类型信息**:C++提供RTTI机制来支持运行时类型识别,Java则通过方法表和JVM的动态绑定机制来实现。 - **性能考量**:C++中的虚函数调用可能会导致额外的间接寻址开销,而Java中的方法调用由JVM优化处理,...

    c++ RTTI解析

    ### C++ RTTI深度解析 #### 一、引言 C++ 的运行时类型识别 (Run-Time Type Information, RTTI) 是一种强大的特性,允许程序在运行时获取对象的类型信息,这对于支持诸如多态性等功能至关重要。本文将深入探讨 C++...

Global site tag (gtag.js) - Google Analytics