Java基础整理（二十二）

最新推荐文章于 2022-09-03 10:25:20 发布
最新推荐文章于 2022-09-03 10:25:20 发布
阅读量439 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43201722/article/details/122140708
版权

反射机制（下）

传送门：反射机制（上）

8. 反射属性Field

（1）常用方法

Student类

public class Student {

    //4个Field，分别采用了不同的访问控制权限修饰符
    private String name;
    protected int id;
    boolean sex;
    public int no;

}

注：其实一个属性就代表一个Field，即private String name是一个Field，boolean sex是一个Field

Test类

public class Test {
    public static void main(String[] args) throws Exception {

        //获取整个类
        Class studentClass = Class.forName("com.study.www.field.Student");

        String className = studentClass.getName();
        //com.study.www.field.Student
        System.out.println(className);

        String classSimpleName = studentClass.getSimpleName();
        //Student
        System.out.println(classSimpleName);

        //获取类中所有public修饰的Field
        Field[] fields = studentClass.getFields();
        System.out.println(fields.length); //1
        //取出这个Field
        Field f = fields[0];
        System.out.println(f.getName()); //no

        //获取类中所有Field
        Field[] fieldsAll = studentClass.getDeclaredFields();
        System.out.println(fieldsAll.length); //4
        for(Field field : fieldsAll){

            //获取属性的修饰符列表
            //返回的修饰符是一个数字，每个数字是修饰符的代号，多个修饰符也会有一个代号
            int i = field.getModifiers(); 
            String modifierString = Modifier.toString(i);
            //private protected     public
            System.out.println(modifierString);
            
            //获取属性的类型
            Class fieldType =field.getType();
            System.out.println(fieldType.getName());//java.lang.String int boolean int
            System.out.println(fieldType.getSimpleName()); //String int boolean int
            
            //获取属性的名字
            System.out.println(field.getName());//name id sex no
        }
    }
}
（2）反编译Field实例
public class Test {
    public static void main(String[] args) throws Exception {

        StringBuilder sb = new StringBuilder();

        Class studentClass = Class.forName("com.study.www.field.Student");
        sb.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + "{\n");
        Field[] fields = studentClass.getDeclaredFields();
        for(Field field : fields){
            String modifierString = Modifier.toString(field.getModifiers());
            sb.append("\t" + modifierString + " ");
            sb.append(field.getType().getSimpleName()+" ");
            sb.append(field.getName()+";\n");
        }
        sb.append("}");
        System.out.println(sb);

    }
}

输出结果：在这里插入图片描述

（3）通过反射机制访问对象属性

  • 在不使用反射机制之前，我们访问对象属性的方式

    public class Test {
    public static void main(String[] args) throws Exception {

        Student stu = new Student();
        stu.no = 1111;
        System.out.println(stu.no);

    }
}

  • 通过反射机制访问对象属性

    public class Test {
    public static void main(String[] args) throws Exception {

        Class studentClass = Class.forName("com.study.www.field.Student");
        //obj就是Student对象，底层调用无参构造
        Object obj = studentClass.newInstance();

        //获取属性no
        Field noField = studentClass.getDeclaredField("no");
        //给obj对象(Student对象)的属性no赋值，赋值1111
        noField.set(obj,1111);
        //获取obj对象的属性no的值
        System.out.println(noField.get(obj));
        
    }
}

    如果是私有属性怎么办？通过反射机制可以访问到吗？

    可以，需要调用setAccessible(true)方法

    public class Test {
    public static void main(String[] args) throws Exception {

        Class studentClass = Class.forName("com.study.www.field.Student");
        //obj就是Student对象，底层调用无参构造
        Object obj = studentClass.newInstance();

        //获取属性name
        Field nameField = studentClass.getDeclaredField("name");
        //打破封装，在外部也可以访问私有属性，不安全
        nameField.setAccessible(true);
        nameField.set(obj,"lisi");
        System.out.println(nameField.get(obj));

    }
}

