java基础--反射机制

例子1

Person

package com.atguigu.java3;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 20:06
 */
public class Person {

    private String name;
    public int age;

    public Person() {
    }

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

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

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

    public void show(){
        System.out.println("你好，我是一个人");
    }

    private String showNation(String nation){
        System.out.println("我的国籍是："+nation);
        return  nation;
    }

}

ReflectionTest

package com.atguigu.java3;

import org.junit.Test;

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

/**
 * @author shkstart
 * @create 2021-12-{DAY} 20:05
 */
public class ReflectionTest {

    //反射之前，对于Person的操作
    @Test
    public void test1(){
        //1.创建Person类的对象
        Person p1 = new Person("Tom", 12);

        //2.通过对象，调用其内部的属性，方法
        p1.age=10;
        System.out.println(p1.toString());

        p1.show();

        //在Person类外部，不可以通过Person类的对象调用其内部私有结构
        //比如，name,showNation()以及私有的构造器
    }

    //反射之后，对于Person的操作
    @Test
    public void test2() throws Exception{
        //1.通过反射，创建Person类的对象
        Class clazz = Person.class;
        Constructor cons = clazz.getConstructor(String.class,int.class);

        Object obj = cons.newInstance("Tom", 12);
        Person p = (Person) obj;
        System.out.println(p.toString());

        //2.通过反射，调用对象指定的属性，方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p.toString());

        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        System.out.println("**********");

        //通过反射，可以调用Person类的私有结构的，比如：私有的构造器，方法，属性
        //调用私有的构造器
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person) cons1.newInstance("Jerry");
        System.out.println(p1);

        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"HanMeimei");
        System.out.println(p1);

        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        showNation.invoke(p1,"中国"); //相当于p1.showNation("中国")


    }


}

例子2

package com.atguigu.java3;

import org.junit.Test;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 20:05
 */
public class ReflectionTest {

    //反射之前，对于Person的操作
    @Test
    public void test1(){
        //1.创建Person类的对象
        Person p1 = new Person("Tom", 12);

        //2.通过对象，调用其内部的属性，方法
        p1.age=10;
        System.out.println(p1.toString());

        p1.show();

        //在Person类外部，不可以通过Person类的对象调用其内部私有结构
        //比如，name,showNation()以及私有的构造器
    }

    //反射之后，对于Person的操作
    @Test
    public void test2() throws Exception {
        //方式1：
        Class clazz1 = Person.class;
        System.out.println(clazz1);
        //方式2:通过运行时类的对象，调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);

        //方式3：调用Class的静态方法，forName(String classPath)
        Class clazz3 = Class.forName("com.atguigu.java3.Person");
        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2);
        System.out.println(clazz1 == clazz3);

        //方式4：使用类的加载器：ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("com.atguigu.java3.Person");
        System.out.println(clazz4);

    }



}

例子3

package com.atguigu.java3;

import org.junit.Test;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 9:51
 */
public class ClassLoaderTest {

    @Test
    public void test1(){
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);
        //调用系统类加载器getParent(),获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);
        //调用扩展类加载器的getParent()，无法获取引导类加载器
        //引导类加载器主要负责加载java核心类库，无法加载自定义类的
        ClassLoader classLo2 = classLoader1.getParent();
        System.out.println(classLo2);

        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);

    }

}

例子4

ClassLoaderTest

package com.atguigu.java3;

import org.junit.Test;

import java.io.FileInputStream;
import java.util.Properties;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 9:51
 */
public class ClassLoaderTest {

    @Test
    public void test2() throws Exception{
        Properties pros = new Properties();

        //此时的文件默认在当前module下
//        FileInputStream fis = new FileInputStream("jdbc.properties");
        FileInputStream fis = new FileInputStream("src\\jdbc.properties");
        pros.load(fis);

        //读取配置文件的方式2：使用ClassLoader
        //配置文件默认识别为：当前module的src下
//        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
//        InputStream is = classLoader.getResourceAsStream("jdbc.properties");
//
//        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");

        System.out.println(user);
        System.out.println(password);

    }

}

jdbc.properties

user=wsf王少锋
password=abc123

例子5

package com.atguigu.java3;

import org.junit.Test;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 10:18
 */
public class NewInstanceTest {

