Java学习第十章(四)

已于 2022-04-14 15:13:14 修改
阅读量1.7k 收藏 5
点赞数
分类专栏： JAVA学习(进阶班) 文章标签： java 开发语言 学习
于 2022-04-06 21:17:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49883619/article/details/123981760
版权

视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=1

视频范围P823 - P833

目录描述

1.获取反射属性Field

学生类：

package bean;

public class Student {
    //Field翻译为字段，其实就是属性/成员
    //5个Field，分别采用了不同的访问控制权限修饰符
    public int no;//Field对象
    private String name;//Field对象
    protected int age;
    boolean sex;
    public static final double MATH_PI = 3.1415926;
}

测试类：

package Reflect;

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

public class ReflectTest05 {
    public static void main(String[] args) throws Exception{
        //获取整个类
        Class studentClass = Class.forName("bean.Student");

        //获取完整类名
        String className = studentClass.getName();
        System.out.println("完整类名：" + className);

        //获取简单类名
        String simpleName = studentClass.getSimpleName();
        System.out.println("简类名：" + simpleName);

        //获取类中所有的public修饰的Field
        Field[] fields = studentClass.getFields();
        System.out.println(fields.length);//测试数组中只有2个元素
        //取出这个Field
        Field f = fields[0];
        //取出这个Field的名字
        String fieldName = f.getName();
        System.out.println(fieldName);//输出为：no

        //获取所有的Field
        Field[] fs = studentClass.getDeclaredFields();
        System.out.println(fs.length);//输出为：5

        System.out.println("------------------------");
        for (Field field : fs){
            //获取属性的修饰符列表
            int i = field.getModifiers();//返回的修饰符是一个数字，每个数字是修饰符的代号！
            System.out.println(i);
            //可以将这个”代号“数字转换成”字符串“
            String modifierString = Modifier.toString(i);
            System.out.println(modifierString);
            
            System.out.println("- - - - - ");
            
            //获取属性的类型
            Class fieldType = field.getType();
            //String fName = fieldType.getName();
            //获取简单名字
            String fName = fieldType.getSimpleName();
            System.out.println(fName);
            
            System.out.println("- - - - - ");
            
            //获取属性的名字
            System.out.println(field.getName());
            
            System.out.println("+++++++++++++++++++++++++++");
        }
    }
}

运行结果：

在这里插入图片描述

2.反编译Field

通过反射机制，反编译一个类的属性Field

package Reflect;

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

public class ReflectTest06 {
    public static void main(String[] args) throws Exception{
        //创建这个是为了拼接字符串
        StringBuilder s = new StringBuilder();

        Class studentClass = Class.forName("bean.Student");

        //s.append("public class Student {");
        s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() +" {\n");

        Field[] fields = studentClass.getDeclaredFields();
        for (Field field : fields){
            s.append("\t");
            s.append(Modifier.toString(field.getModifiers()));
            s.append(" ");
            s.append(field.getType().getSimpleName());
            s.append(" ");
            s.append(field.getName());
            s.append(";\n");
        }
        s.append('}');
        System.out.println(s);
    }
}

运行结果：

在这里插入图片描述

3.通过反射机制访问对象属性【重要！！！】

给属性赋值set
获取属性的值get
反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的

package Reflect;

import bean.Student;

import java.lang.reflect.Field;

