JAVA學習--反射基本知識


 
     * java.lang.Class:是反射的源頭。
     * 我們創建了一個類,通過編譯(javac.exe),生成對應的.class文件。之后我們使用java.exe加載(JVM的類加載器完成的)
     * 此.class文件,此.class文件加載到內存以后,就是一個運行時類,存在在緩存區。那么這個運行時類本身就是一個Class的實例!
     * 1.每一個運行時類只加載一次!
     * 2.有了Class的實例以后,我們才可以進行如下的操作:
     *     1)*創建對應的運行時類的對象
     *     2)獲取對應的運行時類的完整結構(屬性、方法、構造器、內部類、父類、所在的包、異常、注解、...)
     *     3)*調用對應的運行時類的指定的結構(屬性、方法、構造器)
     *     4)反射的應用:動態代理

 1     //在有反射以前,如何創建一個類的對象,並調用其中的方法、屬性
 2     @Test
 3     public void test1(){
 4         Person p = new Person();
 5 //        Person p1 = new Person();
 6         p.setAge(10);
 7         p.setName("TangWei");
 8         System.out.println(p);
 9         p.show();
10 //        p.display("HK");
11     }
 1     //有了反射,可以通過反射創建一個類的對象,並調用其中的結構
 2     @Test
 3     public void test2() throws Exception{
 4         Class clazz = Person.class;
 5         
 6 //        Class clazz1 = String.class;
 7         
 8         //1.創建clazz對應的運行時類Person類的對象
 9         Person p = (Person)clazz.newInstance();
10         System.out.println(p);
11         //2.通過反射調用運行時類的指定的屬性
12         //2.1
13         Field f1 = clazz.getField("name");
14         f1.set(p,"LiuDeHua");
15         System.out.println(p);
16         //2.2
17         Field f2 = clazz.getDeclaredField("age");
18         f2.setAccessible(true);
19         f2.set(p, 20);
20         System.out.println(p);
21         
22         //3.通過反射調用運行時類的指定的方法
23         Method m1 = clazz.getMethod("show");
24         m1.invoke(p);
25         
26         Method m2 = clazz.getMethod("display",String.class);
27         m2.invoke(p,"CHN");
28         
29     }

 

1     @Test
2     public void test3(){
3         Person p = new Person();
4         Class clazz = p.getClass();//通過運行時類的對象,調用其getClass(),返回其運行時類。
5         System.out.println(clazz);
6     }
 1     //如何獲取Class的實例(3種)
 2     @Test
 3     public void test4() throws ClassNotFoundException{
 4         //1.調用運行時類本身的.class屬性
 5         Class clazz1 = Person.class;
 6         System.out.println(clazz1.getName());
 7         
 8         Class clazz2 = String.class;
 9         System.out.println(clazz2.getName());
10         
11         //2.通過運行時類的對象獲取
12         Person p = new Person();
13         Class clazz3 = p.getClass();
14         System.out.println(clazz3.getName());
15         
16         //3.通過Class的靜態方法獲取.通過此方式,體會一下,反射的動態性。
17         String className = "com.atguigu.java.Person";
18         
19         
20         Class clazz4 = Class.forName(className);
21 //        clazz4.newInstance();
22         System.out.println(clazz4.getName());
23         
24         //4.(了解)通過類的加載器
25         ClassLoader classLoader = this.getClass().getClassLoader();
26         Class clazz5 = classLoader.loadClass(className);
27         System.out.println(clazz5.getName());
28         
29         System.out.println(clazz1 == clazz3);//true
30         System.out.println(clazz1 == clazz4);//true
31         System.out.println(clazz1 == clazz5);//true
32     }
 1     //關於類的加載器:ClassLoader
 2     @Test
 3     public void test5() throws Exception{
 4         ClassLoader loader1 = ClassLoader.getSystemClassLoader();
 5         System.out.println(loader1);
 6         
 7         ClassLoader loader2 = loader1.getParent();
 8         System.out.println(loader2);
 9         
10         ClassLoader loader3 = loader2.getParent();
11         System.out.println(loader3);
12         
13         Class clazz1 = Person.class;
14         ClassLoader loader4 = clazz1.getClassLoader();
15         System.out.println(loader4);
16         
17         String className = "java.lang.String";
18         Class clazz2 = Class.forName(className);
19         ClassLoader loader5 = clazz2.getClassLoader();
20         System.out.println(loader5);
21         
22         //掌握如下
23         //法一:
24         ClassLoader loader = this.getClass().getClassLoader();
25         InputStream is = loader.getResourceAsStream("com\\atguigu\\java\\jdbc.properties");
26         //法二:
27 //        FileInputStream is = new FileInputStream(new File("jdbc1.properties"));
28         
29         Properties pros = new Properties();
30         pros.load(is);
31         String name = pros.getProperty("user");
32         System.out.println(name);
33         
34         String password = pros.getProperty("password");
35         System.out.println(password);
36         
37     }
 1 class Person extends Creature<String> implements Comparable,MyInterface{
 2     public String name;
 3     private int age;
 4     int id;
 5     //創建類時,盡量保留一個空參的構造器。
 6     public Person() {
 7         super();
 8 //        System.out.println("今天天氣很悶熱");
 9     }
10     public Person(String name) {
11         super();
12         this.name = name;
13     }
14     private Person(String name, int age) {
15         super();
16         this.name = name;
17         this.age = age;
18     }
19     public String getName() {
20         return name;
21     }
22     public void setName(String name) {
23         this.name = name;
24     }
25     public int getAge() {
26         return age;
27     }
28     public void setAge(int age) {
29         this.age = age;
30     }
31     
32     public int getId() {
33         return id;
34     }
35     public void setId(int id) {
36         this.id = id;
37     }
38     @MyAnnotation(value = "abc123")
39     public void show(){
40         System.out.println("我是一個人!");
41     }
42     
43     private Integer display(String nation,Integer i) throws Exception{
44         System.out.println("我的國籍是:" + nation);
45         return i;
46     }
47     @Override
48     public String toString() {
49         return "Person [name=" + name + ", age=" + age + "]";
50     }
51     @Override
52     public int compareTo(Object o) {
53         // TODO Auto-generated method stub
54         return 0;
55     }
56     
57     public static void info(){
58         System.out.println("中國人!");
59     }
60     
61     class Bird{
62         
63     }
64     
65 }

 

 1 import static java.lang.annotation.ElementType.CONSTRUCTOR;
 2 import static java.lang.annotation.ElementType.FIELD;
 3 import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
 4 import static java.lang.annotation.ElementType.METHOD;
 5 import static java.lang.annotation.ElementType.PARAMETER;
 6 import static java.lang.annotation.ElementType.TYPE;
 7 
 8 import java.lang.annotation.Retention;
 9 import java.lang.annotation.RetentionPolicy;
10 import java.lang.annotation.Target;
11 
12 @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
13 @Retention(RetentionPolicy.RUNTIME)
14 public @interface MyAnnotation {
15     String value();
16 }
1 public class Creature<T>{
2     public double weight;
3     
4     public void breath(){
5         System.out.println("呼吸!");
6     }
7 }

 1 import java.io.Serializable; 2 3 public interface MyInterface extends Serializable{ 4 5 } 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2020 ITdaan.com