    @Test
    public void test1() throws Exception{
        /*
        * newInstance()：调用此方法，创建对应的运行时类的对象
        * 内部调用了运行时类的空参的构造器
        *
        * 要想此方法正常的创建运行时类的对象，要求：
        * 1.运行时类必须提供空参的构造器
        * 2.空参的构造器的访问权限得够，通常，设置为public
        *
        * */
        Class clazz = Person.class;
        Object obj = clazz.newInstance();
        System.out.println(obj);
    }

}

例子6

package com.atguigu.java3;

import org.junit.Test;

import java.util.Random;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 10:18
 */
public class NewInstanceTest {

    @Test
    public void test2(){
        int num = new Random().nextInt(3);

        String classPath1 = "";
        switch (num){
            case 0:
                classPath1 = "java.util.Date";
                break;
            case 1:
                classPath1 = "java.sql.Date";
                break;
            case 2:
                classPath1 = "com.atguigu.java3.Person";
                break;
        }

        try {
            Object obj = getInstance(classPath1);
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

    /*
    * 创建一个指定类的对象
    * classPath:指定类的全类名
    * */
    public Object getInstance(String classPath) throws Exception{
        Class clazz = Class.forName(classPath);
        return clazz.newInstance();
    }


}

例子7

Creature

package com.atguigu.java;

import java.io.Serializable;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 10:53
 */
public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }

    public void eat(){
        System.out.println("生物吃东西");
    }

}

MyAnnotation

package com.atguigu.java;

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

import static java.lang.annotation.ElementType.*;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 11:04
 */

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value() default "hello";

}

MyInterface

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 10:57
 */
public interface MyInterface {
    void info();
}

Person

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 10:48
 */
@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;

    public Person() {
    }

    @MyAnnotation(value = "abc")
    private Person(String name) {
        this.name = name;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是："+nation);
        return  nation;
    }

    public String display(String interests){
        return interests;
    }


    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }
}

获取类的属性，权限修饰符，变量名…

package com.atguigu.java2;

import com.atguigu.java.Person;
import org.junit.Test;

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

/**
 *
 * 获取当前运行时类的属性结构
 * @author shkstart
 * @create 2021-12-{DAY} 11:13
 */
public class FieldTest {

    @Test
    public void test1(){
        Class clazz = Person.class;

        //获取属性结构
        //getFields()：获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for(Field f : fields){
            System.out.println(f);
        }

        System.out.println("**************************");

        //getDeclaredFields()：获取当前运行时类中声明的所有属性（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f);
        }
    }

    //权限修饰符 数据类型 变量名....
    @Test
    public void test2(){
        Class clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            //1.权限修饰符
            int modifiers = f.getModifiers();
            System.out.println(Modifier.toString(modifiers));

            //2.数据类型
            Class type = f.getType();
            System.out.println(type.getName());

            //3.变量名
            String fName = f.getName();
            System.out.println(fName);

            System.out.println("*********");
        }


    }

}

获取子类中的所有方法和其注解，形参列表

package com.atguigu.java2;

import com.atguigu.java.Person;
import org.junit.Test;

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

/**
 * @author shkstart
 * @create 2021-12-{DAY} 12:27
 */
public class MethodTest {

    //获取对应的方法
    @Test
    public void test1(){
        Class clazz = Person.class;


        //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method m:methods){
            System.out.println(m);
        }
        System.out.println();
        //getDeclaredMethods():获取当前运行时类中声明所有方法，（不包含父类中声明的所有方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m:declaredMethods){
            System.out.println(m);
        }
    }

    //获取对应的构造器,注解
    //权限修饰符 返回值类型 方法名(参数类型1 形参名1,...){}
    @Test
    public void test2(){
        Class clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m: declaredMethods){
            //1.获取方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for(Annotation a:annos){
                System.out.println(a);
            }

            //2.权限修饰符
            System.out.println(Modifier.toString(m.getModifiers())+"\t");

            //3.返回值类型
            System.out.println(m.getReturnType().getName()+"\t");

            //4.方法名
            System.out.println(m.getName()+"\t");

            //5.形参列表
            Class[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length==0)){
                for(int i=0; i<parameterTypes.length; i++){
                    System.out.println(parameterTypes[i].getName()+" args_ "+i);
                }
            }

            //6.抛出的异常
            Class[] exceptionTypes = m.getExceptionTypes();
            if(!(exceptionTypes==null && exceptionTypes.length==0)){
                System.out.println("throws ");
                for(int i=0; i<exceptionTypes.length; i++){
                    System.out.println(exceptionTypes[i].getName()+",");
                }
            }

        }



    }




}

