反射机制学习笔记（自用）_diamagnetic代码-CSDN博客

本文链接：https://blog.csdn.net/qq_43130076/article/details/121763710

反射机制

1. 有什么用？

可以通过反射机制直接操作字节码文件（class文件）

2. 反射机制的相关类在哪个包下

java.lang.reflect.*;

3. 反射机制相关的类有哪些？

java.lang.Class：代表一个字节码，代表一个类型，代表整个类

java.lang.reflect.Method：代表字节码中的方法字节码，代表类中的方法

java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法

java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。

// java.lang.Class:
public class User{
    
    //Field
    int no;
    
    //Constructor
    public User(){
    }
    public User(no){
        this.no = no;
    }
    
    //Method
    public void setNo(int no){
        this.no = no;
    }
    public int getNo(){
        return no;
    }
}

4. 获取到这个类的字节码文件

三种方式：

1、方式1

Class c = Class.forName(“完整类名带包名”)
静态方法
方法的参数是一个字符串
字符串需要的是一个完整类名
完整类名必须带有包名java.lang包也不能省略

2、方式2

Class c = 对象.getClass();

3、方式3

java语言中任何一种类型，包括基本类型，它都有.class属性
Class c = 任何类型.class;

package com.company.java.reflect;

import java.util.Date;

/*
* 要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取java.lang.Class实例
*  三种方式
* */
public class ReflectTest01 {
    public static void main(String[] args) throws ClassNotFoundException {
        /*
        *
        * 1、方式1
        *   Class c = Class.forName("完整类名带包名")
        *   静态方法
        *   方法的参数是一个字符串
        *   字符串需要的是一个完整类名
        *   完整类名必须带有包名java.lang包也不能省略
        *
        * 2、方式2
        *   Class c = 对象.getClass();
        *
        * 3、java语言中任何一种类型，包括基本类型，它都有.class属性
        *   Class c = 任何类型.class;
        *
        */
        Class c1 = Class.forName("java.lang.String");//c1代表String.class文件，或者说c1代表String类型
        Class c2 = Class.forName("java.util.Date");//c2代表Date类型
        Class c3 = Class.forName("java.lang.Integer");//c3代表Integer
        Class c4 = Class.forName("java.lang.System");//c4代表System类型


        /*
        *java中任何对象都有一个方法：getclass()
        *
        * */

        String s = "abc";
        Class x = s.getClass();//x代表String.class字节码文件，x代表String类型。
        System.out.println(c1 == x);//true(==判断的是对象的内存地址。)

        Date time = new Date();
        Class y = time.getClass();
        System.out.println(c2 == y);//true (c2和y两个变量中保存的内存地址是一样的，都指向方法区中的字节码文件)


        /*
        * 3、java语言中任何一种类型，包括基本类型，它都有.class属性
        * */
        Class z = String.class;//z代表 string 类型
        Class k = Date.class;//k代表Date类型
        Class j = int.class;//f代表int类型
        Class e = double.class;//e代表double类型
        System.out.println( z == x);

    }
}

5. 获取到Class(字节码文件)有什么用？

通过Class的newInstance()方法来创建对象。

注意：newInstance()方法内部实际上调用了无参构造方法，必须保证无参构造的存在才可以

package com.company.java.reflect;

public class ReflectTest01 {
 public static void main(String[] args) {
     //通过反射机制，获取class，通过Class来实例化对象
     try {
         Class c = Class.forName("com.company.java.bean.User");
         //这个方法会调用User这个类的无参构造，完成对象的创建
         //重点是：newInstance()调用的无参构造，必须保证无参构造存在否则会报异常
         Object o = c.newInstance();

         System.out.println(o);
     } catch (ClassNotFoundException e) {
         e.printStackTrace();
     } catch (InstantiationException e) {
         e.printStackTrace();
     } catch (IllegalAccessException e) {
         e.printStackTrace();
     }
 }
}

实例化异常：

在这里插入图片描述

6. 反射机制更加灵活

反射机制可以通过修改配置文件创建不同的对象

package com.company.java.reflect;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/*验证反射机制的灵活性
* java代码写一遍，在不改变java源码的基础上，可以做到不同对象的实例化。
* 非常灵活（符合OCP开闭原则：对扩展开放，对修改关闭）
*
*
* 后期会学习和使用高级框架
* 包括ssh,ssm,Spring,Springboot,SpringCloud,SpringMVC,MyBatis,Struts,Hibernate
* 这些高级框架底层都采用了反射机制
* */
public class ReflectTest03 {

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

