package cn.gzx.baike;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
public class TestReflect implements Serializable{
private static final long serialVersionUI = -2862585049955236662L;//L代表长整型
private String proprety = null;
public static void main(String[] args) throws Exception{
/* 通过一个对象获得完整的包名 和 类名*/
TestReflect testReflect = new TestReflect();
System.out.println(testReflect.getClass().getName());
// 实例化Class对象
Class<?> class1 = null;
Class<?> class2 = null;
Class<?> class3 = null;
//一般采用这种形式
class1 = Class.forName("cn.gzx.baike.TestReflect");
class2 = new TestReflect().getClass();
class3 = TestReflect.class;
System.out.println(class1.getName());
System.out.println(class2.getName());
System.out.println(class3.getName());
/* 获取一个对象的父类与实现的接口*/
Class<?> clazz = Class.forName("cn.gzx.baike.TestReflect");
//取得父类
Class<?> parentClass = clazz.getSuperclass();
System.out.println("clazz的父类为:" + parentClass.getName());
//clazz的父类为:java.lang.Object
//获取所有的接口
Class<?> intes[] = clazz.getInterfaces();
System.out.println("clazz实现的接口有:");
for(int i = 0;i<intes.length;i++) {
System.out.println((i+1) + ": " + intes[i].getName());
}
/*通过反射机制实例化一个类的对象*/
class1 = Class.forName("cn.gzx.baike.User");
//第一种方法,实例化默认构造方法,调用set赋值
User user = (User)class1.newInstance();
user.setAge(20);
user.setName("Gzx");
System.out.println(user);
//第二种方法,取得全部的构造函数 使用构造函数赋值
Constructor<?> cons[] = class1.getConstructors();
//查看每个构造方法需要的参数
for(int i = 0; i < cons.length; i++) {
Class<?> clazzs[] = cons[i].getParameterTypes();
System.out.print("cons["+ i +"] (");
for(int j = 0; j < clazzs.length; j++) {
if(j == clazzs.length - 1) {
System.out.print(clazzs[j].getName());
}else {
System.out.print(clazzs[j].getName()+",");
}
}
System.out.println(")");
}
user = (User) cons[1].newInstance("Gzx");
System.out.println(user);
user = (User) cons[2].newInstance(20,"Gzx");
System.out.println(user);
//获取某个类的全部属性
System.out.println("==============本类属性==============");
//取得本类的全部属性
Field[] field = clazz.getDeclaredFields();
for(int i = 0; i < field.length; i++){
//权限修饰符
int mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
//属性类型
Class<?> type = field[i].getType();
System.out.println(priv + " " + type.getName()+ " "+ field[i].getName() +";");
}
System.out.println("=========实现的接口或父类的属性=========");
//取得实现的接口或者父类的属性
Field[] field1 = clazz.getFields();
for(int j = 0; j<field.length; j++){
//权限修饰符
int mo = field[j].getModifiers();
String priv = Modifier.toString(mo);
//属性类型
Class<?> type = field[j].getType();
System.out.println(priv + " " + type.getName()+ " "+ field[j].getName() +";");
}
/*获取某个类的全部方法*/
Method method[] = clazz.getMethods();
for(int i = 0; i<method.length;i++){
Class<?> returnType = method[i].getReturnType();
Class<?> para[] = method[i].getParameterTypes();
int temp = method[i].getModifiers();
System.out.print(Modifier.toString(temp) + " ");
System.out.print(returnType.getName() + " ");
System.out.print(method[i].getName() + " ");
System.out.print("(");
for (int j = 0; j < para.length; ++j) {
System.out.print(para[j].getName() + " " + "arg" + j);
if (j < para.length - 1) {
System.out.print(",");
}
}
Class<?> exce[] = method[i].getExceptionTypes();
if (exce.length > 0) {
System.out.print(") throws ");
for (int k = 0; k < exce.length; ++k) {
System.out.print(exce[k].getName() + " ");
if (k < exce.length - 1) {
System.out.print(",");
}
}
} else {
System.out.print(")");
}
System.out.println();
}
/*通过反射机制调用某个类的方法*/
Method method1 = clazz.getMethod("reflect1");
method1.invoke(clazz.newInstance());
method1 = clazz.getMethod("reflect2", int.class, String.class);
method1.invoke(clazz.newInstance(), 20, "张三");
/*通过反射机制操作某个类的属性*/
Object obj = clazz.newInstance();
//可以直接对private
Field fie = clazz.getDeclaredField("proprety");
fie.setAccessible(true);
fie.set(obj, "Java_Reflect");
System.out.println(fie.get(obj));
/**反射机制的动态代理*/
MyInvocationHandler demo = new MyInvocationHandler();
Subject sub = (Subject)demo.bind(new RealSubject());
String info = sub.say("Gzx", 20);
System.out.println(info);
/*在泛型为Integer的ArrayList中存放一个String类型的对象*/
ArrayList<Integer> list = new ArrayList<Integer>();
Method method2 = list.getClass().getMethod("add", Object.class);
method2.invoke(list, "Java_Reflect");
System.out.println(list.get(0));
/*通过反射机制修改数组的大小*/
int[] temp = {1,2,3,4,5,6,7,8,9};
int[] newtemp = (int[])arrayInc(temp, 15);
print(newtemp);
String[] atr = {"a","b","c"};
String[] str1 = (String[]) arrayInc(atr, 8);
print(str1);
}
public void reflect1() {
System.out.println("调用了方法1.");
}
public void reflect2(int age, String name) {
System.out.println("调用了方法2.");
System.out.println("age : " + age + ", name : " + name);
}
public static Object arrayInc(Object obj,int len){
Class<?> arr = obj.getClass().getComponentType();
Object newArr = Array.newInstance(arr, len);
int co = Array.getLength(obj);
System.arraycopy(obj, 0, newArr, 0, co);
return newArr;
}
public static void print(Object obj){
Class<?> c = obj.getClass();
if(!c.isArray()){
return;
}
System.out.println("数组长度为: " + Array.getLength(obj));
for(int i = 0; i < Array.getLength(obj); i++){
System.out.println(Array.get(obj, i) + " ");
}
System.out.println("");
/*反射模式应用于工厂模式*/
fruit f = Factory.getInstance("cn.gzx.baike.Apple");
if(f != null){
f.eat();
}
}
}
class User{
private int age;
private String name;
public User(int age, String name) {
super();
this.age = age;
this.name = name;
}
public User(String name) {
super();
this.name = name;
}
public User() {
super();
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
return "User [age=" + age + ", name=" + name + "]";
}
}
//定义项目接口
interface Subject{
public String say(String name, int age);
}
//定义真实项目
class RealSubject implements Subject{
public String say(String name,int age){
return name + " " + age;
}
}
class MyInvocationHandler implements InvocationHandler{
private Object obj = null;
public Object bind(Object obj){
this.obj = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
Object temp = method.invoke(this.obj, args);
return temp;
}
}
interface fruit{
public abstract void eat();
}
class Apple implements fruit{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("Apple");
}
}
class Orange implements fruit{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("Orange");
}
}
class Factory{
public static fruit getInstance(String ClassName){
fruit f = null;
try{
f = (fruit)Class.forName(ClassName).newInstance();
}catch(Exception e){
e.printStackTrace();
}
return f;
}
}
Java反射机制-简单案例实现(代码篇)
最新推荐文章于 2023-11-28 19:41:12 发布