9. 反射方法Method

（1）常用方法
public class Test {
    public static void main(String[] args) throws Exception {

        //获取类
        Class userServiceClass = Class.forName("com.study.www.field.UserService");

        //获取所有的Method(包括私有的)
        Method[] methods = userServiceClass.getDeclaredMethods();
        System.out.println(methods.length);//2
        for(Method method : methods){
            //获取修饰符列表
            System.out.println(Modifier.toString(method.getModifiers())); //public
            //获取方法的返回类型
            System.out.println(method.getReturnType().getSimpleName());//void boolean
            //获取方法的名字
            System.out.println(method.getName());//logout login
            //方法的参数修饰符列表（一个方法可能有多个参数）
            Class[] parameterTypes= method.getParameterTypes();
            for(Class parameterType : parameterTypes){
                System.out.println(parameterType.getSimpleName()); //String String
            }
        }
    }
}
（2）反编译Method
public class Test {
    public static void main(String[] args) throws Exception {

        StringBuilder sb = new StringBuilder();
        Class userService = Class.forName("com.study.www.field.UserService");
        sb.append(Modifier.toString(userService.getModifiers())+" class "+userService.getSimpleName()+" {\n");

        Method[] methods = userService.getDeclaredMethods();
        for(Method method : methods){
            sb.append("\t"+Modifier.toString(method.getModifiers())+" ");
            sb.append(method.getReturnType().getSimpleName()+" ");
            sb.append(method.getName()+"(");
            Class[] parameterMethod = method.getParameterTypes();
            for(Class parameterClass : parameterMethod){
                sb.append(parameterClass.getSimpleName()+", ");
            }
            //删除末尾多余的符号
            if(", ".equals(sb.substring(sb.length()-2,sb.length()))){
                sb.delete(sb.length()-2,sb.length());
            }
            sb.append("){}\n");
        }
        sb.append("}");
        System.out.println(sb);
    }
}

输出结果：在这里插入图片描述

（3）通过反射机制调用方法

  • 不采用反射机制时

    public class Test {
    public static void main(String[] args) throws Exception {

        UserService userService = new UserService();
        System.out.println(userService.login("admin","123"));
        userService.logout();

    }
}

  • 采用反射机制时

    public class Test {
    public static void main(String[] args) throws Exception {

        Class userServiceClass = Class.forName("com.study.www.field.UserService");
        Object obj = userServiceClass.newInstance();

        //获取Method
        //参数列表：方法的名字，两个方法参数的Class（如果int直接int.class 参数类型.class）
        Method loginMethod = userServiceClass.getMethod("login",String.class,String.class);
        //loginMethod是获取的方法，obj是创建的对象
        //"admin","123"是传进方法的两个实参
        //retValue是方法的返回值
        Object retValue = loginMethod.invoke(obj,"admin","123");
        System.out.println(retValue); //true

    }
}

  • 总结

    反射机制，让代码具有通用性，可变化的内容都是写到配置文件当中，将来修改配置文件之后，创建的对象就不一样了，调用的方法也不同了，但是Java代码不需要任何的改动

10. 反射构造器Constructor

Student类

public class Student {
    
    private String name;
    private int id;
    private int no;

    public Student() {
    }

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

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public Student(String name, int id, int no) {
        this.name = name;
        this.id = id;
        this.no = no;
    }
}
（1）反编译Constructor
public class Test {
    public static void main(String[] args) throws Exception {

        StringBuilder sb = new StringBuilder();
        Class studentClass = Class.forName("com.study.www.field.Student");
        sb.append(Modifier.toString(studentClass.getModifiers())+ " class "+studentClass.getSimpleName()+"{\n");

        Constructor[] constructors = studentClass.getDeclaredConstructors();
        for(Constructor constructor : constructors){
            //构造器没有返回类型，且命名都和类一样
            sb.append("\t" + Modifier.toString(constructor.getModifiers())+ " "+ studentClass.getSimpleName()+"(");
            Class[] parameterTypes = constructor.getParameterTypes();
            for(Class c : parameterTypes){
                sb.append(c.getSimpleName()+",");
            }
            if(parameterTypes.length>0)
                sb.deleteCharAt(sb.length()-1);
            sb.append("){}\n");
        }
        sb.append("}");
        System.out.println(sb);

    }
}

