java反射超详细讲解

public class demo1main1 {

     public static void main(string[] args) throws exception {

         //获取class对象的三种对象

         system.out.println( "根据类名：\t" + user. class );

         system.out.println( "根据对象：\t" + new user().getclass());

         system.out.println( "根据全限定类名：\t" + class .forname( "demo1.user" ));

         //常用的方法

         class <user> userclass = user. class ;

         system.out.println( "获取全限定类名：\t" + userclass.getname());

         system.out.println( "获取类名：\t" + userclass.getsimplename());

         system.out.println( "实例化：\t" + userclass.newinstance());

     }

}

根据类名：   class demo1.user

根据对象：   class demo1.user

根据全限定类名：    class demo1.user

获取全限定类名：    demo1.user

获取类名：   user

实例化：    user{name= 'init' , age= 0 }

public string tostring() {

     return (isinterface() ? "interface " : (isprimitive() ? "" : "class " ))

         + getname();

}

package com.cry;

public class test {

     private   class inner{

     }

     public static void main(string[] args) throws classnotfoundexception {

         //普通类

         system.out.println(test. class .getsimplename()); //test

         system.out.println(test. class .getname()); //com.cry.test

         system.out.println(test. class .getcanonicalname()); //com.cry.test

         //内部类

         system.out.println(inner. class .getsimplename()); //inner

         system.out.println(inner. class .getname()); //com.cry.test$inner

         system.out.println(inner. class .getcanonicalname()); //com.cry.test.inner

         //数组

         system.out.println(args.getclass().getsimplename()); //string[]

         system.out.println(args.getclass().getname()); //[ljava.lang.string;

         system.out.println(args.getclass().getcanonicalname()); //java.lang.string[]

         //我们不能用getcanonicalname去加载类对象，必须用getname

         //class.forname(inner.class.getcanonicalname()); 报错

         class .forname(inner. class .getname());

     }

}

public class constructiontest implements serializable {

     public static void main(string[] args) throws exception {

         class <?> clazz = null ;

         //获取class对象的引用

         clazz = class .forname( "com.example.javabase.user" );

         //第一种方法，实例化默认构造方法，user必须无参构造函数,否则将抛异常

         user user = (user) clazz.newinstance();

         user.setage( 20 );

         user.setname( "jack" );

         system.out.println(user);

         system.out.println( "--------------------------------------------" );

         //获取带string参数的public构造函数

         constructor cs1 =clazz.getconstructor(string. class );

         //创建user

         user user1= (user) cs1.newinstance( "hiway" );

         user1.setage( 22 );

         system.out.println( "user1:" +user1.tostring());

         system.out.println( "--------------------------------------------" );

         //取得指定带int和string参数构造函数,该方法是私有构造private

         constructor cs2=clazz.getdeclaredconstructor( int . class ,string. class );

         //由于是private必须设置可访问

         cs2.setaccessible( true );

         //创建user对象

         user user2= (user) cs2.newinstance( 25 , "hiway2" );

         system.out.println( "user2:" +user2.tostring());

         system.out.println( "--------------------------------------------" );

         //获取所有构造包含private

         constructor<?> cons[] = clazz.getdeclaredconstructors();

         // 查看每个构造方法需要的参数

         for ( int i = 0 ; i < cons.length; i++) {

             //获取构造函数参数类型

             class <?> clazzs[] = cons[i].getparametertypes();

             system.out.println( "构造函数[" +i+ "]:" +cons[i].tostring() );

             system.out.print( "参数类型[" +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( ")" );

         }

     }

}

class user {

     private int age;

     private string name;

     public user() {

         super ();

     }

     public user(string name) {

         super ();

         this .name = name;

     }

     /**

      * 私有构造

      * @param age

      * @param name

      */

     private user( int age, string name) {

         super ();

         this .age = age;

         this .name = name;

     }

     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;

     }

     @override

     public string tostring() {

         return "user{" +

                 "age=" + age +

                 ", name='" + name + '\ '' +

                 '}' ;

     }

}

user{age= 20 , name= 'jack' }

--------------------------------------------

user1:user{age= 22 , name= 'hiway' }

--------------------------------------------

user2:user{age= 25 , name= 'hiway2' }

--------------------------------------------

构造函数[ 0 ]: private com.example.javabase.user( int ,java.lang.string)

参数类型[ 0 ]:( int ,java.lang.string)

构造函数[ 1 ]: public com.example.javabase.user(java.lang.string)

参数类型[ 1 ]:(java.lang.string)

构造函数[ 2 ]: public com.example.javabase.user()

参数类型[ 2 ]:()

constructor cs3 = clazz.getdeclaredconstructor( int . class ,string. class );

