java 反射 超级详细-看完不会来找我

于 2021-11-26 23:18:30 发布
阅读量259 收藏 1
点赞数
分类专栏： 笔记 文章标签： java 反射 java 7 编程语言 算法
发
本文链接：https://blog.csdn.net/qq_56040798/article/details/121570498
版权 
package Demo.java3.反射;

import org.junit.jupiter.api.Test;

import java.io.Serializable;
import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.Arrays;
/*
用反射是可以体现它的动态性


/*
服务器运行起来之后不知道应该new那个类的时候就用反射，体验上动态性

反射和面向对象是否冲突了   面向对象的私有化是告诉你这个方法我已经在我的类里面实现了就不需要你在调用他了， 封装性是解决到底建议你调什么样子的东西   反射是用来解决我能不能调的问题
反射可以是常用类型 int  也可以是数组(一维数组都是相同的class)  或者本身 或者void类型  接口，注解，enum枚举类型
 */
 */
import static java.lang.annotation.ElementType.*;

/*


        int i = f.getModifiers(); //输出0,1,2,3,4这样子的        //权限修饰符
        String s = Modifier.toString(i); // 转换回普通的权限修饰符   public private

       String name = f.getName(); //返回: name,age,id     //变量名称

       Class type=f.getType(); //返回:class java.lang.String   int   int  //数据类型


 */
public class 反射的所有使用方法 {
    public static void main(String[] args) {

    }


    @Test  //创建Class的三种方法
    void abc_00() throws ClassNotFoundException {
        //方式1
        Class c1=Username.class ; //找到位置
        System.out.println(c1);
        /*
         class Demo.java3.反射.Username
         */

        //方式2
        Username use=new Username();
        Class c2=use.getClass(); //找到当前类位置
        System.out.println(c2);
        /*
        Stdio{id=1, name='张三', password='123456'}
         */


        //方式3
        Class c3 = Class.forName("class Demo.java3.反射.Username");//通过全名找到位置
        System.out.println(c3);

        //方式四(通过类的加载器)
        ClassLoader loa = Username.class.getClassLoader(); //获取此类的类加载器
        Class c4=loa.loadClass("class Demo.java3.反射.Username");
        System.out.println(c4);
    }

    @Test //获取所有属性的类型以及修饰符
    void abc_0()
    {
        Class c1=Person1.class;


        //返回所有自己声明的public和父类有的私有属性
        Field[] fields = c1.getFields();//获取所有的public属性(继承了父类还会找父类的所有属性)
        for(Field f:fields)
        {
            System.out.println(f);
            /*
            返回了所有的公有方法:
                    public int Demo.java3.反射.Person1.id
                    public double Demo.java3.反射.Creature.weight

                 返回了本类和父类的所有public属性

             */
        }

        System.out.println();
        System.out.println("返回该类:");
        //反回该类的所有属性包括private属性的
        Field[] fields1 = c1.getDeclaredFields();//返回该类的所有属性(包括private属性的) 但不包含父类的属性
        for (Field f1:fields1)
        {
            System.out.println(f1);
        }

    }
    @Test  //权限修饰符数据类型
   void abc_1()
    {
        Class clazz=Person1.class;
        Field[] fields = clazz.getDeclaredFields(); //返回该类的所有属性(包括private属性的) 但不包含父类的属性

        for(Field f:fields)
        {
            //权限修饰符
          int i = f.getModifiers(); //输出0,1,2,3,4这样子的
          System.out.print(Modifier.toString(i)+"       "); //转换回来成普通类型的  //private        public

            //数据类型
            Class type=f.getType(); //返回:class java.lang.String   int   int
            System.out.println(type); //class java.lang.String

            //变量名称
            String name = f.getName(); //返回: name,age,id     //变量名称
            System.out.println(name);//输出他的变量名
        }


    }

@Test//获取所有方法名
    void abc_2()
    {
        Class c1=Person1.class;

        //返回所在类及其父类的方法(public方法):
//        Method[] methods = c1.getMethods();//返回所在类及其父类的方法(public方法)
//        for (Method m:methods)
//        {
//            System.out.println(m);
//        }

        //返回所在类的方法
        Method[] methods1 = c1.getDeclaredMethods();//返回所在类的方法(所有权限的方法)  和类名称
        for (Method method :methods1)
        {
            System.out.println(method);
            /*
            public java.lang.String Demo.java3.反射.Person1.display(java.lang.String)
            private java.lang.String Demo.java3.反射.Person1.show(java.lang.String)
            public int Demo.java3.反射.Person1.compareTo(java.lang.String)
            public int Demo.java3.反射.Person1.compareTo(java.lang.Object)
            public void Demo.java3.反射.Person1.info()

             */

        }


    }

