java反射

package com.xissl.reflect;
public class Student {
  private String sid;
  private String sname;
  public Integer age;
  static{
    System.out.println("加载进jvm中！");
  }
  public Student() {
    super();
    System.out.println("调用无参构造方法创建了一个学生对象");
  }
  public Student(String sid) {
    super();
    this.sid = sid;
    System.out.println("调用带一个参数的构造方法创建了一个学生对象");
  }
  public Student(String sid, String sname) {
    super();
    this.sid = sid;
    this.sname = sname;
    System.out.println("调用带二个参数的构造方法创建了一个学生对象");
  }
  @SuppressWarnings("unused")
  private Student(Integer age) {
    System.out.println("调用Student类私有的构造方法创建一个学生对象");
    this.age = age;
  }
  public String getSid() {
    return sid;
  }
  public void setSid(String sid) {
    this.sid = sid;
  }
  public String getSname() {
    return sname;
  }
  public void setSname(String sname) {
    this.sname = sname;
  }
  public void hello() {
    System.out.println("你好！我是" + this.sname);
  }
  public void hello(String name) {
    System.out.println(name + "你好！我是" + this.sname);
  }
  @SuppressWarnings("unused")
  private Integer add(Integer a, Integer b) {
    return new Integer(a.intValue() + b.intValue());
  }
}

package com.xissl.reflect;
/**
 * 类类（class类）的获取方式:一切反射的操作都从获取类对象开始
 * 1.Class.forname
 * 2.类实例.getclass()
 * 3.类名.class
 * @author xissl
 */
public class Demo01 {
  public static void main(String[] args) throws Exception {
    Student stu = new Student();
    //1.Class.forname 类的全路径名
    Class class1 = Class.forName("com.xissl.reflect.Student");
    System.out.println(class1);
    //2.类实例.getclass() 通用增删改
    Class class2 = stu.getClass();
    System.out.println(class2);
    //3.类名.class 通用查询
    Class class3 = Student.class;
    System.out.println(class3);
  }
}

package com.xissl.reflect;
import java.lang.reflect.Constructor;
/**
 * 反射实例化
 * 反射默认调用的是无参构造器
 * @author xissl
 *
 */
public class Demo02 {
  public static void main(String[] args) throws Exception {
    Class class1 = Class.forName("com.xissl.reflect.Student");
    //1.调用无参构造器反射实例化
    Student s1 = (Student) class1.newInstance();
    System.out.println(s1);
    //2.调用有一个参数的构造器实例化
    //括号里面填的是参数的类别 
    Constructor cr1 = class1.getConstructor(String.class);
    Student s2 = (Student) cr1.newInstance("s001");
    System.out.println(s2);
    //3.调用有两个参数的构造器实例化
    Constructor cr2 = class1.getConstructor(String.class,String.class);
    Student s3 = (Student) cr2.newInstance("s002","nb");
    System.out.println(s3);
    //4.调用私有的带一个参数的构造器实例化
    Constructor cr3 = class1.getDeclaredConstructor(Integer.class);
    //打开私有修饰符的访问权限
    cr3.setAccessible(true);
    Student s4 = (Student) cr3.newInstance(20);
    System.out.println(s4);
  }
}

package com.xissl.reflect;
import java.lang.reflect.Field;
/**
 * 反射读写属性
 * @author xissl
 *
 */
public class Demo04 {
  public static void main(String[] args) throws Exception {
    //一切反射从类类开始
    Class class1 = Class.forName("com.xissl.reflect.Student");
    Student student = new Student("s001", "yh");
    //写
    Field snameField = class1.getDeclaredField("sname");
    snameField.setAccessible(true);
    snameField.set(student, "sb");
    //获取属性对象 读
    Field[] f = class1.getDeclaredFields();
    for (Field field : f) {
      field.setAccessible(true);
      System.out.println(field.getName()+":"+field.get(student) );
    }
  }
}