反射的基本使用方法

（初学java，个人见解，不一定正确）

package Reflect;

public class ClassDemo {  //重现！！！----> 到位---->自己检查自己
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class c1 = null;//类对象，Class是JDK中的一个类名
		Class c2 = null;
		Class c3 = null;
		
		Student student = new Student();
		
		//Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass方法自动构造的。 
		//1. 类名.class属性 ,更安全，性能更高
		c1 = Student.class;//jvm加载的时候给的class属性
		
		//2.调用Class的静态方法forName()
		c2 = Class.forName("com.bdqn.base.Student");
		
		//3.对象.getClass方法
		c3 = student.getClass();
		
		System.out.println(c1.getName());
		System.out.println(c2.getName());
		System.out.println(c3.getName());
		
//		Object obj = c3.newInstance();
//		Student stu = (Student) obj;
//		stu.setName("张三");
//		
//		System.out.println(stu.getName());
	}
}

package Reflect;

public class Person {
	private String langure;
	public String country;
	
	public void work(String s) {
		System.out.println("工作为："+s);
	}
}

package Reflect;

import java.io.Serializable;
//反射我们项目中都会用到，但不一定是要程序员去敲这些代码
public class Student extends Person implements Serializable,Comparable<Student>{
		    //对象要像能序列化，必须实现Serializable接口，表示其对象是可序列化的
			//Serializable是给jvm用的，我们不需要实现任何它的任何方法
			public static final String XXX="";
			public String name;
			private String gender;
			private int age;
			//反射能看到私有化的数据，跟封装有没有冲突？没有冲突，封装的目的是不让别人随便动，不是不让别人知道
			
			public Student() {
				super();
			}
			
			private Student(String name) {
				super();
				this.name = name;
			}
	
			public Student(String name, String gender, int age) {
				super();
				this.name = name;
				this.gender = gender;
				this.age = age;
			}
	
			public String getName() {
				return name;
			}
	
			public void setName(String name) {
				this.name = name;
			}
	
			public String getGender() {
				return gender;
			}
	
			public void setGender(String gender) {
				this.gender = gender;
			}
	
			public int getAge() {
				return age;
			}
	
			public void setAge(int age) {
				this.age = age;
			}
		
		@Override
		public int compareTo(Student o) {
			// TODO Auto-generated method stub
			return 0;
		}
		public void study(String s) throws NullPointerException {
			System.out.println(s);
		}
		
		private void play(String str) {
			System.out.println("王者荣耀");
		}
		public void play01(String str){
			System.out.println("核平精英");
		}
	}

package Reflect;

import java.lang.reflect.Constructor;

public class TestConstructors {
	//获取某个类中的全部公开构造函数
		public static void main(String[] args) throws Exception {
			Class clas = Class.forName("Reflect.Student");
			
			Constructor[] cons = clas.getConstructors();//获取该类的所有公开构造
			
			//输出所有构造方法的名以及参数列表
			//类似格式Student(String name, String gender, int age)
			for(int i=0;i<cons.length;i++) {
				System.out.print(cons[i].getName()+"(");//获取构造方法的名字
				
				Class<?>[] paras = cons[i].getParameterTypes();//获取构造方法的参数列表
				
				for(int j=0;j<paras.length;j++) {
					if(j == paras.length - 1) {
						System.out.print(paras[j].getName());
					}else {
						System.out.print(paras[j].getName()+",");
					}
				}
				
				System.out.println(")");
			}
			
			Student stu = (Student) cons[0].newInstance("波波","男",18);//通过构造器创建对象
			//在不知道student代码的情况下，我们可以通过反射拿到构造函数，用来创建对象
			System.out.println(stu.getName());
		}
}

package Reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class TestField {
	//获取某个类的全部属性
		public static void main(String[] args) throws Exception {
			Class clas = Class.forName("Reflect.Student");
			//获取该类自定义的属性
			Field[] df = clas.getDeclaredFields();
			for(int i=0;i<df.length;i++) {
				Field f = df[i];//f.getModifiers()获取熟悉的的访问修饰符，public=1,private=2,protected=4,static=8
				System.out.print(f.getModifiers()+" "+Modifier.toString(f.getModifiers()) +" "+f.getType()+" "+f.getName());
				System.out.println();//Modifier.toString()得到访问修饰符对应的字符串
				
				System.out.println(Modifier.isPublic(f.getModifiers()) && Modifier.isStatic(f.getModifiers()));
			}
			
			//获取该类所有，包括从父类继承过来的公开的属性
			Field[] df2 =clas.getFields();
			System.out.println(df2.length);
			for(int i=0;i<df2.length;i++) {
				Field f = df2[i];
				System.out.print(Modifier.toString(f.getModifiers()) +" "+f.getType()+" "+f.getName());
				System.out.println();
			}
		}

}

package Reflect;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class TestMethods {
	//获取某个类的全部公共方法
		public static void main(String[] args) throws Exception {
			Class clas = Class.forName("Reflect.Student");
			
			Method[] ms = clas.getMethods();
			
			for(int i=0;i<ms.length;i++) {
				Method m = ms[i];
				
				Class[] pas = m.getParameterTypes();
				
				StringBuilder params = new StringBuilder();
				for(int j=0;j<pas.length;j++) {
					params.append(pas[j].getName()).append(",");
				}
				
				Class[] es = m.getExceptionTypes();
				
				StringBuilder se = new StringBuilder();
				for(int j=0;j<es.length;j++) {
					se.append(es[j].getName()).append(",");
				}
				
				System.out.println(Modifier.toString(m.getModifiers())+" "+m.getReturnType().getName()+" "+m.getName()+"("+params+")"+"throws "+se);
		}
	}
}

package Reflect;

public class TestParent {
	    //学反射的目的：是告诉你怎么样去获得这个类的内部结构，分析这个类的关系
		//获取一个对象的父类与实现的接口
		public static void main(String[] args) throws ClassNotFoundException {
			Class clas = Class.forName("Reflect.Student");
			Class<?> parent = clas.getSuperclass();//获取父类
			System.out.println(clas.getName()+"的父类为："+parent.getName());
			
			Class<?>[] ims = clas.getInterfaces();//获取父接口，多个，用Class的数组接收
			for(int i=0;i<ims.length;i++) {
				System.out.println(clas.getName()+"实现的接口为："+ims[i].getName());
			}
		}
}

package Reflect;

import java.lang.reflect.Field;

public class TestUseField {
	//通过反射机制调用某个类的属性
		public static void main(String[] args) throws Exception {
			Class clas = Class.forName("Reflect.Student");
			
			Field f = clas.getDeclaredField("gender");//拿某对象的某属性
			f.setAccessible(true);//设置此属性可以访问到
			
			Object obj = clas.newInstance();
			
			f.set(obj, "你好！");//给某对象设置一个filed
			
			Student stu = (Student) obj;
			System.out.println(stu.getGender());
		}
}

package Reflect;

import java.lang.reflect.Method;

public class TestUseMethod {
	//通过反射机制调用某个类的方法
		public static void main(String[] args) throws Exception {
			Class clas = Class.forName("Reflect.Student");
			Method m = clas.getMethod("study", String.class);
			//m是代表方法对象，它要被某个对象调用，对象点方法
			
			m.invoke(clas.newInstance(), "java反射技术");//执行某对象的此 m 方法
			
		}
}