下面的代码主要是针对反射方面的诸多知识点进行强化巩固，用我们非常熟悉的Student类引出反射机制，意在将反射的方方面面集中在一个类中进行解释说明，并由此产生一些疑问。希望各位大牛同学能够帮我解答一下！

1. package cn.itcast.day1;
   
2. 
   
3. public class Student
   
4. {
   
5.         private String name = "zhangsan";
   
6.         private int age = 26;
   
7.         private String school ="fudandaxue";
   
8.         public void shout()
   
9.         {
   
10.                 System.out.println("name: "+name+",age: "+age+",school: "+school);
    
11.         }
    
12.         private void speak()
    
13.         {
    
14.                 System.out.println("Hello World!");
    
15.         }
    
16.         public Student()
    
17.         {        
    
18.         }
    
19.         public Student(String name, int age) {
    
20.                 this.name = name;
    
21.                 this.age = age;
    
22.         }
    
23.         public Student(String name, int age, String school) {
    
24.                 this(name,age);
    
25.                 this.school = school;
    
26.         }
    
27.         public String toString() {
    
28.                 return "Student [name=" + name + ", age=" + age + ", school=" + school + "]";
    
29.         }
    
30. }
    
31. class TestStudent
    
32. {
    
33.         public static void main(String[] args)
    
34.         {               
    
35.                 Student stu = new Student("zhaohongchun",26,"fudandaxue");
    
36.                 stu.shout();
    
37.         }
    
38. }
    

复制代码

1. package cn.itcast.day1;
   
2. import java.lang.reflect.*;
   
3. 
   
4. public class TestReflect
   
5. {
   
6.         public static void main(String[] args) throws Exception {
   
7.                 //通过反射方式创建Student实例对象。constructor3代表具有三个参数的构造方法。
   
8.                 Constructor constructor3= new Student().getClass().getConstructor(String.class,int.class,String.class);
   
9.                 Student stu= (Student)constructor3.newInstance("zhangsan",26,"fudandaxue");
   
10.                
    
11.                 //访问私有属性，并对其数值进行修改。
    
12.                 Field fieldName = stu.getClass().getDeclaredField("name");
    
13.                 fieldName.setAccessible(true);
    
14.                 fieldName.set(stu, "lisi");
    
15.                 System.out.println(stu);
    
16.                
    
17.                 //访问私有方法speak()。
    
18.                 Method speakMethod = stu.getClass().getDeclaredMethod("speak");
    
19.                 speakMethod.setAccessible(true);
    
20.                 speakMethod.invoke(stu);
    
21.                
    
22.                 //调用未知类startingClassName的main方法。我是用上面的cn.itcast.TestStudent类进行测试。
    
23.                 String startingClassName = args[0];
    
24.                 Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class);
    
25.                 mainMethod.invoke(null,(Object)new String[]{"1"});
    
26.         }
    
27. }
    

复制代码

问题1：如果用反射方式调用某一个类的main方法时，众所周知是用Method mainMethod = Class.forName(startingClassName).getMethod("main",String[] args)，然后用mainMethod.invoke(null,(Object)new String[]{"1"})进行调用，可不可以在不投放参数的情况下调用main方法，就像(null,(Object)new String[]{"1"})中所刻意放进去的new String[]{"1"}，我只想获得main方法中的代码，至于放不放参数有些疑问?有人会发问main(String[] args)它的参数列表便是String[]类型的，我们在获得并使用的时候当然要按照它的格式来投放参数，我也知道这一点，有没有这种可能，反射也可以像我们刚开始接触java时候不放任何参数直接对main()方法进行调用?
问题2：反射机制有利有弊
利：引申出框架结构
弊：破坏了面向对象的封装性，可以对类中的私有属性、私有方法进行访问。过多反射会导致程序性能下降。
除了上面的利弊之外，具体还有哪些利弊?请详细说明！

不传参数调用主函数，是不可能的吧，就连jvm都给main传了一个数组，
如果硬要这样的，你可以讲主函数所在的类创建一个方法，并让方法调用main默认给他传进参数
然后再用反射把这个方法发射直接调用，就可以运行到main了。

第二个问题：
优点：运行期类型的判断，动态类加载，动态代理使用反射。
缺点：性能是一个问题，反射相当于一系列解释操作，通知jvm要做的事情，性能比直接的java代码要慢很多。

反射的使用：小项目就无所谓了，大的项目中，为了性能的考虑，能不用反射就不用反射。