创建对应的运行时类的对象、获取运行时类的所有属性、方法

环境准备：
包结构：

========================
Person.java

package com.atguigu.java;

import java.io.Serializable;

public class Person extends Creature<String> implements Comparable,Serializable{
    String name;
    private int age;
    public String id;

    public Person() {
        super();
        System.out.println("Person()....");
    }

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

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

    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;
    }

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

    @MyAnnotation("atguigu")
    public static void show() throws RuntimeException{
        System.out.println("我是一个人！");
    }

    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        return 0;
    }

    private void info(){
        System.out.println("君生我未生 我生君已老");
    }

    public String getNation(String nation,int year){
        System.out.println("nation : " + nation);
        return nation + "!!";
    }
}

=======================
Creature.java

package com.atguigu.java;

public class Creature<T> {//生物
    public double weight;//体重

    public void breath(){
        System.out.println("呼吸");
    }
}

==================
MyAnnotation.java

package com.atguigu.java;

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

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "abc123";
}

==============================
测试：
创建对应的运行时类的对象（掌握）

创建对应的运行时类的对象（掌握）
package com.atguigu.java;

import java.lang.reflect.Constructor;

import org.junit.Test;

/*
 * 有了Class以后，反射的应用一：创建对应的运行时类的对象
 * 
 */
public class NewInstanceTest {

    @Test
    public void test1() throws InstantiationException, IllegalAccessException{
        Class clazz = Person.class;

        //创建Person类的对象
        /*
         * 调用newInstance():实际上就是调用了对应的运行时类的空参的构造器
         * 建议：我们在创建一个类的时候，尽量提供一个公共的无参的构造器
         *     其一，通过反射创建运行时类的对象时，要调用
         *     其二，子类对象实例化是，默认构造器的首行调用的是父类空参的构造器
         * 
         */
        Person p = (Person)clazz.newInstance();

        System.out.println(p);
    }

    /*
     * 调用对应的运行时类中指定的构造器。
     */
    @Test
    public void test2() throws Exception{
        Class clazz = Person.class;
        //1.获取指定的构造器
        Constructor cons = clazz.getDeclaredConstructor(String.class);
        //2.设置此构造器是可访问的
        //cons.setAccessible(true);
        //3.调用指定的构造器，创建对应的运行时类的对象
        Person p = (Person)cons.newInstance("HanMeimei");
        System.out.println(p);
    }
}

===============================
获取运行时类的所有属性

package com.atguigu.java;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

import org.junit.Test;

public class FieldTest {

    @Test
    public void test1() throws ClassNotFoundException{
        Class clazz = Class.forName("com.atguigu.java.Person");

        //getFields():只能获取对应的运行时类及其所有的父类中声明为public的属性
        Field[] fields = clazz.getFields();
        for(int i = 0;i < fields.length;i++){
            System.out.println(fields[i]);
        }

        System.out.println();

        //getDeclaredFields():获取对应的运行时类自己定义的（不包含父类中的）所有的属性
        Field[] declaredFields = clazz.getDeclaredFields();
        for(int i = 0;i < declaredFields.length;i++){
            System.out.println(declaredFields[i]);
        }
    }
    //权限修饰符  数据类型 变量名
    @Test
    public void test2() throws ClassNotFoundException{
        Class clazz = Class.forName("com.atguigu.java.Person");
        Field[] declaredFields = clazz.getDeclaredFields();
        for(int i = 0;i < declaredFields.length;i++){
            //1.权限修饰符的获取
            int modifier = declaredFields[i].getModifiers();
            System.out.print(Modifier.toString(modifier) + "  ");

            //2.数据类型的获取
            Class type = declaredFields[i].getType();
            System.out.print(type.getName() + "  ");

            //3.变量名的获取
            System.out.println(declaredFields[i].getName());
        }
    }
}

==================================
获取运行时类的所有方法

package com.atguigu.java;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.junit.Test;

public class MethodTest {
    @Test
    public void test1() throws ClassNotFoundException {
        Class clazz = Class.forName("com.atguigu.java.Person");

        // getMethods():只能获取对应的运行时类及其所有的父类中声明为public的方法
        Method[] methods = clazz.getMethods();
        for (int i = 0; i < methods.length; i++) {
            System.out.println(methods[i]);
        }

        System.out.println();

        // getDeclaredMethods():获取对应的运行时类自己定义的（不包含父类中的）所有的
        Method[] methods1 = clazz.getDeclaredMethods();
        for (int i = 0; i < methods1.length; i++) {
            System.out.println(methods1[i]);
        }
    }

    // 注解
    // 权限修饰符 返回值类型 方法名 (形参列表) throws 异常类型
    @Test
    public void test2() throws ClassNotFoundException {
        Class clazz = Class.forName("com.atguigu.java.Person");
        Method[] methods1 = clazz.getDeclaredMethods();

        for (int i = 0; i < methods1.length; i++) {
            //0.注解
            Annotation[] anns = methods1[i].getAnnotations();
            //遍历
            for(int j = 0;j < anns.length;j++){
                System.out.println(anns[j]);
            }

            // 1.获取权限修饰符
            System.out.print(Modifier.toString(methods1[i].getModifiers()) + "  ");

            //2.获取返回值类型
            Class returnType = methods1[i].getReturnType();
            System.out.print(returnType.getName() + "  ");
            //3.方法名
            System.out.print(methods1[i].getName() + "(");

            //4.形参列表
            Class[] paramType = methods1[i].getParameterTypes();
            for(int j = 0;j < paramType.length;j++){
                if(j == paramType.length - 1){
                    System.out.print(paramType[j].getName() + " args_" + j);
                    break;
                }

                System.out.print(paramType[j].getName() + " args_" + j + ",");
            }

            System.out.print(")");
            //5.获取异常类型
            Class[] exps = methods1[i].getExceptionTypes();

            for(int j = 0;j < exps.length;j++){
                if(j == 0){
                    System.out.print("throws ");
                }
                System.out.print(exps[j].getName() + " ");
            }

            System.out.println();
        }   

    }
}