JAVA学习--反射属性操作

 1     //获取对应的运行时类的属性
 2     @Test
 3     public void test1(){
 4         Class clazz = Person.class;
 5         //1.getFields():只能获取到运行时类中及其父类中声明为public的属性
 6         Field[] fields = clazz.getFields();
 7         
 8         for(int i = 0;i < fields.length;i++){
 9             System.out.println(fields[i]);
10         }
11         System.out.println();
12         //2.getDeclaredFields():获取运行时类本身声明的所有的属性
13         Field[] fields1 = clazz.getDeclaredFields();
14         for(Field f : fields1){
15             System.out.println(f.getName());
16         }
17     }

 1 //权限修饰符  变量类型 变量名
 2     //获取属性的各个部分的内容
 3     @Test
 4     public void test2(){
 5         Class clazz = Person.class;
 6         Field[] fields1 = clazz.getDeclaredFields();
 7         for(Field f : fields1){
 8             //1.获取每个属性的权限修饰符
 9             int i = f.getModifiers();
10             String str1 = Modifier.toString(i);
11             System.out.print(str1 + " ");
12             //2.获取属性的类型
13             Class type = f.getType();
14             System.out.print(type.getName() + " ");
15             //3.获取属性名
16             System.out.print(f.getName());
17             
18             System.out.println();
19         }
20     }

 1 //调用运行时类中指定的属性
 2     @Test
 3     public void test3() throws Exception{
 4         Class clazz = Person.class;
 5         //1.获取指定的属性
 6         //getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性
 7         Field name = clazz.getField("name");
 8         //2.创建运行时类的对象 
 9         Person p = (Person)clazz.newInstance();
10         System.out.println(p);
11         //3.将运行时类的指定的属性赋值
12         name.set(p,"Jerry");
13         System.out.println(p);
14         System.out.println("%"+name.get(p));
15         
16         System.out.println();
17         //getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性
18         Field age = clazz.getDeclaredField("age");
19         //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。
20         age.setAccessible(true);
21         age.set(p,10);
22         System.out.println(p);
23         
24 //        Field id = clazz.getField("id");
25         
26     }

 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 }

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();
}

public class Creature<T>{
    public double weight;
    
    public void breath(){
        System.out.println("呼吸！");
    }
}

import java.io.Serializable;

public interface MyInterface extends Serializable{

}