1 package java_reflect;
 2 
 3 public class Person {
 4     public String name;
 5     private int age;
 6     
 7 
 8     static{
 9         System.out.println("我是static的静态代码块！！");
10     }
11     public Person(){}
12     public Person(String name,int age){
13         this.name=name;
14         this.age=age;
15     }
16     private Person(String name){
17         this.name=name;
18     }
19     @Override
20     public String toString() {
21         return "Person [name=" + name + ", age=" + age + "]";
22     }
23     public void eat(){
24         System.out.println("人在吃饭！");
25     }
26     private void sleepPrivate(){
27         System.out.println("我正在睡觉！！！！！");
28     }
29     
30     public  boolean action(String name,int age){
31         
32         System.out.println("我是带有参数的方法，通过反射能执行！");
33         return true;
34     }
35     
36     private  void playGame(String name,int age){
37         System.out.println("人在打游戏："+name+" "+age);
38     }
39     
40 }

 1 package java_reflect;
 2 /**
 3  * 获取一个类class文件对象的三种方式：
 4  * 1.类名字
 5  * 2.对象
 6  * 3.class类的静态方法获取
 7  * */
 8 public class ReflectDemo {
 9     
10     public static void main(String[] args) throws ClassNotFoundException {
11         //1.对象获取
12         Person p=new Person();
13         Class c=p.getClass();
14         System.out.println(c);
15         
16         //2.类名获取
17         //每一个类型，包括基本和引用，都会赋予这个类型一个静态的属性，属性名字class
18         Class c1= Person.class;
19         System.out.println(c1);
20         
21         //person这个类的class文件只有一个，虚拟机只会给这个文件创建一个唯一的Class类
22         //所以c1和p的内存地址都是相等的
23         System.out.println(c1==c);//true
24         System.out.println(c1.equals(c));//true
25         
26         //3.Class类的静态方法获取forname(字符串的类名)
27         Class c3=Class.forName("java_reflect.Person");
28         System.out.println(c3);
29         
30         //这三个方法拿到的对象都是唯一的一个对象
31     }
32 }

 1 package java_reflect;
 2 
 3 import java.lang.reflect.Constructor;
 4 
 5 /**
 6  * 通过反射获取class文件中的构造方法，运行构造方法
 7  * 运行构造方法，创建对象
 8  *         获取class文件对象
 9  *         从class文件对象中，获取需要的成员
10  * 
11  * Constructor 描述构造方法对象的类
12  * */
13 public class ReflectDemo2 {
14     
15     public static void main(String[] args) throws Exception, NoSuchMethodException {
16         Class c=Class.forName("java_reflect.Person");
17         //使用Class文件对象，获取类中的构造方法，找到类class，获取构造器
18         //getConstructors()获取class文件对象中的所有公共的构造方法
19         System.out.println("获得共有的所有的构造方法:");
20         Constructor[] cons= c.getConstructors();
21         for(Constructor con:cons){
22             System.out.println(con);
23             /**
24              * public java_reflect.Person()
25                 public java_reflect.Person(java.lang.String,int)
26              * */
27         System.out.println("获取指定的构造方法！");
28         //空参数的构造方法
29             System.out.println("空参数:");
30             Constructor conss= c.getConstructor();
31             System.out.println(conss);
32             //运行空参数的构造方法，newInstence
33             Object objPerson=conss.newInstance();
34             System.out.println(objPerson);
35             Object obj1=conss.newInstance();
36             System.out.println(obj1);
37         }
38     }
39 }

 1 package java_reflect;
 2 /**
 3  *关于反射和new：知识点
 4  *1.ram和rom 2.对内存和栈内存的区别，以及数据结构的方式，以及存储的到底是什么
 5  *3.new 和反射是2中不同的设计方式:关键字；动态开辟一个对象和直接开辟多个对象
 6  * 
 7  * */
 8 import java.lang.reflect.Constructor;
 9 