        //以下diamagnetic是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。
        //通过IO流读取classinfo.properties文件
        FileReader reader = new FileReader("C:\\Users\\zhangyingying\\IdeaProjects\\chapter\\classinfo.properties");
        //创建属性类对象Map
        Properties pro = new Properties();//key  value都是String
        //加载
        pro.load(reader);
        //关闭流
        reader.close();

        //通过key获取value
        String className = pro.getProperty("className");

        //通过反射机制实例化对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

配置文件

className=com.company.java.bean.User

7. Class.forName()执行的时候发生了什么

package com.company.java.reflect;
/*
* 研究以下Class.forName()发生了什么
*
* 重点：如果只希望一个类的静态代码块执行，其他代码一律不执行。
* 你可以使用Class.forName("完整类名");
* 这个方法执行会导致类加载，类加载时，静态代码块执行
* */
public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            //Class.forName的执行会导致：类加载
            Class.forName("com.company.java.reflect.MyClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class MyClass{
    static {
        //静态代码块再类加载时执行，并且只执行一次
        System.out.println("MyClass类的静态代码块执行了！");
    }
}

8. 获取类路径下文件的绝对路径

package com.company.java.reflect;

import java.io.FileNotFoundException;
import java.io.FileReader;

/*
* 研究文件路径的问题
* 怎么获取一个文件的绝对路径。一下方式是通用的
* 前提：文件需要在类路径下,才能用这种方式
* */
public class AboutPath {
    public static void main(String[] args) throws Exception {
/*      这种方式的路径，缺点是：移植性差，在IDEA中默认的当前路径是Project的根
        这个代码假设离开了IDEA换到的其他位置，可能当前就不是project的根，这时这个路径就无效了
        FileReader reader = new FileReader("C:\\Users\\zhangyingying\\IdeaProjects\\chapter\\classinfo.properties");

        通用的路径，即使代码换位置，这样编写仍然是通用的
        使用以下通用方式的前提是，这个文件只能在类路径下
        凡是在src下的都是类路径
        src是类的根路径

        */
        
        /*
        * 解释：
        *   Thread.currentThread()  当前线程对象
        *   getContextClassLoader()   是线程对象的方法，可以获取到当前线程的类加载器对象
        *   getResource("")  【获取资源】这是类加载器对象的方法，当前线程的类加载器，默认从类的根路径下加载资源。
        *   getPath()
        *
        *
        * 
        */

        /*
        这种方式获取文件绝对路径
        * 适合于各种操作系统
        * 适合于各种环境的
        * 
        */
        String str = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath();
        System.out.println(str);


        //获取db.properteis文件的绝对路径
        //从类的根路径下作为起点开始
        String str2 = Thread.currentThread().getContextClassLoader()
                .getResource("com/company/java/bean/db.properties").getPath();
        System.out.println(str2);
    }
}

用流的方式返回绝对路径

package com.company.java.reflect;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class IOPropertiesTest {
    public static void main(String[] args) throws Exception {
/*
        方法一：获取绝对路径
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath();
        FileReader fileReader = new FileReader(path);*/

        //方法二：直接以流的形式返回
        InputStream fileReader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("classinfo2.properties");
        Properties pro = new Properties();
        pro.load(fileReader);

        //关闭流
        fileReader.close();
        //通过key值获取value值
        String className = pro.getProperty("className");
        System.out.println(className);
    }
}

9. 资源绑定器

package com.company.java.reflect;

import java.util.ResourceBundle;

/*
* util包下提供了一个资源绑定器，便于获取属性文件中内容
* 使用以下这种方式的时候，属性配置文件xxxx.properties必须放到类路径下。
* */
public class ResourceBundleTest {
    public static void main(String[] args) {
        //资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
        //并且在写路径的时候，路径后面的扩展名千万不能写。

        //ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
        ResourceBundle bundle = ResourceBundle.getBundle("com/company/java/bean/db");
        String className = bundle.getString("className");
        System.out.println(className);

    }
}

10. 类加载器

关于JDK中自带的类加载器：

什么是类加载器？

专门负责加载类的命令/工具
JDK中自带了三个类加载器
- 启动类加载器：父 rt.jar
- 扩展类加载器：母 ext/*.jar
- 应用类加载器 classpath
假设有这样一段代码：

String s = “abc”;

代码在开始执行之前，会将所需要类全部加载到JVM中。

通过类加载器加载，看到以上代码加载器会找到String.class文件，

找到就加载，怎么进行加载呢？

首先先通过”启动类加载器“加载

注意：启动类加载器专门加载：C:\Java\jdk1.8\jre\lib\rt.jar

rt.jar中都是JDK中最核心的类库

如果通过”启动类加载器“加载不到的时候，会通过”扩展类加载器“加载。

注意：扩展类加载器专门加载：C:\Java\jdk1.8\jre\lib\ext.*jar

如果“扩展类加载器”中没有加载到，会通过应用类加载器加载

注意：应用类加载器专门加载：classpath中的类
java中为了保证类加载的安全，使用了双亲委派机制。

优先从启动类加载器中加载，这个称为”父加载器“。

“父加载器”加载不到，再从扩展类加载器中加载，

这个称为“母加载器”。双亲委派。如果都加载不到，

才会考虑从应用类加载器中加载。直到加载到为止。

11. 回顾反射机制

什么反射机制？反射机制有什么用？

可以让程序更灵活

可以操作字节码文件

可以创建对象

反射机制在哪个包下？

java.lang.reflect.*;

反射机制相关的类在哪个包下？

java.lang.Class;

java.lang.reflect.Method

java.lang.reflect.Constructor

java.lang.reflect.Field

在java中获取Class的三种方式

第一种：

Class c = Class.forName(“完整类名”)；

第二种：

Class c = 对象.getClass();

第三种：

Class c = int.class;

Class c = String.Class;

获取了Class之后，可以调用无参构造方法来实例化对象

Class c = Class.forName(“java.util.Date”);

Object obj = c.newInstance();

一定要注意的：newInstance();底层调用的是该类型的无参构造。如果没有无参构造会出现实例化异常。

如果只想让静态代码块执行

Class.forName(“该类的类名”)；

这样类就加载，类加载的时候，静态代码块执行！！！

在这里对该方法返回值不感兴趣，主要是为了使用类加载这个动作

关于路径问题

方法一：为了获取一个文件的绝对路径，但是该文件要求放在类路径下，换句话说：也就是放在src下，src下是类的根路径。

String s = Thread.currentThread().getContextClassLoader().getResrouce("相对路径，但是相对路径从src下出发开始找").getPath();

String s = Thread.currentThread().getContextClassLoader().getResrouce("abc").getPath();//必须保证src下有abc文件

String s = Thread.currentThread().getContextClassLoader().getResrouce("a/db").getPath();//必须保证src下有a目录，a目录下有db文件
String s = Thread.currentThread().getContextClassLoader().getResrouce("com/compary/test.properties").getPath();//必须保证src下有a目录，a目录下有db文件

这种方式是为了获取一个文件的绝对路径。通常不会受到环境移植的影响。但是文件要求放在类路径下

方法二：

InputStream filereader = Thread.currentThread().getContextClassLoader().getResrouceAsStream("");


Properties pro = new Properties();

pro.load(filereader);

fileReader.close();

String className = pro.getProperties("className");

快速绑定属性资源文件

//要求：这个文件必须在类路径下
//这个文件必须以.properties结尾
ResourceBundle bundle = ResourceBundle.getBundle("com/company/java/db");
String str = bundle.getString(key);

12. 获取Field

package com.company.java.reflect;

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

public class ReflectTest05 {
    public static void main(String[] args) throws ClassNotFoundException {

        //第一步获取整个Student类
        Class c = Class.forName("com.company.java.bean.Student");
        
        //get完整类名
        String s1 = c.getName();
        System.out.println(s1);
        
        //get一个简类名
        String simpleName = c.getSimpleName();
        System.out.println(simpleName);


        
        //获取类中所有的public的Field
        Field[] fields = c.getFields();
        System.out.println(fields.length);//测试数组中只有一个元素

        //取出这个Field
        Field f = fields[0];
        String fieldName = f.getName();
        System.out.println(fieldName);

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

        //获取所有的Field
        Field[] field = c.getDeclaredFields();
        System.out.println(field.length);

        //遍历
        for (Field fs : field) {
            //获取属性的名字
            String s = fs.getName();
            System.out.println(s);

            //获取属性的类型
            Class fieldType = fs.getType();
            String fName = fieldType.getName();
            String fName2 = fieldType.getSimpleName();
            System.out.println(fName);
            System.out.println(fName2);

            //获取属性的修饰符列表
            //返回的修饰符是一个数字

            int i = fs.getModifiers();
            System.out.println(i);
            //将代号数字转换为字符串
            String m = Modifier.toString(i);
            System.out.println(m);
            System.out.println();
        }
    }
}

13. 反编译Field

package com.company.java.reflect;

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

/*
* 通过反射机制，反编译一个类的属性Field
* */
public class ReflectTest06 {
    public static void main(String[] args) throws ClassNotFoundException {
        //创建这个只是为了拼接字符串。
        StringBuilder s = new StringBuilder();

        Class studentClass = Class.forName("com.company.java.bean.Student");

        s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + " {");

