javaSE高级开发反射（上）

java是一个纯面向对象的语言
一、初识反射
1.反射指的是对象的反操作。那么正的操作就是先导入一个包，然后才能产生类的实例化对象
正向操作：

从代码上来理解正向和反向操作：

package com.wschase.reflect;

import java.util.Date;

/**
 * Author:WSChase
 * Created:2019/1/19
 */
public class TestClass {
    public static void main(String[] args) {

    //1.普通的一个对象，通过java.util.Date这个类实例化的
    Date date=new Date();

    //2.反向操作——反射
    Class classz=date.getClass();
        System.out.println(classz);
    }
}

最后可以得到这个类——这就叫反向操作，即是反射。
2.三种实例化对象
（1）对象实例化：（常考选择）
（1）new 构造方法
（2）反序列化
（3）反射

//反射的方法
try {
            Date date1=(Date)classz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

（2）Class对象获取

    //Class对象获取
        //1.object.getClass
        Class classz1=date.getClass();
        System.out.println(classz1);
        //2.ClassName.class
        //建议：一般在开发反射的代码中我们经常使用类的权限名
        Class<java.util.Date> dateClass=Date.class;
        System.out.println(dateClass);
        try {
            Date date2 = dateClass.newInstance();
            System.out.println(date2);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        //3.Class.forName("className");

        Class dateClass1 ;
        try {
            Class<Date> dateClass1= (Class<Date>) Class.forName("java.util.Date");
        } catch (ClassNotFoundException e) {
            //注意：这里的异常
            e.printStackTrace();
        }

        //当前这三个Class对象都是由Class<java.util.Date>获取，都来描述java.util.Date这个类
        System.out.println("比较三个Class对象");
        System.out.println(classz==dateClass);
        System.out.println(classz==dateClass1);

        //Class这个类是描述我们在java中定义的类
        //Class类的对象是Class文件加载到JVM中的标识对象（类加载器）

二、反射与类操作
1.反射调用父类信息

package com.wschase.reflect;

/**
 * Author:WSChase
 * Created:2019/1/19
 */
public class TestClassMethod {
    public static void main(String[] args) {
        //1.获取Class对象所描述的类的包
        //2.获取Class对象所描述的类的继承的类
        //3.获取Class对象所描述的类的实现接口

        try {
            Class<Test> testClass= (Class<Test>) Class.forName("com.wschase.reflect.Test");

            Package aPackage=testClass.getPackage();
            //1.获取Class对象所描述的类的包
            System.out.println("打印包名：");
            System.out.println(aPackage.getName());//包名

            Class superclass=testClass.getSuperclass();
            //2.获取Class对象所描述的类的继承的类
            System.out.println("打印父类toString()");
            System.out.println(superclass);


            System.out.println("打印父类SimpleName："+superclass.getSimpleName());
            System.out.println("打印父类Name："+superclass.getName());

            //3.获取Class对象所描述的类的实现接口
            Class[] classes=testClass.getInterfaces();
            System.out.println("打印实现的接口");
            for(Class c:classes){
                System.out.println(c);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

interface IMessage{

}
interface IFruit1{

}

//extends Object
class Test implements IMessage,IFruit1{

}

2.反射调用构造

package com.wschase.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * Author:WSChase
 * Created:2019/1/19
 */
public class TestClassConstructor {

    public static void main(String[] args) {

        try {
            Class classz=Class.forName("com.wschase.reflect.Person");
        //1.构造方法
            Constructor[] constructors=classz.getConstructors();
            System.out.println("打印输出Person类的构造方法：");
            for(Constructor constructor:constructors){
                System.out.println(constructor);
            }
            System.out.println("打印输出Person类的一个参数的构造方法：");
            System.out.println(classz.getConstructor(java.lang.String.class));
        //2.（1）class.newInstance =>类里面有无参数构造方法
            Person p= (Person) classz.newInstance();
            System.out.println(p);
            //（2）Person(String name)-》有参构造方法
            //Constructor =>获取构造方法对象，执行构造方法对象的newInstance(参数值...)
            System.out.println("通过构造方法来获取对象");
            Constructor constructor=classz.getConstructor(java.lang.String.class);
            //constructor.newInstance
            Person p1=(Person) constructor.newInstance("张三");
            System.out.println(p1);    
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }


    }

}
class Person{
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(Integer age) {
        this.age = age;
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

3.反射调用普通方法（重点）

package com.wschase.reflect;

import jdk.internal.org.objectweb.asm.commons.Method;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * Author:WSChase
 * Created:2019/1/19
 */
public class TestClassConstructor {
    public static void main(String[] args) {
          try{
              Class clases=Class.forName("com.wschase.reflect.Person");

              //1.获取Person类中所有普通方法
//              Method[] methods=clases.getMethod();
//              for(Method m:methods){
//                  System.out.println(m);
//              }


              //2.获取Person类中的setName方法
              java.lang.reflect.Method setNameMethod=clases.getMethod("setName",String.class);

              //3.调用方法
              Person person= (Person) clases.newInstance();
              Object voidObject=setNameMethod.invoke(person,"霓虹");
              System.out.println("setName="+voidObject);
              System.out.println(person);
              java.lang.reflect.Method getNameMethod=clases.getMethod("getName");
              Object stringObject=getNameMethod.invoke(person);
              System.out.println("getName="+stringObject);
              System.out.println(voidObject);

          } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
              e.printStackTrace();
          }


    }

}
class Person{
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(Integer age) {
        this.age = age;
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4.获取属性

     try{
              Class clases=Class.forName("com.wschase.reflect.Student");

              //获取属性：public
              Field[] fields=clases.getFields();
              System.out.println("输出所有的公开的属性：");
              for(Field f:fields){
                  System.out.println(f);
              }

              System.out.println("输出本类所有的声明的属性");
              for(Field f:clases.getDeclaredFields()){
                  System.out.println(f);
              }

              System.out.println("获取指定属性");
              Field major=clases.getDeclaredField("major");
              System.out.println(major);

        } catch (ClassNotFoundException | NoSuchFieldException e) {
        e.printStackTrace();
        }