java--反射常用方法（三）

一、Class中获取构造方法

• Constructor类用于描述类中的构造方法：
• Constructor<T> getConstructor(Class<?>... parameterTypes) 

返回该Class对象表示类的指定的public构造方法; 

• Constructor<?>[] getConstructors()

返回该Class对象表示类的所有public构造方法; 

• Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

返回该Class对象表示类的指定的构造方法,和访问权限无关;

• Constructor<?>[] getDeclaredConstructors() 

 

返回该Class对象表示类的所有构造方法,和访问权限无关;

Class中获取构造方法实例

      package reflect;
      import java.lang.reflect.Constructor;
      import java.util.Date;
      class Person {
     	//没有使用public修饰的类的默认构造器的访问修饰符是啥？
     	//一个类的默认的构造器的访问权限和类的访问权限一致；
      }
      public class ConstructorDemo {
     	public static void main(String[] args) throws Exception {
     		// 得到Person里所有公共的构造器
     		// 先得到Person的字节码
      		Class<Dept> clz = Dept.class;
     		// 获得Person里所有public的构造器
      		Constructor<?>[] cs = clz.getConstructors();//只能获得公共 的构造器
     		//Constructor<?>[] cs = clz.getDeclaredConstructors();//所有的构造器
      		System.out.println(cs.length);
     		for (Constructor<?> c : cs) {
      			System.out.println(c);
      		}
     		//===========================================
     		//获得指定的构造器 protected Dept(int age)
     		/**
       * Constructor<T> getConstructor(Class<?>... parameterTypes)
       获得Class所表示类的指定的public修饰的构造器；
       Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
       获得Class所表示类的指定的构造器，和访问权限无关；
       */
     		//Constructor<Dept> con = clz.getConstructor(int.class);
      		Constructor<Dept> con = clz.getDeclaredConstructor(int.class);
      		System.out.println("-->"+con);
     		//获得 private Dept()
      		con = clz.getDeclaredConstructor();
      		System.out.println(con);
     		//获得protected Dept(int age,Date d) 
      		con = clz.getDeclaredConstructor(int.class,Date.class);
      		System.out.println(con);
      	}
      }
  
 

二、Class获取Method

• Method类用于描述类中的方法：
• Method getMethod(String name, Class<?> ... parameterTypes) 

返回该Class对象表示类和其父类的指定的public方法; 

• Method[] getMethods()：  

返回该Class对象表示类和其父类的所有public方法; 

• Method getDeclaredMethod(String name, Class<?>... parameterTypes) 

返回该Class对象表示类的指定的方法。和访问权限无关，但不包括继承的方法;

• Method[] getDeclaredMethods(): 获得类所有的方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法;

Class获取Method实例

      package reflect;
      import java.lang.reflect.Method;
      import java.lang.reflect.Modifier;
      import java.util.Date;
      import java.util.List;
      class Sub extends Object {
     	private void show1() {
      	}
     	void show2() {
      	}
     	protected void show3() {
      	}
     	public void show4() {
      	}
     	@Deprecated
     	public  void  ooxx(byte[] bys, int age, Integer i1, String name, Date bornDate){}
      }
      public class MethodDemo {
     	public static void main(String[] args) throws Exception {
     		// 得到Object里所有的public修饰的方法
      		Class<Sub> clz = Sub.class;
     		/**
       * Method[] getMethods() 得到Class所表示类的所有的public修饰的方法,包括继承过来的方法 Method[]
       * getDeclaredMethods() 和访问权限无关，不包括继承过来的的方法
       */
     		// Method[] ms = clz.getMethods();
      		Method[] ms = clz.getDeclaredMethods();
     		for (Method m : ms) {
      			System.out.println(m);
      		}
      		System.out.println("-0--------------------------");
     		//获得指定的方法；
     		/**
       * Method getMethod(String methodName, Class<?>... parameterTypes) :public修饰的方法
       * Method getDeclaredMethod(String methodName, Class<?>... parameterTypes) 和权限无关，不包括继承的
       */
     		//只获得protected void show3()
     		Method m = clz.getDeclaredMethod("show3");
      		System.out.println(m);
     		//获得public void ooxx(byte[] bys, int age, Integer i1, String name, Date bornDate)
      		m  = clz.getMethod("ooxx", byte[].class, int.class,Integer.class,String.class,Date.class);
      		System.out.println(m);
      		System.out.println(m.getName());
      		System.out.println(Modifier.toString(m.getModifiers()));
      		System.out.println(m.getReturnType());
     		//Arrays: 得到 public static <T> List<T> asList(T... a)
      	}
      }
  
 