        Field[] fields = studentClass.getDeclaredFields();
        s.append("\n");
        for (Field fs :fields) {

            int i = fs.getModifiers();
            String str = Modifier.toString(i);

            Class c = fs.getType();
            String name = c.getSimpleName();

            String s1 = fs.getName();

            s.append("\t");
            s.append(str);
            s.append(" ");
            s.append(name);
            s.append(" ");
            s.append(s1);
            s.append(";");
            s.append("\n");
        }

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

    }
}

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

package com.company.java.reflect;
/*
* 必须掌握：
* 怎么通过反射机制访问一个java对象的属性？
* 给属性赋值
* 获取属性值
* */

import com.company.java.bean.Student;

import java.lang.reflect.Field;

public class ReflectTest07 {
    public static void main(String[] args) throws Exception {
        //不使用反射机制怎么访问一个对象的属性
        Student student = new Student();
        student.no = 111;//三要素：给student对象的no赋值111
                        //要素1：对象s
                        //要素2：no属性
                        //要素3：值111
        System.out.println(student.no);

        //使用反射机制，怎么去访问一个对象的属性
        Class studentClass = Class.forName("com.company.java.bean.Student");
        Object obj = studentClass.newInstance();//Obj就是Student对象（底层调用无参数构造方法）

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

        //给obj对象（student）的no属性赋值
        /*
        * 虽然使用了反射机制，但三要素还是缺一不可
        * 要素1：obj对象
        * 要素2：no属性
        * 要素3：01值
        * 反射机制让代码复杂了，但是使用起来灵活了
        * */
        noField.set(obj,12);//给obj对象的no赋值01
        //读取属性的值
        //获取obj对象的no属性的值

        System.out.println(noField.get(obj));

        //可以访问私有的属性吗？


        Field name = studentClass.getDeclaredField("name");

        //打破封装(反射机制的缺点：打破封装可能会给不法分子留下机会)
        //这样设置完会给不法分子留下机会
        name.setAccessible(true);
        //给name属性赋值
        name.set(obj,"zhangsan");
        //获取name属性的值
        System.out.println(name.get(obj));
    }
}

