Java反射基础学习

package com.gooagoo.classloader;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Date;

class User {
	  // 注意：已经自定义构造函数，编译器就不会再添加无参构造函数
	  // 如果没有自定义，编译器会自动添加一个无参构造函数
	  public User(String username){
		this.username = username;  
	  }
	  
	  public User(){
	  }
	  
	  private User(String username,int age){
		  this.username = username;
		  this.userage = age;
	  }
	  
    static {   System.out.println("Loading User"); }
    
    public String username;
    private int userage;
    public Date userbirth;
    public  void print(){
        System.out.println("print user: username=" + this.username + "; userage=" + this.userage);
    }
    
    public int cal(){
        return -1;
    }
    
    private void display(){
        System.out.println("display something");
    }
  }
  
public class TestLoader
{   
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{
        try {
            // how to instance 
        	// 注意：实例化默认构造方法，User必须无参构造函数,否则将抛异常
            User userInstance = (User) Class.forName("com.gooagoo.classloader.User").newInstance(); 
            userInstance.print();
            // 总结创建对象实例的几种方法
            // （1）通过JVM内存中的Class对象
            // （2）通过new关键字
            // （3）通过反序列化
            // （4）通过clone

            // 反射：运行时根据XX.class文件全路径加载Class对象到JVM中
            Class<?> someClass = Class.forName("com.gooagoo.classloader.User");
            System.out.println("-----------------get constructors--------------");
            Constructor[] constuctorsPublic =  someClass.getConstructors(); // 获取所有共有构造函数
            for(Constructor constructorTemp: constuctorsPublic){
            	 System.out.println(constructorTemp.getName());
            }
            
            Constructor[] constuctorsAll =  someClass.getDeclaredConstructors(); // 获取所有构造函数
            for(Constructor constructorTemp: constuctorsAll){
           	 System.out.println(constructorTemp.getName());
           }
            
            System.out.println("-----------------call the constructors with parameters-------------");

            // 调用有参构造函数
            User userInstance2 = (User)someClass.getConstructor(String.class).newInstance("liup");
            userInstance2.print();
            
            System.out.println("-----getDeclaredMethods can get all elements(private & public) except constructors except parent elements--------------");
            // 通过反射获取构造有参数构造函数
            Method[] declaredMethods = someClass.getDeclaredMethods();  // 获取所有方法（private & public），不包括父类的
            for(Method method:declaredMethods){
                System.out.println(method.getName());
                System.out.println(method.getReturnType().getName());
            }
            
            Field[] declaredfields = someClass.getDeclaredFields();   // 获取所有字段（private & public），不包括父类的
            for(Field field:declaredfields){
                System.out.println(field.getName());
                System.out.println(field.getType().getName());
            }
            
            
            System.out.println("-----------------getMethods only get public elements include parent public elements except constructors--------------");
            Method[] methods = someClass.getMethods();   // 只能获取到public方法,父类(Object)的public方法也会被获取到，但是不包括构造函数
            for(Method method:methods){
                System.out.println(method.getName());
                System.out.println(method.getReturnType().getName());
            }
            
            Field[] fields = someClass.getFields();     // 只能获取到public字段,父类的public字段也会被获取到
            for(Field field:fields){
                System.out.println(field.getName());
                System.out.println(field.getType().getName());
            }
       
        
            System.out.println("----------------分别通过class和instance获取className----------");
            Class<?> cls = Class.forName("com.gooagoo.classloader.User");
            Class clsRef = User.class;
            System.out.println(cls.getName().equals(userInstance.getClass().getName()));
            
        } catch(ClassNotFoundException e) { // checked exception
          System.out.println("Couldn't find User");
        }
    }
}