三、Class中获取Field

• Field类用于描述类中的字段：
• Field getField(String name) 

返回该Class对象表示类和其父类的指定的public字段;  

• Field[] getFields() 

返回该Class对象表示类和其父类的所有public字段;

• Field getDeclaredField(String name) 

返回该Class对象表示类的指定的字段和访问权限无关,但不包括继承的字段; 

• Field[] getDeclaredFields()

 

返回当前Class对象中公共、保护、默认（包）访问和私有字段,但不包括继承的字段;    

Class中获取Field实例

      package reflect;
      import java.lang.annotation.Annotation;
      import java.lang.reflect.Field;
      import java.lang.reflect.Modifier;
      import java.util.Date;
      class People{
     	public String name;
      }
      class Student extends People{
     	@Deprecated
     	private int age;
     	public Date bornDate;
      }
      public class FieldDemo {
     	public static void main(String[] args) throws Exception {
      		Class<Student> clz = Student.class;
     		/**
       * Field[] getFields() : 得到Class所表示类的所有的public修饰的字段，包括继承的
       * Field[] getDeclaredFields() ：　得到Class所表示类的所有的字段和访问权限无关，不包括继承的
       */
     		//Field[] fs = clz.getFields();
      		Field[]  fs = clz.getDeclaredFields();
     		for (Field field : fs) {
      			System.out.println(field);
      		}
      		System.out.println("--------------------------");
     		/**
       * 获得指定的一个字段：
       * Field getField(String filedName) : 得到Class所表示类的所有的public修饰的字段，包括继承的
       * Field getDeclaredField(String fileName) ：　得到Class所表示类的所有的字段和访问权限无关，不包括继承的
       */
     		Field f = clz.getDeclaredField("age");
      		System.out.println(f.toString());
      		System.out.println(Modifier.toString(f.getModifiers()));
      		System.out.println(f.getType());
      		System.out.println(f.getName());
      		Annotation[] as   = f.getDeclaredAnnotations();
     		for (Annotation a : as) {
      			System.out.println(a);
      		}
      	}
      }
  
 

四、Class常用方法

      package reflect;
      import java.io.Serializable;
      import java.lang.reflect.Modifier;
      import java.util.Date;
      import java.util.Map;
      @Deprecated//表示过时
      class Emp implements Serializable,Comparable<Emp>{
     	 private class A{
      	}
     	 class B{
      	}
     	public int compareTo(Emp o) {
     		return 0;
      	}
      }
      public class ClassCommonMethodDemo {
     	public static void main(String[] args) {
     		//获得Emp类里的信息//Date
      		Class<Emp> clz = Emp.class;
     		/**
       * Annotation[] getAnnotations() 返回此元素上存在的所有注释。
       */
      		System.out.println(clz.getAnnotations().length);
     		/**
       * Class<?>[] getClasses()
       得到Class所描述类的所有的public修饰的内部类
       Class<?> getDeclaredClasses()
       得到Class所描述类的所有的内部类,和访问权限无关
       */
     		//Class<?>[] innerClass = clz.getClasses();
      		Class<?>[] innerClass = clz.getDeclaredClasses();
      		System.out.println(innerClass.length);
     		for (Class<?> c : innerClass) {
      			System.out.println(c);
      		}
     		/**
       * Class<?>[] getInterfaces() 确定此对象所表示的类或接口实现的接口。
       */
      		System.out.println("接口 "+clz.getInterfaces().length);
     		/**
       * int getModifiers() 返回此类或接口以整数编码的 Java 语言修饰符。
       */
     		/**
       * Modifier:
       * static String toString(int mod) 返回描述指定修饰符中的访问修饰符标志的字符串。
       */
      		Class<Date> clzDate = Date.class;
      		System.out.println(clzDate.getModifiers());//1
      		System.out.println(Modifier.toString(clzDate.getModifiers()));//public
     		/**
       * String getName() 返回Class所描述类的全限定名
       * String getSimpleName() 返回源代码中给出的底层类的简称。
       */
      		System.out.println(clz.getName());//reflect.Emp
      		System.out.println(clz.getSimpleName());//Emp
     		/**
       * Package getPackage() 获取此类的包。
       */
      		System.out.println(clz.getPackage());
     		/**
       * Class<? super T> getSuperclass()
       返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
       */
      		System.out.println("clz.getSuperclass()＝　" +clz.getSuperclass());
      		System.out.println(String.class.isArray());//false
      		System.out.println(String[].class.isArray());//true
      		System.out.println(Map.class.isInterface());
      		System.out.println(Gender.class.isEnum());
      		System.out.println(int[].class.isPrimitive());//
      		System.out.println(int.class.isPrimitive());
      		System.out.println(Deprecated.class.isAnnotation());
     		/**
       * <U> Class<? extends U> asSubclass(Class<U> clazz)
       强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。
       */
     		Object obj = new Date();
      		Class<Date> d  = (Class<Date>) obj.getClass().asSubclass(Date.class);
      		System.out.println(d);
     		/**
       * boolean isInstance(Object obj)
       判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。
       对象 instanceof 类
       */
      		System.out.println("-->"+obj.getClass());//Date d = new Date();
     		boolean b    = Object.class.isInstance(new Date());
      		System.out.println(b);//true
      		System.out.println(Date.class.isInstance(obj));
      	}
      }
  
 