10 public class ReflectDemo3 {
11     
12     public static void main(String[] args) throws Exception {
13         Class c=Class.forName("java_reflect.Person");
14         //Class...parameterTypes基本数据类型的Class文件
15         //1.获取带有参数的构造函数的参数列表
16         Constructor con= c.getConstructor(String.class,int.class);
17         System.out.println(con);
18         //2.运行构造方法:initargs（实际参数）
19         Person p=(Person) con.newInstance("haha",35);
20         System.out.println(p);
21     }
22 }

 1 package java_reflect;
 2 /**
 3  * 反射获取构造方法并运行，有快捷的方式
 4  * 有前提：
 5  *         被反射的类，必须是有空参数构造方法
 6  *         构造方法的权限必须是public
 7  * */
 8 public class ReflectDemo4 {
 9     
10     public static void main(String[] args) throws Exception{
11         Class c=Class.forName("java_reflect.Person");
12         //Class类中定义了一个方法，newInstance()
13         
14         //注意这个Class类中的方法newInstance是不能传递参数的
15         //这样也使得构造方法必须是有一个空参数的构造方法
16         //所以我们在写类的时候如果用到反射，最好也是写上空参数构造器
17         Object obj=c.newInstance();
18         System.out.println(obj);
19     }
20 }

 1 package java_reflect;
 2 
 3 import java.lang.reflect.Constructor;
 4 
 5 /**
 6  * 反射获取私有的构造方法运行
 7  *     不推荐，破坏了程序的封装性
 8  * 
 9  * 我们可以使用暴力反射，强行打破Java中的类在运行时的权限
10  * */
11 public class ReflectDemo6 {
12     
13     public static void main(String[] args) throws Exception {
14         Class c=Class.forName("java_reflect.Person");
15         //获得私有的构造器getDeclaredConstructors() 
16         Constructor [] cons=c.getDeclaredConstructors();
17         for(Constructor con:cons){
18             System.out.println(con);
19         }
20         System.out.println("私有的指定的一个私有构造器！");
21         Constructor conPrivate=c.getDeclaredConstructor(String.class);
22         System.out.println(conPrivate);
23 //        Person p2=(Person)conPrivate.newInstance("李泽博！");
24         //错误，main中无法访问私有的构造器
25         
26         //1.使用暴力反射
27         /**
28          * AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。
29          * 对于公共成员、默认（打包）访问成员、受保护成员和私有成员，
30          * 在分别使用 Field、Method 或 Constructor 
31          * 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，
32          * 会执行访问检查。
33          * */
34         Constructor con=c.getDeclaredConstructor(String.class);
35         con.setAccessible(true);
36         //运行私有的构造器！！ 
37         con.newInstance("李泽博！！！！！！！！！");
38     }
39 }

 1 package java_reflect;
 2 
 3 import java.lang.reflect.Field;
 4 
 5 public class ReflectDemo7 {
 6 
 7         public static void main(String[] args) throws Exception{
 8             Class  c=Class.forName("java_reflect.Person");
 9             Object obj=c.newInstance();
10             //获取成员变量的Clas变量的方法getField class文件中所有公共的成员变量
11             //返回值是Field[] Fiel类描述成员变量对象的类
12             
13             //拿的是公有的成员变量
14             System.out.println("拿的是私有的成员变量");
15             Field[] fields= c.getFields();
16             for(Field field:fields){
17                 System.out.println(field);
18             }
19             //私有的，公有的一起，也即是声明了的变量
20             System.out.println("私有的 :");
21             Field [] fiels1=c.getDeclaredFields();
22             for(Field fiels:fiels1){
23                 System.out.println(fiels);
24             }
25             //获取指定的一个成员变量
26             System.out.println("获取指定的一个成员变量");
27             Field fieldss=c.getField("name");
28             System.out.println(fieldss);
29             
30             System.out.println("改掉变量值为‘王五‘");
31             fieldss.set(obj, "王五！！");
32             
33             System.out.println(obj);
34             //这里如果我们不是用obj,上面创建的对象，那么使用c.newInstance()会使得
35             //你创建了2个对象，使得结果是null，0
36         }
37 }

 1 package java_reflect;
 2 
 3 import java.lang.reflect.Method;
 4 
 5 public class ReflectDemo8 {
 6 
 7     public static void main(String[] args) throws Exception {
 8         Class c=Class.forName("java_reflect.Person");
 9         Object obj=c.newInstance();
10         //获取到成员方法
11         //Method []getMethods()获取的是Class文件的所有公共的成员方法，包括继承的
12         //Method是描述成员方法的对象类
13         System.out.println("成员方法：");
14         Method [] methods= c.getMethods();
15         for(Method method:methods){
16             System.out.println(method);
17         }
18         System.out.println("利用反射使用method:");
19         Method method= c.getMethod("eat");
20         System.out.println(method);
21         method.invoke(obj);
22     }
23 }

 1 package java_reflect;
 2 
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.Method;
 5 
 6 public class ReflectDemo9 {
 7     
 8     public static void main(String[] args) throws Exception {
 9         Class c=Class.forName("java_reflect.Person");
10         Object obj=c.newInstance();
11         
12         Method method= c.getMethod("action", String.class,int.class);
13         boolean  bool=(Boolean) method.invoke(obj,"李泽博",23);
14         System.out.println(bool);
15         //通过反射获取私有的带参数的方法
16         System.out.println("通过反射获取私有的带参数的方法");
17         Object obj1=c.newInstance();
18         Method method1=c.getDeclaredMethod("playGame", String.class,int.class);
19         //在使用反射式，取消Java中权限
20         method1.setAccessible(true);
21         method1.invoke((Person)obj1, "李泽博sdf",23);
22         
23     }
24 }