java反射机制

1.Class类的使用
在面向对象的世界里，万事万物皆对象
java语言中，静态的成员、普通的数据类型不是对象
所有类都是java.lang.Class类的实例对象
Class类的对象如何表示
任何一个类都是Class类的实例对象，这个实例对象有三种表示方式

1.Class c1=Student.class;//任何一个类都有一个隐含的静态成员变量class
2.Class c2=student.getClass();//已经知道该类的对象通过getClassF方法

3. Class c3=null;    //反射机制
              try {
                c3=Class.forName("com.wugeek.test.Student");
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
//c1=c2=c3表示了**Studen这个类的、类的类型**c1==c2==c3,我们可以通过这个类的、类的类型去创建该类的对象实例
  Student student=(Student )c3.newInstance();//为Object对象，强转为Student
   
   
1
2
3
4
5
6
7
8
9
10
11
12

2.动态加载类（功能性的类尽量使用动态加载）
静态加载类：编译时刻加载 new创建对象
动态加载类：运行时刻加载 Class.forName(“类的全名”)
编译时：假如有两个类需要加载 Word和Excel,如果采用静态加载，那么这两个类必须全部编译通过才可以运行，如果采用动态加载那么在其中一个类出问题时并不影响另一个类的使用！
代码实现：
编写一个office接口，word和excel类要实现这个接口
编写word和Excel类
分别通过动态加载和静态加载创建实例化对象

1.编写一个office接口，word和excel类要实现这个接口
2.编写word和Excel类
3.分别通过动态加载和静态加载创建实例化对象

//office接口
package com.wugeek.test;
public interface Office {
    public void print();
}
package com.wugeek.test;
//word类
public class Word implements Office{

    @Override
    public void print() {
        System.out.println("Word!");

    }


}
package com.wugeek.test;
/**
Excel类
*/
public class Excel implements Office {

    @Override
    public void print() {
        System.out.println("Excel!");
    }

}
package com.wugeek.test;



/**
主函数
*/
public class UseOffice {
    public static void main(String [] args){
        //静态加载类
        Word word=new Word();
        word.print();
        Excel excel=new Excel();
        excel.print();
        //动态加载类
        try {
            Class c=Class.forName("com.wugeek.test.Word");//传入word就用word,传入excel就用excel!
            Office office=(Office) c.newInstance();
            office.print();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

3.方法的反射调用
方法：方法名+参数列表决定一个方法
获取类的类的类型 Class c=student.getClass();
获取类的信息（方法）Method m=c.getMethod(“方法名”，“参数列表”）；
调用方法：m.invoke(“实例对象”，“参数”）
应用：通过javabean的名获得值
4.理解集合的泛型本质

集合的泛型：防止输入错误的类型，只在编译阶段有效，绕过编译就会无效
反射的操作都是编译之后的操作，运行时的操作，编译后的泛型集合的泛型就擦除了。如果绕过编译就会绕过泛型，错误的泛型就可以插入了

        ArrayList<String> stringlist=new ArrayList<String>();
        ArrayList<Integer> intlist=new ArrayList<Integer>();
        //stringlist.add(20);不允许插入int，只可以插入string
        stringlist.add("20");
        Class stringclass=stringlist.getClass();
        Class intclass=intlist.getClass();
        System.out.println(stringclass==intclass);//结果为true说明编译后泛型被擦除
        try {
            Method m=stringclass.getMethod("add", Object.class);
            m.invoke(stringlist, 111);
            System.out.println(stringlist);//打印结果int 111加入了进去 说明 绕过编译操作就绕过了泛型
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        }

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

            转载来源于   https://blog.csdn.net/peanutwzk/article/details/78739530   版权归作者所有