运行结果：在这里插入图片描述

（2）通过反射机制调用构造器

  • 不使用反射机制

    public class Test {
    public static void main(String[] args) throws Exception {

        //不使用反射机制调用构造器创建对象
        Student student = new Student();
        Student student1 = new Student("lisi",111);
        Student student2 = new Student("zhangsan",222,2);
    }
}

  • 使用反射机制

    public class Test {
    public static void main(String[] args) throws Exception {

        //不使用反射机制调用构造器创建对象
        Student student = new Student();
        Student student1 = new Student("lisi",111);
        Student student2 = new Student("zhangsan",222,2);


        Class studentClass = Class.forName("com.study.www.field.Student");

        //调用无参数构造方法
        Object obj = studentClass.newInstance();
        System.out.println(obj);

        //调用无参数构造方法的第二种方式
        Constructor c1 = studentClass.getDeclaredConstructor();
        Object obj1 = c1.newInstance();
        System.out.println(obj1);


        //调用有参数的构造方法
        //先获取这个有参数的构造方法
        Constructor c = studentClass.getDeclaredConstructor(String.class,int.class,int.class);
        //调用构造方法new对象
        Object obj2 = c.newInstance("wangwu",333,3);

        System.out.println(obj2);
    }
}

    运行结果：在这里插入图片描述