public class ReflectTest07 {
    public static void main(String[] args) throws Exception{
        //不使用反射机制，去访问一个对象的属性
        Student s = new Student();
        //给属性赋值
        s.no = 1111;//三要素：给s对象的no属性赋值1111
        //读属性值
        System.out.println(s.no);//两要素：获取s对象的no属性的值

        //使用反射机制，访问一个对象的属性(set get)
        Class studentClass = Class.forName("bean.Student");
        Object obj = studentClass.newInstance();//obj就是Student对象(底层调用无参数构造方法)

        //获取no属性(根据属性的名称来获取Field)
        Field noField = studentClass.getDeclaredField("no");

        //给obj对象(Student对象)的no属性赋值
        noField.set(obj,2222);//三要素：给obj对象的no属性赋值2222

        //读取属性的值
        System.out.println(noField.get(obj));//两个要素：获取obj对象的no属性的值

        //###################################################################
        //访问私有的属性
        Field nameField = studentClass.getDeclaredField("name");

        //打破封装(反射机制的缺点：打破封装，可能会给不法分子留下机会！！！)
        //这样设置完之后，在外部也是可以访问private的
        nameField.setAccessible(true);

        //给name属性赋值
        nameField.set(obj,"jackson");
        //获取name属性的值
        System.out.println(nameField.get(obj));
    }
}

4.可变长度参数

  1. 可变长度参数：int… args
  2. 语法：类型… 【注意：一定是3个点】
  3. 可变长度参数要求的参数个数是：0~N个
  4. 可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有1个
  5. 可变长度参数可以当做一个数组来看待
package Reflect;

public class ArgsTest {
    public static void main(String[] args) {
        m();
        m(10);
        m(10,20);

        //编译报错
        //m("abc");

        m2(100);
        m2(200,"abc");
        m2(200,"abc","def");
        m2(200,"abc","def","xyz");

        m3("ab","de","kk","ff");

        String[] strs = {"a","b","c"};
        //也可以传一个数组
        m3(strs);

        //直接传一个数组
        m3(new String[]{"我","是","中","国","人"});//没必要

        m3("我","是","中","国","人");
    }

    public static void m(int... args){
        System.out.println("m方法执行了！");
    }

    //必须在最后一个位置上，而且可变长度参数只能有1个
    //public static void m2(int... args2,String... args1){};
    public static void m2(int a,String... args1){};

    public static void m3(String... args){
        //args有length属性，说明args是一个数组！
        //可以将可变长度参数当做一个数组来看
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

运行结果：

在这里插入图片描述

5.反射Method

用户业务类：

package service;

public class UserService {

    /**
     * 登录方法
     * @param name  用户名
     * @param passward 密码
     * @return true表示登录成功，false表示登录失败
     */
    public boolean login(String name,String passward){
        if ("admin".equals(name) && "123".equals(passward)){
            return true;
        }
        return false;
    }

    /**
     * 退出系统的方法
     */
    public void logout(){
        System.out.println("系统已经安全退出！");
    }

}

测试类：

package Reflect;

import javax.xml.transform.Source;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ReflectTest08 {
    public static void main(String[] args) throws Exception {
        //获取类
        Class userServiceClass = Class.forName("service.UserService");
        //获取所有的Method(包括私有的！)
        Method[] methods = userServiceClass.getDeclaredMethods();
        System.out.println(methods.length);//2

        //遍历Method
        for (Method method : methods){
            //获取修饰符列表
            System.out.println(Modifier.toString(method.getModifiers()));

            //获取方法的返回值类型
            System.out.println(method.getReturnType().getSimpleName());

            //获取方法名
            System.out.println(method.getName());

            //方法的修饰符列表(一个方法的参数可能会有多个)
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parameterType : parameterTypes){
                System.out.println(parameterType.getSimpleName());
            }
        }
    }
}

运行结果：

在这里插入图片描述

6.反编译Method

package Reflect;

import service.UserService;

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

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

        StringBuilder s = new StringBuilder();
        Class UserServiceClass = Class.forName("service.UserService");
        s.append(Modifier.toString(UserServiceClass.getModifiers()) + " class " + UserServiceClass.getSimpleName() +" {\n");


        Method[] methods = UserServiceClass.getDeclaredMethods();
        for (Method method: methods){
            //public boolean login(String name,String passward){}
            s.append("\t");
            s.append(Modifier.toString(method.getModifiers()));
            s.append(" ");
            s.append(method.getReturnType().getSimpleName());
            s.append(" ");
            s.append(method.getName());
            s.append("(");
            //参数列表
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            //删除指定下标位置上的字符
            if (parameterTypes.length > 0){
                s.deleteCharAt(s.length() - 1);
            }
            s.append("){}\n");
        }
        s.append("}");
        System.out.println(s);
    }
}

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