15. 可变长度参数

package com.company.java.reflect;
/*
* 可变长度参数
*   int...args就是可变长度参数
*   语法是：类型...（注意一定是三个点）
*
* 1、可变长度参数要求的参数个数是0-N个
* 2、可变长度参数在参数列表中必须是最后一个位置上。而且可变长参数只能有一个。
* 3、可变长度参数可以当作一个数组来看待
* */

public class ArgsTest {
    public static void main(String[] args) {
        m();
        m(10);
        m(10,20);
        m2(100);
        m2(10,"abc");
        m2(20,"abc","abcd","hjs");

        m3("hsuusjifj","jsheuhr","bjdhahi","jdhuahu");
    }
    public static void m(int...args){

        System.out.println("sofijijia");

    }
    //public static void m2(int...args2,String...args1){}

    //必须在最后，且只能有一个
    public static void m2(int a,String...args1){

    }
    public static void m3(String...args3){
        //args3有length属性，说明args是一个数组
        for (int i = 0; i < args3.length; i++) {
            System.out.println(args3[i]);
        }
    }

}

16. 反射Method

package com.company.java.reflect;

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

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

        //遍历方法
        for (Method method: methods) {
            //获取方法修饰符
            System.out.println(Modifier.toString(method.getModifiers()));
            //获取方法返回值类型
            System.out.println(method.getReturnType().getSimpleName());
            //获取方法名
            System.out.println(method.getName());
            //方法的修饰列表（一个method参数可能有多个）
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parameter : parameterTypes) {
                System.out.println(parameter.getSimpleName());
            }
        }

    }
}

