java基础之反射

一、反射的概述
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

在 Java 中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为 Java 语言的反射机制。

编译时类型和运行时类型
在 Java 程序中许多对象在运行是都会出现两种类型：编译时类型和运行时类型。 编译时的类型由声明对象时实用的类型来决定，运行时的类型由实际赋值给对象的类型决定 。如：
Person p=new Student();
其中编译时类型为 Person，运行时类型为 Student。的编译时类型无法获取具体方法程序在运行时还可能接收到外部传入的对象，该对象的编译时类型为 Object,但是程序有需要调用该对象的运行时类型的方法。为了解决这些问题，程序需要在运行时发现对象和类的真实信息。然而，如果编译时根本无法预知该对象和类属于哪些类，程序只能依靠运行时信息来发现该对象和类的真实信息，此时就必须使用到反射了
Java 反射 API
反射 API 用来生成 JVM 中的类、接口或则对象的信息。

1. Class 类：反射的核心类，可以获取类的属性，方法等信息。
2. Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性
   值。
3. Method 类： Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或
   者执行方法。
4. Constructor 类： Java.lang.reflec 包中的类，表示类的构造方法。
   . 反射使用步骤（获取 Class 对象、调用对象方法）
5. 获取想要操作的类的 Class 对象，他是反射的核心，通过 Class 对象我们可以任意调用类的方
   法。
6. 调用 Class 类中的方法，既就是反射的使用阶段。
7. 使用反射 API 来操作这些信息。

package com.reflection;

public class Person {

    public Person() {
    }

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

    public int getAge() {
        return age;
    }

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

    public static String getName() {
        return name;
    }

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

    private int age;
    private static String name;

    private void speak() {
        System.out.println("hello");
    }

    private static String Sing() {
        return "ME!";
    }

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

package com.reflection;


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

/**
 * JAVA反射：
 * <p>
 * 动态语言，是指程序在运行时可以改变其结构：新的函数可以引进，已有的函数可以被删除等结
 * 构上的变化。比如常见的 JavaScript 就是动态语言，除此之外 Ruby,Python 等也属于动态语言，
 * 而 C、C++则不属于动态语言。从反射角度说 JAVA 属于半动态语言。
 */
public class reflect {
    public static void main(String[] args) {
        getClassTest();
        getAllMethod();
        getMemberAttribute();
        getConstructorMethod();

        increatObject();
    }


    /**
     * 获取 Class 对象的 3 种方法
     */
    private static void getClassTest() {
        // 第一种：调用某个对象的 getClass()方法
        Person p = new Person();
        Class clazz1 = p.getClass();
        System.out.println(clazz1.toString());

        // 第二种：调用某个类的 class 属性来获取该类对应的 Class 对象
        Class clazz2 = Person.class;
        System.out.println(clazz2.toString());

        //第三种：使用 Class 类中的 forName()静态方法(最安全/性能最好)
        String path = "com.reflection.Person";
        try {
            Class clazz3 = Class.forName(path);
            System.out.println(clazz3.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }


    /**
     * 获取所有的方法
     */
    private static void getAllMethod() {
        Class clazz = Person.class;
        Method[] method = clazz.getDeclaredMethods();
        for (Method m : method) {
            System.out.println(m.toString());
        }
    }

    /**
     * 获取所有的成员属性
     */
    private static void getMemberAttribute() {
        Class clazz = Person.class;
        Field[] field = clazz.getDeclaredFields();
        for (Field f : field) {
            System.out.println(f.toString());
        }
    }

    /**
     * 获取 Person 类的所有构造方法信息
     */
    private static void getConstructorMethod() {
        Class clazz = Person.class;
        Constructor[] constructor = clazz.getDeclaredConstructors();
        for (Constructor c : constructor) {
            System.out.println(c.toString());
        }
    }

    /**
     * 创建对象的两种方法
     */
    private static void increatObject() {
        Class clazz = Person.class;

        //1.调用 Constructor 对象的 newInstance()
        //使用 Class 对象的 newInstance()方法来创建该 Class 对象对应类的实例，但是这种方法要求
        //该 Class 对象对应的类有默认的空构造器。
        try {
            Constructor c = clazz.getDeclaredConstructor(int.class);
            Person p1 = (Person) c.newInstance(20);
            System.out.println(p1.getAge());
            System.out.println(p1);
        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
            e.printStackTrace();
        }


        //2.先使用 Class 对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance()
        //方法来创建 Class 对象对应类的实例,通过这种方法可以选定构造方法创建实例。
        //获取 Person 类的 Class 对象
        //使用.newInstane 方法创建对象
        try {
            Person p = (Person) clazz.newInstance();
            System.out.println(p);
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}