    @Test  // @ 注解 权限修饰符  方法名(参数类型1,形参名1)  返回值类型
    void abc_3()
    {
        Class c1=Person1.class;
        Method[] methods = c1.getDeclaredMethods();//返回所在类的方法(所有权限的方法)

        //获取注解
        for(Method m1:methods)
        {
            //获取方法声明的注解
            Annotation[] annotations = m1.getAnnotations();  //可能会有多个注解所以用数组
            for (Annotation a1:annotations)
            {
                System.out.println("获取到的注解:"+a1);//获取注解的值
                /*
                @Demo.java3.反射.MyAnnotation(value="hello")
                 */
            }

        //获取所有的方法的(public private)权限修饰符加+返回值类型+方法名+形参
        //    private  void breath()    private 权限修饰符   void 返回值类型  breath  方法名
            System.out.println("权限修饰符"+Modifier.toString (m1.getModifiers())+"            "
                              +"返回值类型:"+m1.getReturnType().getName()+"      "
                              +"方法名:"+m1.getName()//方法名
                              );//获取所有的方法的(public private)等权限修饰符  加返回值类型 方法名
            //形参列表
            System.out.print("(");

            Class[] types = m1.getParameterTypes(); //获取里面的所有返回值
            if(types!=null&&types.length!=0)  //不为空或者length不为0
            {
                for (Class c:types)
                {

                    System.out.print("形参:"+c.getName()); //获取他的形参  (形参:java.lang.Object)
                }
            }
            System.out.print(")");





            /* 返回:
            权限修饰符public            返回值类型:int      方法名:compareTo  (形参:java.lang.String)
            权限修饰符public volatile            返回值类型:int      方法名:compareTo  (形参:java.lang.Object)
            权限修饰符public            返回值类型:void      方法名:info  ()
            获取到的注解:@Demo.java3.反射.MyAnnotation(value="hello")
            权限修饰符private            返回值类型:java.lang.String      方法名:show (形参:java.lang.String)
            权限修饰符public            返回值类型:java.lang.String      方法名:display (形参:java.lang.String)
             */

            //抛出的异常
            Class[] ex= m1.getExceptionTypes(); //获取抛出的异常
            if(ex!=null&&ex.length!=0) //如果为0或者为空就是啥也没有
            {
              for(int i=0;i<ex.length;i++)

                    System.out.print(" "+"抛出的异常:"+ex[i].getName());//抛出异常
        /*
        (形参:java.lang.String) 抛出的异常:java.lang.Exception
         */
                }


            System.out.println();//换行一下
        }//循环结束

    }

    @Test  //构造器(公有和所有的权限修饰符构造器)
    void abc_4()
    {
        Class c1=Person1.class;
        Constructor[] cs=c1.getConstructors(); //获取当前运行时类中声明为public的构造器
        System.out.println("声明为public的构造器:");
        for(Constructor c:cs)
        {
            System.out.println(c); //获取构造器
        }

        System.out.println();//换行

        Constructor[] cs1=c1.getDeclaredConstructors(); //获取当前运行时类中所有权限修饰符的构造器
        System.out.println("所有权限修饰符的构造器:");
        for(Constructor c:cs1)
        {
            System.out.println(c); //获取构造器
        }

        /*
public Demo.java3.反射.Person1()

所有权限修饰符的构造器:
private Demo.java3.反射.Person1(java.lang.String,int)
private Demo.java3.反射.Person1(java.lang.String)
public Demo.java3.反射.Person1()
         */

    }

    @Test  //获取运行时的父类
    void abc_5()
    {
        //获取运行时不带泛型的父类
        Class c1=Person1.class;
        Class aClass = c1.getSuperclass(); //获取运行时的父类
        System.out.println("不带泛型的父类:"+aClass);

        //获取运行时带泛型的父类   (会用到)
        Type type = c1.getGenericSuperclass();//获取运行时带泛型的父类
        System.out.println("获取时带泛型的父类:"+type);


        //获取运行时代泛型的父类的泛型
        Type type1 = c1.getGenericSuperclass();//获取运行时带泛型的父类
        ParameterizedType theorized= (ParameterizedType) type1;  //获取运行时代泛型的父类的泛型
        Type[] Actual = theorized.getActualTypeArguments();//父类可能会有多个泛型所以是数组类型的
        System.out.print("运行时代泛型的父类的泛型:");
        for(Type t1:Actual)
        {
            System.out.print(t1+"   ");
        }

        /*
         不带泛型的父类:class Demo.java3.反射.Creature
         获取时带泛型的父类:Demo.java3.反射.Creature<java.lang.String>
         运行时代泛型的父类的泛型:class java.lang.String
         */


    }

    @Test  //获取运行时类的接口  (会用到)
    void abc_6()
    {
        Class cs=Person1.class;

        //获取运行时类的接口
        Class[] interfaces = cs.getInterfaces(); //获取运行时类的接口
        for (Class c1:interfaces)
        {
            System.out.println(c1);
        }

        /*
        interface java.lang.Comparable
        interface Demo.java3.反射.MyInterface
         */

        System.out.println();//换行

        //获取运行时类的父类的接口
        Class[] interfaces1 = cs.getSuperclass().getInterfaces();//获取运行时类的父类的接口
        for (Class c1:interfaces1)
        {
            System.out.println(c1);
        }

        /*
        interface java.io.Serializable
         */



    }