system.out.println( "-----getdeclaringclass-----" );

class uclazz=cs3.getdeclaringclass();

//constructor对象表示的构造方法的类

system.out.println( "构造方法的类:" +uclazz.getname());

system.out.println( "-----getgenericparametertypes-----" );

//对象表示此 constructor 对象所表示的方法的形参类型

type[] tps=cs3.getgenericparametertypes();

for (type tp:tps) {

     system.out.println( "参数名称tp:" +tp);

}

system.out.println( "-----getparametertypes-----" );

//获取构造函数参数类型

class <?> clazzs[] = cs3.getparametertypes();

for ( class claz:clazzs) {

     system.out.println( "参数名称:" +claz.getname());

}

system.out.println( "-----getname-----" );

//以字符串形式返回此构造方法的名称

system.out.println( "getname:" +cs3.getname());

system.out.println( "-----getogenericstring-----" );

//返回描述此 constructor 的字符串，其中包括类型参数。

system.out.println( "getogenericstring():" +cs3.togenericstring());

-----getdeclaringclass-----

构造方法的类:com.example.javabase.user

-----getgenericparametertypes-----

参数名称tp: int

参数名称tp: class java.lang.string

-----getparametertypes-----

参数名称: int

参数名称:java.lang.string

-----getname-----

getname:com.example.javabase.user

-----getogenericstring-----

getogenericstring(): private com.example.javabase.user( int ,java.lang.string)

public class reflectfield {

     public static void main(string[] args) throws classnotfoundexception, nosuchfieldexception {

         class <?> clazz = class .forname( "reflect.student" );

         //获取指定字段名称的field类,注意字段修饰符必须为public而且存在该字段,

         // 否则抛nosuchfieldexception

         field field = clazz.getfield( "age" );

         system.out.println( "field:" +field);

         //获取所有修饰符为public的字段,包含父类字段,注意修饰符为public才会获取

         field fields[] = clazz.getfields();

         for (field f:fields) {

             system.out.println( "f:" +f.getdeclaringclass());

         }

         system.out.println( "================getdeclaredfields====================" );

         //获取当前类所字段(包含private字段),注意不包含父类的字段

         field fields2[] = clazz.getdeclaredfields();

         for (field f:fields2) {

             system.out.println( "f2:" +f.getdeclaringclass());

         }

         //获取指定字段名称的field类,可以是任意修饰符的自动,注意不包含父类的字段

         field field2 = clazz.getdeclaredfield( "desc" );

         system.out.println( "field2:" +field2);

     }

}

class person{

     public int age;

     public string name;

     //省略set和get方法

}

class student extends person{

     public string desc;

     private int score;

     //省略set和get方法

}

   输出结果:

field: public int reflect.person.age

f: public java.lang.string reflect.student.desc

f: public int reflect.person.age

f: public java.lang.string reflect.person.name

================getdeclaredfields====================

f2: public java.lang.string reflect.student.desc

f2: private int reflect.student.score

field2: public java.lang.string reflect.student.desc

//获取class对象引用

class <?> clazz = class .forname( "reflect.student" );

student st= (student) clazz.newinstance();

//获取父类public字段并赋值

field agefield = clazz.getfield( "age" );

agefield.set(st, 18 );

field namefield = clazz.getfield( "name" );

namefield.set(st, "lily" );

//只获取当前类的字段,不获取父类的字段

field descfield = clazz.getdeclaredfield( "desc" );

descfield.set(st, "i am student" );

field scorefield = clazz.getdeclaredfield( "score" );

//设置可访问，score是private的

scorefield.setaccessible( true );

scorefield.set(st, 88 );

system.out.println(st.tostring());

//输出结果：student{age=18, name='lily ,desc='i am student', score=88}

//获取字段值

system.out.println(scorefield.get(st));

// 88

class clazz = class .forname( "reflect.circle" );

//创建对象

circle circle = (circle) clazz.newinstance();

//获取指定参数的方法对象method

method method = clazz.getmethod( "draw" , int . class ,string. class );

//通过method对象的invoke(object obj,object... args)方法调用

method.invoke(circle, 15 , "圈圈" );

//对私有无参方法的操作

method method1 = clazz.getdeclaredmethod( "drawcircle" );

//修改私有方法的访问标识

method1.setaccessible( true );

method1.invoke(circle);

//对有返回值得方法操作

method method2 =clazz.getdeclaredmethod( "getallcount" );

integer count = (integer) method2.invoke(circle);

system.out.println( "count:" +count);

draw 圈圈,count= 15

drawcircle

count: 100

public interface type {

     //1.8新增

     default string gettypename() {

         return tostring();

     }

}