获取子类中的所有构造器，获取运行时的父类，获取运行时带泛型的父类，获取运行时类的带泛型的父类的泛型，获取运行时类的接口，获取运行时类声明的注解

package com.atguigu.java2;

import com.atguigu.java.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 13:07
 */
public class OtherTest {

    /**
     * 获取构造器结构
     */
    @Test
    public void test1(){
        Class clazz = Person.class;
        //getConstructors()：获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c:constructors){
            System.out.println(c);
        }
        System.out.println();

        //getDeclaredConstructors:获取当前运行时类中声明的所有的构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c:declaredConstructors){
            System.out.println(c);
        }
    }

    //获取运行时的父类
    @Test
    public void test2(){
        Class clazz = Person.class;

        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }

    //获取运行时带泛型的父类
    @Test
    public void test3(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }

    //获取运行时类的带泛型的父类的泛型
    @Test
    public void test4(){
        Class clazz = Person.class;

        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        System.out.println(actualTypeArguments[0].getTypeName());
    }

    //获取运行时类实现的接口
    @Test
    public void test5(){
        Class clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for(Class c: interfaces){
            System.out.println(c);
        }
        System.out.println();
        //获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class c:interfaces1){
            System.out.println(c);
        }

    }

    //获取运行时类所在的包
    @Test
    public void test6(){
        Class clazz = Person.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);

    }

    //获取运行时类声明的注解
    @Test
    public void test7(){
        Class clazz = Person.class;

        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation annos:annotations){
            System.out.println(annos);
        }

    }

}

例子8

package com.atguigu.java2;

import com.atguigu.java.Person;
import org.junit.Test;

import java.lang.reflect.Field;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 13:43
 */
public class ReflectionTest {

    @Test
    public void testField() throws Exception{
        Class clazz = Person.class;
        //获取运行时类的对象
        Person p = (Person) clazz.newInstance();
        //获取指定的属性：要求运行时类中属性声明为public
        Field id = clazz.getField("id");

        //设置当前属性的值
        /*
        * set():参数1，指明设置那个对象的属性 参数2：将此属性值设置为多少
        * */
        id.set(p,1001);

        /*
        * 获取当前属性的值
        * get()：参数1，获取那个对象的当前属性值
        * */
        int PId = (int) id.get(p);
        System.out.println(PId);

    }

    @Test
    public void testField1() throws Exception{

        Class clazz = Person.class;
        //获取运行时类的对象
        Person p = (Person) clazz.newInstance();
        //1.getDeclaredField(String fieldName)：获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");
        //2.保证当前属性是可访问的
        name.setAccessible(true);
        name.set(p,"Tom");

        System.out.println(name.get(p));






    }


}

例子9

package com.atguigu.java2;

import com.atguigu.java.Person;
import org.junit.Test;

import java.lang.reflect.Method;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 13:43
 */
public class ReflectionTest {

    @Test
    public void testMethod() throws Exception{
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person)clazz.newInstance();

        //1.获取指定的某个方法
        /*
        * getDeclaredMethod():参数1，指明获取的方法的名称 参数2：指明获取的方法的形参列表
        *
        * */
        Method show = clazz.getDeclaredMethod("show", String.class);

        show.setAccessible(true);

        /*
        * invoke():参数1：方法的调用者 参数2:给方法形参赋值的实参
        * invoke()的返回值即为对应的类中调用的方法的返回值
        * */

        Object returnValue = show.invoke(p, "CHN");
        System.out.println(returnValue);

        System.out.println("***************如何调用静态方法************");
        //private static void showDesc()

        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中没有返回值，则此invoke()返回null
        Object returnVal = showDesc.invoke(Person.class);
        System.out.println(returnVal);


    }


}

例子10

package com.atguigu.java2;

import com.atguigu.java.Person;
import org.junit.Test;

import java.lang.reflect.Constructor;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 13:43
 */
public class ReflectionTest {

    //调用运行时类中指定的构造器
    @Test
    public void testConstructor() throws Exception{
        Class clazz = Person.class;

        //1.获取指定的构造器
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        //2.保证此构造器是可访问的
        constructor.setAccessible(true);

        //3.调用此构造器创建运行时类的对象
        Person per = (Person) constructor.newInstance("Tom");
        System.out.println(per);
    }


}