    @Test  //获取运行时类所在的包位置
    void abc_7()
    {
        Class cs=Person1.class;
        Package aPackage = cs.getPackage();//获取运行时类所在的包位置
        System.out.println("运行时所在的包位置:"+aPackage);

        /*
        运行时所在的包位置:package Demo.java3.反射
         */

    }

    @Test  //获取运行时类的注解
    void abc_8()
    {
        Class cs=Person1.class;

        //获取运行时类的注解
        Annotation[] annotations = cs.getAnnotations();//获取运行时类的注解
        for(Annotation an:annotations)
        {
            System.out.println("运行时类的注解:"+an);
        }
        /*
     运行时类的注解:@Demo.java3.反射.  MyAnnotation(value="我是运行时类的注解")
         */

    }
    //)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    //)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

    //如何调用运行时类的属性,方法,构造器

    @Test  //获取指定的属性(因为属性一般都是用不是public类型的所有已经不使用了废弃了)
    /* 废弃*/ void abc_9() throws NoSuchFieldException, InstantiationException, IllegalAccessException {
        Class cs=Person1.class;

        Person1 obj = (Person1)cs.newInstance(); //获取指定的构造器
        //获取指定属性要求声明为public类型的
        Field ld = cs.getField("id");// 获取指定属性

        ld.set(obj,12); // 获取指定构造器的属性修改属性值(相当于复制操作)

        int pid = (int)ld.get(obj); //获取指定对象的属性值
        System.out.println(pid);  //返回 : 12



    }

    @Test  //获取指定的属性  支持私有的属性
    void abc_10() throws InstantiationException, IllegalAccessException, NoSuchFieldException {

        Class cs=Person1.class;

        Object instance = cs.newInstance(); //获取构造器
        Field name = cs.getDeclaredField("name"); //获取属性

        name.setAccessible(true); //必须得实现为true这样子才给你调用  获取设置对象的此属性值

        name.set(instance,"你好");
        System.out.println(name.get(instance)); //返回修改完成之后的值


    }

    @Test  //调用方法
    void abc_11() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class cs=Person1.class;

        Object o = cs.newInstance(); //构造器调用空参构造器

        Method show = cs.getDeclaredMethod("show", String.class); //输入该方法的名称,和参数

        show.setAccessible(true); //保证方法是可访问私有的

        Object o1 = show.invoke(o, "我是中国人"); // invok 是调用里面的方法 第一个是类构造器,第二个是参数  如果有返回值就可以接收
        System.out.println(o1);
/*
写的sout返回: 我的国籍是:我是中国人

返回值为:我是中国人
 */

        //如果方法是为静态的
        Method desc = cs.getDeclaredMethod("showDesc", String.class);//声明方法

        desc.setAccessible(true);//启动可以访问私有的

        Object o2 = desc.invoke(Person1.class, "我爱中国");//调用方法
        System.out.println(o2);//输出返回值

        /*
        调用; 调用了我
        返回值: 我爱中国
         */


    }


    @Test  //调用构造器带参数的构造器(不通用) 一般使用不带参数的因为不适合
    void abc_12() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class cs=Person1.class;
        //1.获取指定构造器
        Constructor constructor = cs.getDeclaredConstructor(String.class); //调用有参数的构造器 ,指明构造器的参数列表

        //2.保证可访问
        constructor.setAccessible(true);//保证能访问

        //3.调用此构造器创建运行时类的对象
        Person1 instance = (Person1)constructor.newInstance("我爱我的国家 传输进去构造器的值"); //调用一个参数的构造器
        System.out.println(instance.toString());

        /*
        Person1{name='我爱我的国家 传输进去构造器的值', age=0, id=0}
         */

    }


    @Test  //
    void abc_13()
    {
        Class cs=Person1.class;

    }


}










class Creature<T> implements Serializable  //父类
{
    private  char gender;
    public  double weight;


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

}


@MyAnnotation(value = "我是运行时类的注解")
class Person1 extends Creature<String> implements  Comparable<String>,MyInterface  //主类
{
//属性区
    private String name;
    int age;
    public int id;

//构造函数区
    public  Person1() {  //空参构造器
    }


    @MyAnnotation(value = "1234")
    private  Person1(String name) {  //一个参数构造器
        this.name=name;

    }


    private   Person1(String name,int age) {  //两个参数构造器
    this.name=name;
    this.age=age;
    }



    //方法区
    private String show(String nation) //1
    {
        System.out.println("我的国籍是:"+nation);
        return nation;
    }


    public String display(String interests) throws Exception  //2
    {
        return interests;
    }


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


    public int compareTo(String o) { //4
        return 0;
    }

    private static String showDesc(String name)
    {
        System.out.println("调用了我");
return name;
    }

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





interface MyInterface   //接口
{
    void info();

}


@Target({TYPE,FIELD,METHOD, PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{       //注解
    String value() default "hello";
}
游迹AI
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

游迹AI

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值