11. 获取父类以及实现的接口

  • 获取一个类的父类：getSuperclass()

    public class Test {
    public static void main(String[] args) throws Exception {

        Class stringClass = Class.forName("java.lang.String");

        //获取String父类
        Class superClass = stringClass.getSuperclass();
        //java.lang.Object
        System.out.println(superClass.getName());

    }
}

  • 获取一个类实现的接口：getInterfaces()

    由于一个类可以实现多个接口，所以一定返回的是一个数组

    public class Test {
    public static void main(String[] args) throws Exception {

        Class stringClass = Class.forName("java.lang.String");

        //获取String类实现的接口
        Class[] interfaces = stringClass.getInterfaces();
        for(Class c : interfaces){
            System.out.println(c.getName());
        }
        //java.io.Serializable
		//java.lang.Comparable
		//java.lang.CharSequence

    }
}
李同学向前冲
关注
专栏目录
Java面向对象(二):类Class
qq_42865964的博客
10-31 699
类Class
java基础(4)public class 和class的区别及注意事项
见贤思齐焉，见不贤内自省
11-28 4532
java基础(4)public class 和class的区别及注意事项
JAVA中的public class与class的区别详解
热门推荐
知行合一
03-28 2万+
1.类的访问权限 1.为了控制某个类的访问权限，修饰词必须出现在关键字class之前。例如：public class Animal {} 2.在编写类的时候可以使用两种方式定义类： （1）public class定义类 public class Animal{ ... } （2）class定义类 class Animal{ } 2.public class定义类 1. 如果一个类声明的时候使...
JavaSE基本语法~
m0_64365419的博客
09-03 4096
Java程序代码必须放在一个类中，刚开始学习时，我们可以将类看作一个Java程序。类使用关键字class定义，在class前面可以有类的修饰符。类的定义格式如下：1：Java程序代码可分为执行定义语句和功能执行语句，其中，结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能，每条功能执行语句的最后必须用分号结束（;）。举例：需要注意的是，在程序中，不要将英文的分号写成中文的分号。否则编译器会出现如下所示的错误：2：，在定义类时，不能将class写成Class，否则编译器会出现如下错误：假设在程序
Java中的泛型类，泛型方法，泛型接口
feicongcong的博客
05-10 878
泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展 1.泛型接口，接口持有泛型，类名<T> public interface TestApi<T> { T method1(T a); } 1.泛型类，类持有泛型，类名<T> public class ResultDto<T> {...
java基础笔记整理java基础笔记整理.pdf
07-15
java基础笔记整理java基础笔记整理
java基础整理笔记超详细
07-17
【Java基础整理笔记超详细】 Java是一门广泛使用的高级编程语言，由Sun Microsystems（后被Oracle收购）在1995年推出。它的设计目标是跨平台、面向对象，并且具有健壮性和安全性。Java这个名字源于印度尼西亚的咖啡...
2024版Java基础知识总结（超详细整理）
最新发布
09-24
2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识...
java基础单词整理
10-02
java单词入门整理,包括java基础,前端基础,web以及框架,适用于初学者.
java基础整理
03-21
自己整理的一些java的知识点。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Test.javaclass Student { private String id;//表示学号 private String name;//表示姓名 pri
12-24
Java考试成绩显示class Student { private String id;//表示学号 private String name;//表示姓名 private char sex;//表示性别 private int age;//表示
Java进阶——反射机制
LiLi的博客
12-05 495
反射机制（比较简单，因为只要会查帮助文档，就可以了） 反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件。 优点类似于黑客。（可以读和修改字节码文件） 通过反射机制可以操作代码片段。（class文件） 反射机制的相关类在哪个包下？ java.lang.reflect.*; 反射机制相关的重要的类有哪些？ java.lang.Class：代表整个字节码，代表一个类型，代表整个类。 java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。
Java语言：public class和class的区别
m0_65909265的博客
08-05 1726
Java语言：public class和class的区别
java中关于public class
sun_abc的专栏
09-03 6918
1，一个java程序中至多只能有一个public类，也可以没有任何public类；2，一个java程序中有几个class就会被编译成几个class文件。3，main方法可以在任意一个类中（main只是一个程序入口）
private关键字的使用——学生案列
weixin_44768683的博客
03-19 249
package it.lym; public class Student { private String name; private int age; public void setName(String n){ name=n; } public String getName(){ return name; } public void setAge(int a){ if(a<=0 || a&g
java面向对象(学生练习)
qq_44739966的博客
03-02 765
创建一个学生类（姓名、年龄、性别） ​ 创建5个学生对象 ​ 将5个学生对象存放到学生数组 ​ 设计一个方法，从键盘随机录入学生姓名，查找对应学生是否存在 ​ 设计一个方法，按照学生年龄从大到小，对数组中所有学生进行排序 ​ 设计一个方法，根据性别，统计男生和女生人数 public class Student { private String name; private int age; private String sex; public Student() { super(); } pu
Java --- > 基础学习Ⅱ
栗子好好吃的博客
04-03 389
继承 继承概述 下面有一个学生类 public class Student{ private String name; private int age; public void study(){ System.out.println("努力学习了"); } public String getName() { ...
java面向对象作业3
xxxlllOmO的博客
09-23 873
题目3: 设计，并定义一个学员类：Student，要求有以下属性： 学员编号（String） 姓名（String） 性别（String） 身高（double） 年龄（int） 使用封装的原则，并提供无参和全参的构造方法。 1 定义MainApp类，并包含main()方法。 2 在main方法，运行程序，应分别提示用户输入学员编号、姓名等信息。 【提示：键盘输入字符串。String s = sc.next();】 例如控制台显示： 请输入学员编号： xxx 请输入学员姓名： xxx 数据接收到
[Java] public class, main和args的解释
Stephen Wong的专栏
03-12 6488
大家可以下载《Java编程思想》第四版，参考2.7小节“你的第一个Java程序”。里面介绍了public class, main的含义。 文件名与类名 我们如果需要创建一个独立运行的程序，那么文件中必须存在某个类与该文件同名（否则编译器会报错），而且那个类必须包含一个名为main()的方法。 所以在HelloWorld.java文件中，我们必须存在如下类定义： // Hello
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值