7.反射机制调用方法【重要！！！】

Java中区分一个方法：依靠方法名和参数列表
反射机制优点：让代码很具有通用性，可变化的内容都是写到配置文件当中，将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，但是Java代码不需要做任何改动！

package Reflect;

import service.UserService;

import java.lang.reflect.Method;

public class ReflectTest10 {
    public static void main(String[] args) throws Exception{
        //不使用反射机制
        //创建对象
        UserService userService = new UserService();
        //调用方法
        /*
        要素分析：
        1.对象：userService
        2.方法名：login
        3.实参列表："admin","123"
        4.返回值：loginSuccess
         */
        boolean loginSuccess = userService.login("admin","123");
        System.out.println(loginSuccess?"登录成功" : "登录失败");//登录成功

        //使用反射机制调用一个对象的方法
        Class userServiceClass = Class.forName("service.UserService");
        //创建对象
        Object obj = userServiceClass.newInstance();
        //获取Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        //调用方法 也需要四要素
        /*
        要素分析：
        1.对象：obj
        2.方法名：loginMethod
        3.实参列表："admin","123"
        4.返回值：retValue
         */
        //反射机制中最重要的一个方法
        Object retValue = loginMethod.invoke(obj,"admin","123");
        System.out.println(retValue);//true
    }
}

8.反射Constructor

Vip类：

package bean;

public class Vip {
    int no;
    String name;
    String birth;
    boolean sex;

    public Vip() {
    }

    public Vip(int no) {
        this.no = no;
    }

    public Vip(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public Vip(int no, String name, String birth) {
        this.no = no;
        this.name = name;
        this.birth = birth;
    }

    public Vip(int no, String name, String birth, boolean sex) {
        this.no = no;
        this.name = name;
        this.birth = birth;
        this.sex = sex;
    }
}

测试类：

package Reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

public class ReflectTest11 {
    public static void main(String[] args) throws Exception{
        StringBuilder s = new StringBuilder();
        Class vipClass = Class.forName("bean.Vip");
        s.append(Modifier.toString(vipClass.getModifiers()));
        s.append(" class ");
        s.append(vipClass.getSimpleName());
        s.append("{\n");

        //拼接构造方法
        Constructor[] constructors = vipClass.getDeclaredConstructors();
        for (Constructor constructor : constructors){
            //public Vip(int no, String name, String birth, boolean sex) {}
            s.append("\t");
            s.append(Modifier.toString(constructor.getModifiers()));
            s.append(" ");
            s.append(vipClass.getSimpleName());
            s.append("(");
            //拼接参数
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            //删除最后下标位置上的字符
            if (parameterTypes.length > 0){
                s.deleteCharAt(s.length() - 1);
            }
            s.append("){}\n");

        }

        s.append("}");
        System.out.println(s);
    }
}

运行结果：

在这里插入图片描述

9.反射机制调用构造方法

Vip类：

package bean;

public class Vip {
    int no;
    String name;
    String birth;
    boolean sex;

    public Vip() {
    }

    public Vip(int no) {
        this.no = no;
    }