五、Class创建对象

创建对象：

• 使用Class对象的newInstance()方法创建该Class对象的实例，此时该Class对象必须要有无参数的构造方法。
• 使用Class对象获取指定的Constructor对象，再调用Constructor的newInstance（）方法创建对象类的实例，此时可以选择使用某个构造方法。

创建对象实例

      package reflect;
      import java.lang.reflect.Constructor;
      import java.util.Date;
      class Teacher{
     	private Teacher(String name){
      		System.out.println(name);
      	}
     	public String toString() {
     		return "老师";
      	}
      }
      public class NewInstanceDemo {
     	public static void main(String[] args) throws Exception {
     	// Teacher t = new Teacher();
     		//System.out.println(t);
     		/**使用反射来创建对象
       * 1.
       * public T newInstance():只能创建非private，无参的构造方法的对象；好比 new 类()；
       * T classInstance.newIntance();
       * 如同用一个带有一个空参数列表的 new 表达式实例化该类。如果该类尚未初始化，则初始化这个类。
       *
       * 2.
       * 1>.先得到一个指定的构造方法，
       * 2>.调用构造器里的一个方法，
       * T newInstance(Object... initargs) 、
       * initargs表示构造器的需要的实际参数
       */
      		Class<Teacher> clz = Teacher.class;
     		//Teacher t2 = clz.newInstance();
     		//System.out.println(t2);
     	// System.out.println(t == t2);//false
     		//调用有参的私有构造方法
      		Constructor<Teacher> con  = clz.getDeclaredConstructor(String.class);
     		/**
       * 访问私有的成员之前:先设置其为可访问的
       *
       * AccessibleObject: 表示可访问的对象，是Contructor，Method,Filed的父类；
       * 方法： void setAccessible(boolean flag) ：用来设置是否可访问的
       若要设置可访问的：
       obj.setAccessible(true);
       */
      		con.setAccessible(true);//设置可访问的
     		Teacher t = con.newInstance("will");
      		System.out.println(t);
     		//===========================
      		System.out.println("------------------");
      		createInstance();
      	}
     	//使用反射来创建java.util.Date的对象
     	public  static void  createInstance() throws Exception{
     		//new Date();
      		Class<?> clz = Class.forName("java.util.Date");
     		Date d = (Date) clz.newInstance();
      		System.out.println(d);
     		//
      		Constructor<Date> con = (Constructor<Date>) clz.getConstructor();
      		System.out.println(con.newInstance());
     		//new Date(long time);
      		con = (Constructor<Date>) clz.getConstructor(long.class);
      		System.out.println(con.newInstance(1));
      	}
      }
  
 

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/80105073