17. 反编译Method

package com.company.java.reflect;
/*
* 反编译一个类的方法
* */
import com.company.java.serivce.UserService;
import javafx.util.Builder;

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

public class ReflectTest09 {
    public static void main(String[] args) throws Exception{
        Class userService = Class.forName("java.lang.String");
        StringBuilder s = new StringBuilder();
        s.append(Modifier.toString(userService.getModifiers()) + " class " + userService.getSimpleName() + " {");
        s.append("\n");
        Method[] methods = userService.getDeclaredMethods();
        //public boolean login(String name, String password){
        for (Method method : methods) {
            s.append("\t");
            s.append(Modifier.toString(method.getModifiers()));
            s.append(" ");
            s.append(method.getReturnType().getSimpleName());
            s.append(" ");
            s.append(method.getName() + "(");
            //参数列表
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parameter:parameterTypes) {
                s.append(parameter.getSimpleName());
                s.append(",");
            }
            //删除指定下标位置上的字符
            s.deleteCharAt(s.length() - 1);
            s.append("){}\n");
        }

        s.append("}");

        System.out.println(s);
    }
}

18. 反射机制调用方法

package com.company.java.reflect;

import com.company.java.serivce.UserService;

import java.lang.reflect.Method;

/*
* 重点：怎么通过反射机制调一个对象的方法
*反射机制让代码很具有通用性，可变化的内容都是写在配置文件中的，将来修改配置文件之后，创建的文件不一样了，调用的方法也不同了，但是java代码不需要进行改动
* */
public class ReflectTest10 {
    public static void main(String[] args) throws Exception{
        //不使用反射机制，怎么调用方法
        UserService userService = new UserService();
        boolean loginSuccess = userService.login("admin","123");
        System.out.println(loginSuccess);

        //使用反射机制来调用一个方法该怎么做
        Class userServiceClass = Class.forName("com.company.java.serivce.UserService");
        //创建对象
        Object obj = userServiceClass.newInstance();
        //获取Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login",String.class,String.class);
        //调用方法：要素：对象userService,login方法名，实参列表，返回值
        //反射机制中最重要的一个方法，必须记住
        //loginMethod//方法
        //"admin","123"//实参
        //obj//对象
        //retvalue返回值
        Object retvalue = loginMethod.invoke(obj,"admin","123");
        System.out.println(retvalue);
    }
}

19. Constructor

package com.company.java.reflect;
/*
* 反编译一个类的Constructor构造方法。
*
* */

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

public class ReflectTest11 {
    public static void main(String[] args) throws Exception{
        StringBuilder stringBuilder = new StringBuilder();
        Class vipClass = Class.forName("com.company.java.bean.VIP");
        //public class VIP {
        stringBuilder.append(Modifier.toString(vipClass.getModifiers()) + " class " + vipClass.getSimpleName() + " {\n");

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

        System.out.println(stringBuilder);
    }
}

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

package com.company.java.reflect;
/*
* 通过反射机制调用构造方法实例化对象
* */

import com.company.java.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","1999-01-23",true);
        //使用构造方法创建对象
        Class vipClass = Class.forName("com.company.java.bean.VIP");
        //调用无参数构造
        System.out.println(vipClass.newInstance());
        //调用有参数的构造方法
         Constructor cons = vipClass.getDeclaredConstructor(int.class, String.class, String.class, boolean.class);

         //调用构造方法new对象
        Object obj = cons.newInstance(100,"jackson","1900-07-12",true);
        System.out.println(obj);

        //获取无参构造方法
        Constructor cons2 = vipClass.getDeclaredConstructor();
        Object obj2 = cons2.newInstance();
        System.out.println(obj2);

    }
}

21. 获取一个类的父类以及实现了哪些接口

package com.company.java.reflect;
/*
* 给你一个类，怎么获取这个类的父类，已经实现了哪些接口
* */
public class ReflectTest13 {
    public static void main(String[] args) throws Exception{

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

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

        //获取String类所有实现了的接口
        Class[] superInterfaces = c.getInterfaces();
        for (Class interfaces : superInterfaces) {
            System.out.println(interfaces.getName());
        }
    }
}