    public Vip(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public Vip(int no, String name, String birth) {
        this.no = no;
        this.name = name;
        this.birth = birth;
    }

    public Vip(int no, String name, String birth, boolean sex) {
        this.no = no;
        this.name = name;
        this.birth = birth;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Vip{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", birth='" + birth + '\'' +
                ", sex=" + sex +
                '}';
    }
}

测试类：

package Reflect;

import bean.Vip;

import java.lang.reflect.Constructor;

public class ReflectTest12 {
    public static void main(String[] args) throws Exception {
        //不使用反射机制创建对象
        Vip v1 = new Vip();
        Vip v2 = new Vip(110,"zhangsan","2022-04-06",true);

        //使用反射机制创建对象
        Class c = Class.forName("bean.Vip");
        //调用无参数构造方法
        Object obj = c.newInstance();
        System.out.println(obj);

        //调用有参数的构造方法
        //第一步：先获取到这个有参数的构造方法
        Constructor con = c.getDeclaredConstructor(int.class,String.class,String.class,boolean.class);
        //第二步：调用构造方法new对象
        Object newObj = con.newInstance(110,"jackson","1990-10-11",true);
        System.out.println(newObj);

        //获取无参数构造方法
        Constructor con2 = c.getDeclaredConstructor() ;
        Object newObj2 = con2.newInstance();
        System.out.println(newObj2);
    }
}

运行结果：

在这里插入图片描述

10.获取父类和父类接口

获取一个类的父类以及实现的接口

package Reflect;

public class ReflectTest13 {
    public static void main(String[] args) throws Exception{
        //String举例
        Class stringClass = Class.forName("java.lang.String");

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

        //获取String类实现的所有接口(一个类可以实现多个接口)
        Class[] interfaces = stringClass.getInterfaces();
        for (Class in :interfaces){
            System.out.println(in.getName());
        }
    }
}

运行结果：

在这里插入图片描述

计算机量子狗
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE 反射中getDeclaredFiled,getField,setAccessible之间的关系和用法
qq_43318840的博客
12-16 1572
1. 首先明确一点,getDeclaredFiled()只能取得本类独有的成员字段,getField()能取得本类独有的成员字段+父类的成员字段 但 这些都只能是public的. 所谓不可取得即是不可见,NoSuchField. 比如现在有两个类: public class Animal { public String name; protected double appetite; int age; private String habitat; ...
Class.getDeclaredField()
LIUCHANGSHUO的博客
04-16 766
在上面的示例中，我们首先获取了 `MyClass` 类的 `Class` 对象，然后使用 `getDeclaredField("name")` 方法获取了该类中名为 "name" 的字段。需要注意的是，`getDeclaredField()` 方法会查找指定名称的字段，如果该字段不存在或不可访问，则会抛出 `NoSuchFieldException` 异常。`Class.getDeclaredField()` 方法是 Java 中的反射 API 之一，在运行时用于获取指定类中的特定字段（属性）。
Java反射机制基础
qq_38596491的博客
07-08 242
反射：框架设计的灵魂 （1）反射机制：将类的各个组成部分——>封装为其它对象。 Class类对象：将字节码文件通过类加载器加载到内存中，将其中的成员变量封装为field对象，将构造方法封装为Constructor对象，将成员方法封装为Method对象（方法都放在method[]中），这些统一为Class类对象（Class class;）。 ——本质：获取Class对象后，反向获取Person对象的各种信息。 好处： 1.可以在程序的运行过程中去操作这些对象 2.可以解耦（通过降低程序的耦合性，来提
java 编程中的反射机制_java反射机制中的getDeclaredField()
weixin_36376765的博客
02-27 516
反射机制：所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。如下为getDeclaredField()的一个实例：package com.bijian.test;import java.lang.reflect.Field;import java.util.Date;public class Program {public Prog...
反射机制：getDeclaredField和getField的区别
热门推荐
在路上的羊先森
01-23 5万+
在做后台开发时实体的固定字段一般会抽取为一个父类，其他类继承该父类，例如主键字段，会放到一个父类中（IdEntity），其他类继承该类，但是我们在操作时操作的是子类，在通过子类获取父类属性是getDeclaredField和getField是不一样的，简单说 getDeclaredFiled 仅能获取类本身的属性成员（包括私有、共有、保护）  getField 仅能获取类(及其父类可以自己测试...
java学习课件 第四章
12-21
这是关于学习java基础的课件 第一章、java语言基础 第二章、java语法基础 第三章、面向对象特征 第四章、applet及其应用 第五章、图形用户界面设计 第六章、异常处理 第七章、线程 ...第十章、网络编程
Java就业培训教程第十章
01-21
第10章 Applet10.1浏览器怎样显示网页在学习Applet之前，我们先来看看浏览器是如何显示网页的。浏览器打开网页文件的过程同我们用记事本程序打开文本文件的过程是一样的，只是浏览器会对这个网
使用java理解程序逻辑第十章
05-06
java入门基础，入门宝典，新手学习必备，好东西不容错过！
java第十章答案JAVA多线程——一篇文章让你彻底征服多线程开发
03-24
java第十章答案JAVA多线程——一篇文章让你彻底征服多线程开发
java学习课件第二章
12-21
这是第2章内容 这是关于学习java基础的课件 第一章、java语言基础 第二章、java语法基础 第三章、面向对象特征 第四章、applet及其应用 第五章、图形用户界面设计 第六章、异常处理 ...第十章、网络编程
Java反射笔记
weixin_44863459的博客
09-29 596
反射概述 反射（reflection library）提供了一个非常丰富工具集，以便编写能够动态操纵Java代码的程序。它是Java组件的体系结构。使用反射功能可以使得Java可以操作任意一个类，包括类的所有属性和方法，对于任意一个对象也可以去调用内部的属性和方法，这种动态获取类和对象属性的功能被称为反射机制。 反射机制又被称为框架设计的灵魂 Class类 在Java中要想通过反射来操作一个类首先要获得这个类的.class字节码文件，而在Java.lang包下就提供了一个Class类，用于将获取到每一个
Java-反射-getDeclaredFields()方法
weixin_42584319的博客
04-18 2341
获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。：获得某个类的所有的公共（public）的字段，包括父类中的字段。
java 反射获取字段field
qq_16430873的博客
08-14 3961
java基础，反射field及父类字段
getDeclaredFields方法
qq_45877149的博客
08-04 1万+
getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。 getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
java.lang.Class.getDeclaredField()方法
sinat_32520015的博客
11-19 1万+
java.lang.Class.getDeclaredField()方法 java.lang.Class.getDeclaredField()方法用法实例教程 - 方法返回一个Field对象，它反映此Class对象所表示的类或接口的指定已声明字段。 描述 java.lang.Class.getDeclaredField()方法返回一个Field对象，它反映此Class对象所表示的类或接
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
最新发布
janeqi1987的专栏
05-28 896
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1206
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
java黑皮书第十章第4题
06-06
这题是关于Java的多线程编程。 题目描述： 编写一个Java程序，该程序创建两个线程。一个线程输出奇数，另一个线程输出偶数，要求两个线程交替输出。 实现思路： 可以使用两个线程分别输出奇数和偶数，使用一个变量控制输出的数字的奇偶性。具体实现如下： ```java public class OddEvenPrinter { private static volatile int count = 1; // 初始值为奇数 private static final Object lock = new Object(); // 用于同步的锁对象 public static void main(String[] args) { Thread oddThread = new Thread(new OddPrinter()); Thread evenThread = new Thread(new EvenPrinter()); oddThread.start(); evenThread.start(); } static class OddPrinter implements Runnable { public void run() { while (count <= 100) { synchronized (lock) { if (count % 2 == 1) { System.out.println("奇数：" + count); count++; lock.notify(); // 唤醒等待的线程 } else { try { lock.wait(); // 等待偶数线程输出 } catch (InterruptedException e) { e.printStackTrace(); } } } } } } static class EvenPrinter implements Runnable { public void run() { while (count <= 100) { synchronized (lock) { if (count % 2 == 0) { System.out.println("偶数：" + count); count++; lock.notify(); // 唤醒等待的线程 } else { try { lock.wait(); // 等待奇数线程输出 } catch (InterruptedException e) { e.printStackTrace(); } } } } } } } ``` 运行程序后，可以看到输出结果交替出现奇数和偶数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值