JAVA反射的基础

                 反射

2.1获取类对象的方式 ： 三种方式
1 对象.getClass();
2 类名.class;
3 Class.forname(“类的全名称”);
2.2创建实例
clazz.newInstance(); 默认无参构造
Constructor c=clazz.getConstructor(…);
c.newInstance(…);
2.3获取类的属性
clazz.getField(…); //公共的 ，包含继承
clazz.getFields(); //公共的，包含继承
clazz.getDeclaredField(); //一个属性，不包含继承
clazz.getDeclaredFields(); //所有的属性，不包含继承

          field.set(obj,value);//赋值
      field.get(obj);//获取

2.4获取类的方法
clazz.getMethod(…); //公共的 ，包含继承
clazz.getMethods(); //公共的，包含继承
clazz.getDeclaredMethod(); //一个属性，不包含继承
clazz.getDeclaredMethods(); //所有的属性，不包含继承
method.invoke(obj,…);

 //需求：   利用反射技术来解剖Person
 //Person类
 public class Person {
    private String name;
    private int age;
    private String gender;
    public Person() {
        System.out.println("我是无参构造发方法");
    }
    public Person(String name, int age, String gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
        System.out.println("我是有参构造方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    /**
     * 打印信息 无参方法
     */
    public void showInfo(){
        System.out.println("姓名:"+name+" 年龄:"+age+" 性别:"+gender);
    }
    /**
     * 打印信息 ，带参方法
     */
    public void showInfo(String address){
        System.out.println("姓名:"+name+" 年龄:"+age+" 性别:"+gender+" 地址："+address);
    }
    /**
     * 返回信息  带返回值的方法
     * @return
     */
    public String getInfo(){
        return "姓名:"+name+" 年龄:"+age+" 性别:"+gender;
    }
    /**
     * 私有方法
     * @return
     */
    private void  sleep(){
        System.out.println("这是一个私有方法");
    }

    /**
     * 静态方法
     */
    public static void  Say(){
        System.out.println("要放假了....哈哈哈");
    }

}
//利用反射技术来解剖Person类
public class ReflectDome{
    public static void main(String[]args)
    {
        getClassDemo();
    }
    //获取类对象   有三种方法  一般使用第三种方法
    public static void getClassDemo()
    {
        //第一种方式  通过类的class属性获取
        Class class1=Person.class;
        System.out.println(class1);
        //第二种方式  通过类的对象getClass方法
        Person bingbing =new Person();
        Class class2=bingbing.getClass();
        System.out.println(class2);
        //第三种方式  通过Class.forName()方法
        Class class3=Class.forName("com.qianfeng.day30.Person");
        System.out.println(class3);
    }
    //获取构造方法
    public static void getConstructDemo()throws Exception
    {
        //1.获取类对象
        Class class1=Class.forName("包名.Person");
        //2.获取构造方法
        //2.1获取多个的构造方法
        Constructor []constructors=class1.getConstructors();
        for(Constructor constructor:constructors)
        {
            System.out.println(constructor);
        }
        //2.2获取一个  无参的构造方法
        Constructor constructor=class1.getConstructor(null);
            System.out.println(constructor);
        //2.3获取 一个 带参的构造函数
        Constructor constructor=class.getConstructor(String.class,int.class,String.class);
        Object object=constructor.newInstance("冰冰",20,"女");     
    } 
    public static void getMethodDemo()throws Exception
    {
        //1.获取去类的对象
        Class class1=Class.forName("包名.Person");
        //创建对象
        Constructor constructor=class.getConstructor(String.class,int.class,String.class);
        Objent bing=constructor.newInstance("彬彬",20,"女");
        //2.获取方法对象
        //2.1通过getMethods()
        Method[]methods=class.getMethods();//只能获取到公共的方法和从父类继承的方法
        for(Method nethod:methods)
        {
            System.out.println(method);
        }
        //2.2通过getDeclaredMethods()
        Method[]methods=class.getDeclaredMethods();//获取类中所以的方法，不包含父类中的方法
        for(Method nethod:methods)
        {
            System.out.println(method);
        }
        //2.3获取一个无参的方法
        Method method=class.getDeclaredMethods("showInfo",null);
        Objent bing=class.newInstance();//调用的是默认的无参构造
        method.invoke(bing,null);
        //2.4获取一个有参的方法
        Method method=class.getDeclaredMethods("showInfo",String.class);
        method.invoke(bing,"北京");
        //2.5获取带返回值的方法
        Method method=class.getDeclaredMethods("getInfo",null);
        Object result=method.invoke(bing,null);
        System.out.println(resule);
        //2.6获取私有的方法
        Method method=class.getDeclaredMethods("sleep",null);
        method.setAccessible(true);//设置访问修饰符无效
        method.invoke(null,null);
        //2.7获取静态方法
        Method method=class.getDeclaredMethods("Say",null);
        method.invoke(null,null);
    }
    //获取字段（属性）
    public static void getFieldDemo()throws Exception
    {
        //1.获取去类的对象
        Class class1=Class.forName("包名.Person");
        Object xinxin=class.newInstance();
        Field[]fields=class1.getFidles();//只能获取公开的字段和继承父类所以的字段
        for(Field field:fields)
        {
            System.out.println（field）;
        }
        Field[]fields=class1.getDeclareFidles();
        for(Field field:fields)
        {
            System.out.println（field）;
        }
        Field[]field=class1.getDeclareFidles("name");
        field.setAccessible(true);//设置访问权限无效
        field.set(xinxin,"鑫鑫");
        Object obj=field.get(xinxin);
        System.out.pringln(obj);
    }

}