java注解(Annotation)和反射(Reflection)

news2024/11/24 18:53:00

文章目录

  • 重要的点
  • 一 注解 ( A n n o t a t i o n ) (Annotation) (Annotation)
  • 二 反射 ( R e f l e c t i o n ) (Reflection) (Reflection)
    • 2.0 关于动态语言和静态语言的补充
    • 2.1 Java反射机制概述
      • 2.1.1 Java反射机制提供的功能
      • 2.1.2 Java反射的优点和缺点
      • 2.1.3 Java反射相关的主要API
      • 2.1.4 java反射演示
    • 2.2 理解class类并获取class实例
      • 2.2.1 Class类
      • 2.2.2 Class类的常用方法
      • 2.2.3 获取Class类的实例
      • 2.2.4 获取Class类代码演示
      • 2.2.5 拥有Class对象的类型
      • 2.2.6 内置数据类型、注解、void的Class类代码演示
    • 2.3 Java内存分析
    • 2.4 类的加载与ClassLoader
      • 2.4.1 代码演示
      • 2.4.2 初始化时间
      • 2.4.3 初始化代码演示
      • 2.4.4 类加载器的作用
      • 2.4.5 类加载器代码演示
    • 2.5 调用运行时类的指定结构
      • 2.5.1 通过反射获取运行时类的完整结构
      • 2.5.2 代码演示
      • 2.5.4 调用指定的方法
      • 2.5.5 反射检测性能分析代码演示
      • 2.5.6 反射操作泛型
      • 2.5.7 反射操作泛型代码演示
      • 2.5.8 反射操作注解
      • 2.5.9 ORM练习代码
    • 2.6 创建运行时类的对象
      • 2.6.1 创建运行时对象
      • 2.6.2 创建运行时对象代码演示

重要的点

  • 感谢狂神说对java教学的奉献。感谢有你！
  • 通过反射机制编程实现对这些元数据的访问。
  • 概念理论看不懂可以结合代码演示认真体会
  • 文末，有彩蛋哟！

一 注解 ( A n n o t a t i o n ) (Annotation) (Annotation)

1.1 注解初识

  • Annotation是从JDK5.0开始引入新技术
  • Annotation的作用：
    • 可以对程序作出解释，类似于注释（comment）
    • 可以被其他程序（此如：编译器等）读取
  • Annotation的格式：
    • 注解是以"@注释名"在代码中存在的，同时还可以添加一些参数值。
@SuppressWarnings(value="unchecked”）
  • 注解的使用范围：package，class，method，field等上面，相当于给他们添加了额外的辅助信息。

1.2 内置注解

注解名称详解
@Override定义在 j a v a . l a n g . O v e r r i d e java.lang.Override java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明
@Deprecated定义在 j a v a . l a n g . D e p r e c a t e d java.lang.Deprecated java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，不鼓励程序员使用这样的元素
@SuppressWarnings 定义在 定义在 定义在java.lang.SuppressWarnings$中，用来抑制编译时的警告信息需要添加一个已经定义好的参数才能正确使用
@SuppressWarnings("all")
@SuppressWarnings("unchecked")
@SuppressWarnings(value={"unchecked","deprecation"})

1.3 内置注解代码演示

/**
 * @author 缘友一世
 * date 2022/12/26-11:28
 */
//内置注释的了解和演示
public class AnnotationTest {
    public static void main(String[] args) {
        Man man = new Man();
        //使用@Deprecated注释的方法或者类时，会出现横线的提示
        man.test();
    }

}
//所有类默认继承Object类
class Man extends Object {
    public String name;

    //@Override 重写注释
    @Override
    public String toString() {
        return "man{" +
                "name='" + name + '\'' +
                '}';
    }

    //Deprecated 不推荐使用注释，但是可以使用，或者存在更好的方式
    @Deprecated
    public void test() {
        System.out.println("Deprecated");
    }

    @SuppressWarnings("all")
    //未调用此方法时，方法名会变为灰色，可使用@SuppressWarnings("all")镇压警号
    //一般情况下，不建议使用，可以帮我们避免一些错误
    public void test02() {
        System.out.println("test01");
    }
}

1.4 元注解 ( m e t a − a n n o t a t i o n ) (meta-annotation) (meta−annotation)

  • 元注解的作用就是负责注解其他注解。
  • Java定义了4个标准的元注解类型，他们被用来、提供对其他注解类型作说明
  • 这些类型和它们所支持的类在 j a v a . l a n g . a n n o t a t i o n java.lang.annotation java.lang.annotation包中可以找到.（@Target，@Retention，@Documented，@Inherited）
元注解说明
@Target用于描述注解的使用范围
@Retention表示保存该注释信息的级别，用于描述注解的生命周期（SOURCE>CLASS>RUNTIME)
@Document说明该注解将被包含在javadoc中
@Inherited说明子类可以继承父类中的该注解

1.5 元注解代码演示

/**
 * @author 缘友一世
 * date 2022/12/26-11:43
 */
//元注释的认识和使用
public class MetaAnnotationTest {
    @MyAnnotation
    public static void main(String[] args) {

    }

}
//@Retention 标注注解的有效范围 SOURCE<CLASS<RUNTIME
//@Retention(value=RetentionPolicy.RUNTIME)
//当注解的参数只有一个时，就可以省略简写，如下形式
@Retention(RetentionPolicy.RUNTIME)
//Target 标记注解的使用范围 方法、类、变量、包... 其参数类型时字符串数组
//@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Inherited  //@Inherited 子类可继承父类的注解
@Documented //@Documented 将注解生成在JAVADoc中
//@interface 定义一个注释
@interface MyAnnotation {

}

1.6 自定义注解

  • @ i n t e r f a c e @interface @interface自定义注解，自动继承了 j a v a . l a n g . a n n o t a t i o n . A n n o t a t i o n java.lang.annotation.Annotation java.lang.annotation.Annotation接口
  1. @ i n t e r f a c e @interface @interface用来声明一个注解，格式： p u b l i c @ i n t e r f a c e 注解名（定义内容） public@interface注解名（定义内容） public@interface注解名（定义内容）
  2. 其中的每一个方法实际上是声明了一个配置参数
  3. 方法的名称就是参数的名称
  4. 返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）.
  5. 可以通过 d e f a u l t default default来声明参数的默认值
  6. 如果只有一个参数成员，一般参数名为value
  7. 注解元素必须要有值，在定义注解元素时，经常使用空字符串，0作为默认值
//自定义注解
public class CustomizedAnnotationTest {
    //没有默认初始化的参数必须——显式定义；否则，报错
    @MyAnnotation2(name = "tom",numbers = {"0001","002"})
    public void test01(){

    }
    @MyAnnotation3("Cat")
    public void test02() {

    }
}

1.7 自定义注解代码演示

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

/**
 * @author 缘友一世
 * date 2022/12/26-11:57
 */
//自定义注解
public class CustomizedAnnotationTest {
    //没有默认初始化的参数必须——显式定义；否则，报错
    @MyAnnotation2(name = "tom",numbers = {"0001","002"})
    public void test01(){

    }
    @MyAnnotation3("Cat")
    public void test02() {

    }
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数： 参数类型+参数名()
    //没有默认初始化的参数必须——显式定义；否则，报错
    //已经默认初始化的参数，不显式定义，也不会报错，也可以显式定义。
    String name();//自定义参数变量的后面要有（）
    String[] numbers();
    int age() default 0;//默认参数值
    int score() default -1;//默认值-1，代表不存在
}

//只有一个参数时，建议定义参数名为value
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();
}

二 反射 ( R e f l e c t i o n ) (Reflection) (Reflection)

2.0 关于动态语言和静态语言的补充

  • 动态语言
    • 一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说：在运行时代码可以根据某些条件改变自身结构。
    • 主要动态语言：Object-C、C#、JavaScript、PHP、Python……
  • 静态语言
    • 运行时结构不可变的语言就是静态语言，如Java、c、C++。
    • Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性我们可以利用反射机制获得类似动态语言的特性。

2.1 Java反射机制概述

  • 反射是Java被视为动态语言的关键，反射机制允许程序在执行期借助于反射API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
Class class=Class.forName("java.lang.String")
  • java虚拟机加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有这个对象就包含了完整的类的结构信息个Class对象）
  • 通过这个对象可以看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以形象的称之为：反射。

在这里插入图片描述

2.1.1 Java反射机制提供的功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理

2.1.2 Java反射的优点和缺点

优点缺点
可以实现动态创建对象和编译，体现出很大的灵活性对性能有影响。
使用反射基本上是一种解释操作，这类操作总是慢于直接执行相同的操作。

2.1.3 Java反射相关的主要API

API说明
java.lang.Class代表一个类
java.lang.reflect.Method代表类的方法
java.lang.reflect.Field代表类的成员变量
java.lang.reflect.Constructor代表类的构造器

2.1.4 java反射演示

/**
 * @author 缘友一世
 * date 2022/12/26-21:53
 */
//认识反射
public class demo02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class<?> c1 = Class.forName("Reflection.User02");
        Class<?> c2 = Class.forName("Reflection.User02");
        System.out.println(c1);
        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println("c1的hashCode值"+c1.hashCode());
        System.out.println("c2的hashCode值"+c2.hashCode());

    }
}
class User02 {
    private String name;
    private int id;
    private int age;

    public User02() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

在这里插入图片描述

2.2 理解class类并获取class实例

  • 在Object类中定义了以下的方法，getClass()被所有子类继承.
  • 返回值的类型是一个Class此类是Java反射的源头类。
  • 反射从程序的运行结果来看，即：可以通过对象反射求出类的名称。对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类实现了哪些接口。
public final Class getClass(）

在这里插入图片描述

2.2.1 Class类

  • 对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构的有关信息。
  • Class本身也是一个类
  • Class对象只能由系统建立对象
  • 一个加载的类在JVM中只会有一个Class实例
  • 一个Class对象对应的是一个加载到JVM中的一个.class文件
  • 每个类的实例都会记录是由哪个Class实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是反射的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

2.2.2 Class类的常用方法

方法名功能说明
static ClassforName(String name)返回指定类名name的Class对象
Object newlnstance()
getName(）返回此Class对象所表示的实体（类，接口，数组类或void）的名称
Class getSuperClass()返回当前Class对象的父类的Class对象
Class[] getinterfaces()获取当前Class对象的接口
ClassLoader getClassLoader()返回该类的类加载器
ConstructorflgetConstructors()返回一个包含某些Constructor对象的数组
Method getMothed（Stringname,Class…T）返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields()返回Field对象的一个数组

2.2.3 获取Class类的实例

  1. 若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
Class class=Person.class;
  1. 已知某个类的实例，调用该实例的getclass()方法法获取Class对象
Class class=person.getClass();
  1. 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取可能抛出ClassNotFoundException
Class class=Class.forName(demo01.Student”);
  1. 内置基本数据类型可以直接用类名.Type
Class<Integer> c4 = Integer.TYPE;
  1. 利用ClassLoader
在这里插入代码片

2.2.4 获取Class类代码演示

/**
 * @author 缘友一世
 * date 2022/12/26-22:00
 */
public class demo03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person03 person = new Student03();
        System.out.println(person.name);

        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1);
        System.out.println("c1的hashCode值:"+c1.hashCode());

        //方式二：通过forName获得
        Class<?> c2 = Class.forName("Reflection.Student03");
        System.out.println(c2);
        System.out.println("c2的hashCode值:"+c2.hashCode());

        //方式三：通过类名.class获得
        Class<Student03> c3 = Student03.class;
        System.out.println(c3);
        System.out.println("c3的hashCode值:"+c3.hashCode());

        //方式四：基本内置类型的包装类都有一个Type属性
        Class<Integer> c4 = Integer.TYPE;
        System.out.println(c4);

        //获取父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);

    }
}
class Person03 {
    public String name;
    public Person03() {

    }

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

    @Override
    public String toString() {
        return "Person03{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Student03 extends Person03 {
    public Student03() {
        this.name="student";
    }
}
class Teacher03 extends Person03 {
    public Teacher03() {
        this.name="teacher";
    }
}

在这里插入图片描述

2.2.5 拥有Class对象的类型

  • class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
  • interface：接口
  • []：数组
  • enum：枚举
  • annotation：注解@interface
  • primitivetype：基本数据类型
  • void

2.2.6 内置数据类型、注解、void的Class类代码演示

/**
 * @author 缘友一世
 * date 2022/12/26-22:17
 */
//所有类型的Class
public class demo04 {
    public static void main(String[] args) {
        Class c1 = Object.class;   //类
        Class c2=Comparable.class; //接口
        Class c3=String[].class;   //一维数组
        Class c4=char[][].class;   //二维数组
        Class c5= Override.class;  //注解
        Class c6= Element.class;   //枚举
        Class c7=Integer.class;    //基本类型
        Class c8=void.class;       //void
        Class c9=Class.class;      //Class
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //不同的同类对象具有相同的Class类
        int[] arr1=new int[10];
        int[] arr2=new int[100];
        System.out.println(arr1.getClass().hashCode());
        System.out.println(arr2.getClass().hashCode());
    }
}

在这里插入图片描述

2.3 Java内存分析

在这里插入图片描述
在这里插入图片描述

2.4 类的加载与ClassLoader

  • 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 j a v a . l a n g . C l a s s java.lang.Class java.lang.Class对象
  • 链接：将Java类的二进制代码合并到VM的运行状态之中的过程
    • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
    • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
    • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
  • 初始化：
    • 执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
    • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
    • 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。
      在这里插入图片描述

2.4.1 代码演示

/**
 * @author 缘友一世
 * date 2022/12/26-22:24
 */
//类的加载理解
public class demo05 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }
}
/*
* 1. 加载到内存，产生一个类对应class对象
* 2.链接，链接结束后m=0
* 3.初始化
*       <clinit>() {
*              System.out.println("A类静态代码初始化");
*              m=2;
*              m=1;
*       }
* */
class A {
    static {
        System.out.println("A类静态代码初始化");
        m=2;
    }
    static int m=1;
    public A() {
        System.out.println("A类的无参构造初始化");
    }
}

在这里插入图片描述

2.4.2 初始化时间

类的主动引用（一定会发生类的初始化）类的被动引用（不会发生类的初始化）
当虚拟机启动，先初始化main方法所在的类
new一个类的对象
调用类的静态成员（除了final常量）和静态方法
使用java.lang.reflect包的方法对类进行反射调用
当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类		当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
通过数组定义类引用，不会触发此类的初始化
引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

2.4.3 初始化代码演示

/**
 * @author 缘友一世
 * date 2022/12/26-22:33
 */
//测试类何时初始化
public class demo06 {
    static {
        System.out.println("Main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        demo06 dm = new demo06();
        dm.test01();
        /*
            Main类被加载
            Father类被加载
            Son类被加载
         */
        //dm.test02();
        /*
            Main类被加载
            Father类被加载
            1
         */
        //dm.test03();// Main类被加载
        dm.test04();
        /*
         Main类被加载
         666
        */
    }
    public void test01() throws ClassNotFoundException {
        //1. 主动引用
        Son son = new Son();

        //反射也会产生主动引用
        Class<?> c1 = Class.forName("Reflection.Son");
    }
    public void test02() {
        //不会产生类的引用的方法 子类调用父类的静态变量
        System.out.println(Son.x1);
    }
    public void test03() {
        //只是申请空间和变量名，虚拟机启动，先初始化Main所在的类，所以只有Main被加载
        Son[] sons = new Son[5];
    }
    public void test04() {
        //类中的常量并不会导致子类和父类的初始化
        System.out.println(Son.m);
    }
}
class Father{
    static int x1=1;
    static {
        System.out.println("Father类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("Son类被加载");
        x=10;
    }
    static int x=100;
    static final int m=666;
}

2.4.4 类加载器的作用

  • 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
  • 类缓存：标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象
    在这里插入图片描述
  • 类加载器的作用就是把类(class)装载进内存。JVM规范定义了如下类型的加载器。
  • 引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取
  • 扩展类加载器：负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
  • 系统类加载器：负责java-classpath或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器
    在这里插入图片描述

2.4.5 类加载器代码演示

package Reflection;

/**
 * @author 缘友一世
 * date 2022/12/26-22:56
 */
public class demo07 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //获取系统类加载器的父类加载器-->拓展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //获取拓展类加载器的父类加载器-->根加载器(c/c++编写)
        //引导类加载器，用来装载核心类库，加载器无法直接获取，所以返回为null
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("Reflection.demo07").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置的类是哪个加载器加载的-->根加载器
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);//null

        //获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        //双亲委派机制
        /*
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;
        C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar; 重要的类库
        C:\Users\HP\Desktop\program\java basic grammar\out\production\basic grammar;
        C:\Users\HP\Desktop\program\java basic grammar\basic grammar\src\IO流\libs\commons-io-2.11.0.jar;
        C:\Users\HP\Desktop\program\java basic grammar\basic grammar\src\多线程\lib\commons-io-2.11.0.jar;
        C:\Program Files\JetBrains\IntelliJ IDEA 2022.2.1\lib\idea_rt.jar;
        C:\Users\HP\AppData\Local\JetBrains\IntelliJIdea2022.2\captureAgent\debugger-agent.jar
         */
    }
}

在这里插入图片描述

2.5 调用运行时类的指定结构

2.5.1 通过反射获取运行时类的完整结构

  • 实现的全部接口(Interface)
  • 所继承的父类(Superclass)
  • 全部的构造器( Constructor)
  • 全部的方法(Method)
  • 全部的字段(Field)
  • 注解(Annotation)

2.5.2 代码演示

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

/**
 * @author 缘友一世
 * date 2022/12/26-23:12
 */
//获得类的信息
public class demo08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class<?> c1 = Class.forName("Reflection.User08");

        //获取类的名字
        System.out.println("获取类的名字");
        System.out.println(c1.getName());//包名+类名
        System.out.println(c1.getSimpleName());//类名

        //获取类的属性
        System.out.println("-----------");
        //获取public属性
        System.out.println("获取类的public属性");
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("-----------");
        System.out.println("获取所有的属性");
        //获取所有的属性
        Field[] fields1 = c1.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }

        System.out.println("-----------");
        System.out.println("获取指定属性的值");
        //获取指定属性的值[public&private访问权限]
        Field name = c1.getDeclaredField("phone");
        Field name2 = c1.getDeclaredField("name");
        System.out.println("public属性的"+name);
        System.out.println("private属性的"+name2);

        System.out.println("-----------");
        //获取类的方法[包含父类的方法]
        //public访问权限的方法
        System.out.println("获取public访问权限的方法");
        Method[] methods = c1.getMethods();
        for(Method method:methods) {
            System.out.println("public:"+method);
        }
        //类的所有方法
        System.out.println("获取类的所有方法");
        Method[] declaredMethods = c1.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("getDeclaredMethods:"+declaredMethod);
        }

        System.out.println("-----------");
        //获取指定方法
        System.out.println("获取类的指定方法");
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        System.out.println("-----------");
        //获取类的构造器
        System.out.println("获取类public构造器");
        Constructor<?>[] constructors = c1.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("public Constructor:"+constructor);
        }
        System.out.println("获取类所有的构造器");
        Constructor<?>[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("declaredConstructor:"+declaredConstructor);
        }

        System.out.println("-----------");
        //获取指定的构造器
        Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("获取指定的构造器：");
        System.out.println(declaredConstructor);

    }
}
class User08 {
    private String name;
    private int id;
    private int age;
    public String phone;

    public User08() {
    }

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

    private User08(String name,int id) {
        this.name = name;
        this.id = id;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.5.4 调用指定的方法

在这里插入图片描述

//获取Class对象
Class<?> c1 = Class.forName("Reflection.User09");
//通过反射调用普通方法
User09 user3 = (User09)c1.newInstance();
//通过反射获取一个方法
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user3,"小倩");//invoke 激活 (对象,"方法的值")
System.out.println(user3.getName());
  • 通过反射，调用类中的方法，通过Method类完成
    1. 通过Class类的getMethod(String name,Class...parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
    //获取Class对象
Class<?> c1 = Class.forName("Reflection.User09");
//通过反射获取一个方法
Method setName = c1.getDeclaredMethod("setName", String.class);
    1. 之后使用Object invoke(Object obj，Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息
      • Object invoke(Object obj,Object...args)

        • Object对应原方法的返回值，若原方法无返回值，此时返回null

        • 若原方法若为静态方法，此时形参Objectobj可为null

        • 若原方法形参列表为空，则Objectf]args为null

        • 若原方法声明为private，则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

        • Method和Field、Constructor对象都有setAccessible()方法

          • setAccessible作用是启动和禁用访问安全检查的开关

          • 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。

            • 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。使得原本无法访问的私有成员也可以访问。

          • 参数值为false则指示反射的对象应该实施Java语言访问检查

2.5.5 反射检测性能分析代码演示

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author 缘友一世
 * date 2022/12/27-9:54
 */
//分析性能问题
public class demo10 {

    //普通方法调用
    private static void test01() {
        User10 user = new User10("小静",100,8);
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            user.getName();
        }
        long endTime=System.currentTimeMillis();
        System.out.println("普通方法执行1亿次耗时："+(endTime-startTime)+"ms");
    }
    //反射方法调用
    private static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User10 user = new User10("小静",100,8);
        Class<? extends User10> c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            getName.invoke(user,null);
        }
        long endTime=System.currentTimeMillis();
        System.out.println("反射方法[未关闭检测]执行1亿次耗时："+(endTime-startTime)+"ms");
    }
    //反射方法调用关闭检测
    private static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User10 user = new User10("小静",100,8);
        Class<? extends User10> c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            getName.invoke(user,null);
        }
        long endTime=System.currentTimeMillis();
        System.out.println("反射方法[关闭检测]执行1亿次耗时："+(endTime-startTime)+"ms");
    }
    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        test01();
        test02();
        test03();
    }
}
class User10 {
    private String name;
    private int id;
    private int age;
    public String phone;

    public User10() {
    }

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

    private User10(String name,int id) {
        this.name = name;
        this.id = id;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

在这里插入图片描述

2.5.6 反射操作泛型

  • Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
  • 为了通过反射操作这些类型，Java中ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
泛型类说明
ParameterizedType表示一种参数化类型，比如Collection<String>
GenericArrayType表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable各种类型变量的公共父接口
WildcardType代表一种通配符类型表达式

2.5.7 反射操作泛型代码演示

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

/**
 * @author 缘友一世
 * date 2022/12/27-10:06
 */
//反射操作泛型
public class demo11 {
    public static void test01(Map<String,User11> map, List<User11> list) {
        System.out.println("test01");
    }
    public static  Map<String,User11> test02() {
        System.out.println("test02");
        return null;
    }
    public static void main(String[] args) throws NoSuchMethodException {
        Method method = demo11.class.getMethod("test01", Map.class, List.class);
        //获得方法的泛型参数类型
        Type[] genericExceptionTypes = method.getGenericParameterTypes();
        for (Type genericExceptionType : genericExceptionTypes) {
            System.out.println(">>"+genericExceptionType);
            //获取泛型的信息 泛型参数类型属于参数化类型
            if(genericExceptionType instanceof ParameterizedType) {
                //强制转化 获得真实的参数信息
                Type[] actualTypeArguments = ((ParameterizedType) genericExceptionType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        System.out.println(">>>>>>>>>>>>>>>>");
        Method method1 = demo11.class.getMethod("test02", null);
        //获取泛型的返回值类型
        Type genericReturnType = method1.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}
class User11 {
    private String name;
    private int id;
    private int age;
    public String phone;

    public User11() {
    }

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

    private User11(String name,int id) {
        this.name = name;
        this.id = id;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

在这里插入图片描述

2.5.8 反射操作注解

Modifier and TypeMethod and Description
<A extends Annotation>getAnnotation(类<A> annotationClass)
返回该元素的，如果这样的注释 ，否则返回null指定类型的注释。
Annotation[] getAnnotations() 返回此元素上 存在的注释。

2.5.9 ORM练习代码

  • ORM练习：
    • ORM：Object relationship Mapping ==>对象关系映射
    • 类和表结构对应
    • 属性和字段对应
    • 对象和字段对应
  • 要求：利用注解和反射完成类和表结构的映射关系
package Reflection;

import java.lang.annotation.*;
import java.lang.reflect.Field;

/**
 * @author 缘友一世
 * date 2022/12/27-10:36
 */
//反射操作注解
/*
    ORM练习：
        ORM：Object relationship Mapping ==>对象关系映射
        类和表结构对应
        属性和字段对应
        对象和字段对应
    利用注解和反射完成类和表结构的映射关系
 */
public class demo12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("Reflection.student12");
        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解的value的值
        table tb = c1.getAnnotation(table.class);
        String value = tb.value();
        System.out.println(value);

        //获得类指定的注解
        Field f = c1.getDeclaredField("name");
        filed annotation = f.getAnnotation(filed.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface table{
    String value();
}

//属性注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface filed{
    String columnName();
    String type();
    int length();
}
@table("db_student")
class student12 {
    @filed(columnName = "db_id",type = "int",length = 5)
    private int id;
    @filed(columnName = "db_age",type = "int",length = 10)
    private int age;
    @filed(columnName = "db_name",type = "int",length = 8)
    private String name;

    public student12() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

在这里插入图片描述

2.6 创建运行时类的对象

2.6.1 创建运行时对象

使用Class对象之后，可以完成的操作

  • 创建类的对象：调用Class对象的newlnstance()方法
    1. 类必须有一个无参数的构造器。
    2. 类的构造器的访问权限需要足够
  • 思考
    • 难道没有无参的构造器就不能创建对象了吗？
    • 只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作
  • 步骤如下：
    1. 通过Class类的getDeclaredconstructor(class…parameterTypes）取得本类的指定形参类型的构造器
    2. 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数
    3. 通过Constructor实例化对象
 //获取Class对象
        Class<?> c1 = Class.forName("Reflection.User09");
        //构造一个对象
        //本质是调用类的无参构造器 如果类中没有无参构造器，会报错
        User09 user = (User09)c1.newInstance();
        System.out.println(user);

        System.out.println("---------");
        //通过构造器创建对象
        Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User09 user2 = (User09) constructor.newInstance("小茜", 101, 22);
        System.out.println(user2);

2.6.2 创建运行时对象代码演示

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

/**
 * @author 缘友一世
 * date 2022/12/27-9:37
 */
//动态的创建对象，通过反射
public class demo09 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获取Class对象
        Class<?> c1 = Class.forName("Reflection.User09");
        //构造一个对象
        //本质是调用类的无参构造器 如果类中没有无参构造器，会报错
        User09 user = (User09)c1.newInstance();
        System.out.println(user);

        System.out.println("---------");
        //通过构造器创建对象
        Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User09 user2 = (User09) constructor.newInstance("小茜", 101, 22);
        System.out.println(user2);
		//通过反射调用普通方法
        User09 user3 = (User09)c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getMethod("setName", String.class);
        setName.invoke(user3,"小倩");//invoke 激活 (对象,"方法的值")
        System.out.println(user3.getName());

        System.out.println("---------");
        //通过反射操作属性
        User09 user4 = (User09) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接获得属性，需要关闭程序的安全检测 属性或者方法的setAccessible(true)
        name.setAccessible(true);
        name.set(user4,"小瑶");
        System.out.println(user4.getName());
    }
}
class User09 {
    private String name;
    private int id;
    private int age;
    public String phone;

    public User09() {
    }

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

    private User09(String name,int id) {
        this.name = name;
        this.id = id;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

在这里插入图片描述

***感谢阅读！***养眼时刻
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/126476.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

gitlab-ci.yml关键字（三）before_script 、script 、after_script

gitlab-ci.yml关键字（三）before_script 、script 、after_script

before_script before_script 用于定义在每个作业执行之前所运行的一系列脚本命令。这里需要注意的是&#xff0c;before_script 运行的时机&#xff0c;是在制品&#xff08;artifacts&#xff09;恢复后&#xff0c;也就意味着&#xff0c;在这个时机中是可以操作制品的。 …
阅读更多...
Unity 解决QFramework WebGL报错

Unity 解决QFramework WebGL报错

Unity 解决QFramework WebGL报错&#x1f95d;错误描述☕原因&#x1f364; 解决方案&#x1f95d;错误描述 在新建工程中只导入了QFramework&#xff0c;Build WebGL(空场景) 会看到如下错误&#xff1a; Exception: Non-Public Constructor() not found! in QFramework.Saf…
阅读更多...
点云 3D 目标检测 - SECOND（Sensors 2018）

点云 3D 目标检测 - SECOND（Sensors 2018）

点云 3D 目标检测 - SECOND&#xff08;Sensors 2018&#xff09;摘要1. 引言2. 相关工作2.1 基于前视图和图像的方法2.2 基于鸟瞰图的方法2.3 基于3D的方法2.4 基于融合的方法3. SECOND检测器3.1 网络架构3.1.1 点云分组3.1.2 Voxelwise特征提取器3.1.3 稀疏卷积中间提取器3.1…
阅读更多...
代码模板3---基础算法(双指针算法/位运算/离散化/区间合并)

代码模板3---基础算法(双指针算法/位运算/离散化/区间合并)

①双指针算法 一般做题&#xff1a;先用暴力做法&#xff0c;然后去看是否存在某种性质&#xff08;如单调性&#xff0c;维护这个区间的单调性即可&#xff09; AcWing 799. 最长连续不重复子序列 - AcWing AcWing 800. 数组元素的目标和 - AcWing AcWing 2816. 判断子序列 - …
阅读更多...
期货交易软件哪个好？为什么选择期货MT4平台软件？

期货交易软件哪个好？为什么选择期货MT4平台软件？

越来越多人选择期货投资&#xff0c;因为期货投资具有高投资高回报的特征。在做期货交易时&#xff0c;很多投资者会发现市场上有各种各样的期货交易软件。如果第一次接触期货交易&#xff0c;难免会不知道选择哪个期货交易软件更好。下面为大家讲讲期货交易软件哪个好&#xf…
阅读更多...
centos7安装rabbitmq集群

centos7安装rabbitmq集群

公司号口项目让运维安装rabbitmq&#xff0c;结果rabbitmq页面state都显示down了&#xff0c;问运维居然说都正常&#xff0c;麻蛋欺负我无知&#xff0c;自己搞一遍试试。 前言 RabbitMQ是一个开源的强大的企业消息系统&#xff0c;支持主流的操作系统&#xff0c;支持多种开…
阅读更多...
OpenHarmony#深入浅出学习eTs#（七）判断密码是否正确

OpenHarmony#深入浅出学习eTs#（七）判断密码是否正确

本项目Gitee仓地址&#xff1a;深入浅出eTs学习: 带大家深入浅出学习eTs (gitee.com) 一、基本界面 本项目基于#深入浅出学习eTs#&#xff08;四&#xff09;登陆界面UI&#xff0c;继续进行&#xff0c;实现一个判断的功能 二、控件介绍 TextInput 可以输入单行文本并支持…
阅读更多...
如果我是核酸系统架构师，我会这么用MQ。。。

如果我是核酸系统架构师，我会这么用MQ。。。

V-xin&#xff1a;ruyuan0330 获得600页原创精品文章汇总PDF 目录 一、前情提示二、保证投递消息不丢失的confirm机制三、confirm机制的代码实现四、confirm机制投递消息的高延迟性五、高并发下如何投递消息才能不丢失六、消息中间件全链路100%数据不丢失能做到吗&#xff1f;…
阅读更多...
医学图像包——DCMTK、VTK、ITK、RTK、SimpleITK

医学图像包——DCMTK、VTK、ITK、RTK、SimpleITK

1.ITK-医学图像处理软件包 ITK&#xff08; Insight Segmentation and Registration Toolkit&#xff09;是美国国家卫生院下属的国立医学图书馆开发的一款医学图像处理软件包&#xff0c;是一个开源的、跨平台的影像分析扩展软件工具。 ITK的开发过程中采用了先进的多模态数…
阅读更多...
VAE详解及PyTorch代码

VAE详解及PyTorch代码

三大有名的生成模型VAE、GAN以及Diffusion Model 其余两篇 看了网上的一些博客&#xff0c;大多都写到了重点&#xff0c;也就是后面的公式推导部分&#xff0c;可是大部分只有推导过程&#xff0c;很少有讲明白为什么要这么假设&#xff0c;我看的时候内心不断有个疑问&…
阅读更多...
这篇文章详细介绍动态内存管理 ，让你醍醐灌顶【c语言】

这篇文章详细介绍动态内存管理 ，让你醍醐灌顶【c语言】

文章目录动态内存函数mallocfreecallocrealloc常见的动态内存错误对NULL指针的解引用操作对动态开辟空间的越界访问对非动态开辟内存使用free释放使用free释放一块动态开辟内存的一部分对同一块动态内存多次释放动态开辟内存忘记释放&#xff08;内存泄漏&#xff09;练习柔性数…
阅读更多...
物联网终端的信息保护

物联网终端的信息保护

针对漏洞的恶意行为分析 我们共捕获到 4 种针对 UPnP 漏洞的利用行为 1&#xff0c;如表 4.7 所示。从中可以看出&#xff0c;这些漏洞均为远程 命令执行类漏洞。另外我们也发现&#xff0c;当漏洞出现在特定端口时&#xff0c;攻击者一般不会经过 UPnP 的发现阶段&#xff0c…
阅读更多...
Moran指数分析

Moran指数分析

Moran指数分析 Moran指数&#xff08;莫兰指数&#xff09;是研究空间关系的一种相关系数值&#xff0c;比如研究中国31省市GDP之间是否具有空间相关关系。Moran指数通常分为两种&#xff0c;分别是全局Moran指数和local局部Moran指数。全局Moran指数用于分析整体上是否存在空…
阅读更多...
概率分布到底有什么用？

概率分布到底有什么用？

1.1 要概率分布有什么用&#xff1f; 个人理解&#xff1a;每种概率分布对应描述了某种特定事件发生的规律&#xff0c;像是一个模板&#xff0c;只要某种事件符合该分布的要求&#xff0c;那么就可以用对应的概率分布计算此事件的概率 1.2 为什么非要确定一个分布&#xff1f;…
阅读更多...
计算机组成原理复习题

计算机组成原理复习题

一、选择题 一个节拍信号的宽度是指______。 A. 指令周期 B. 存储周期 C. 机器周期 D. 时钟周期 我的答案: D正确答案: D 3.3分 2. (单选题) 中断向量地址是______。 A. 子程序入口地址 B. 中断服务子程序出口地址 C. 中断返回地址 D. 中断服务子程序入口地址 我的答案: D正…
阅读更多...
SpringCloudAlibaba、SpringCloud版本和SpringBoot版本适配

SpringCloudAlibaba、SpringCloud版本和SpringBoot版本适配

本文继SpringCloud版本和SpringBoot版本适配后&#xff0c;加入SpringCloudAlibaba组件版本适配&#xff01; 官网链接&#xff1a;https://github.com/alibaba/spring-cloud-alibaba/wiki/
阅读更多...
MySQL基本用法

MySQL基本用法

一、数据库的基本操作&#xff1a; 1、启动数据库&#xff1a;net start mysql; 2、进入数据库&#xff1a;mysql -h localhost -u root -p; 3、关闭数据库服务&#xff1a;net stop mysql; 4、查看数据库&#xff1a;show databases; 5、新建数据库&#xff1a;create databa…
阅读更多...
[vue element-ui]JAVA POST请求

[vue element-ui]JAVA POST请求

01.前端 <!DOCTYPE html> <html><head><meta charset"UTF-8"><title></title><script type"text/javascript" src"js/jquery-3.4.1.min.js"></script><script type"text/javascript&qu…
阅读更多...
Raft论文翻译(5.4.2)——安全性-提交之前term的日志entry

Raft论文翻译(5.4.2)——安全性-提交之前term的日志entry

5.4.2 Committing entries from previous terms 提交之前term的日志entry As described in Section 5.3, a leader knows that an entry from its current term is committed once that entry is stored on a majority of the servers. If a leader crashes before committin…
阅读更多...
linux 分析启动时服务时间消耗

linux 分析启动时服务时间消耗

工具systemd-analyze systemd-analyze是一个分析启动性能的工具&#xff0c;用于分析启动时服务时间消耗。 1 systemd-analyze使用 1.1 查看启动耗时 rootloongson-pc:/# systemd-analyze 1.2 查看每个服务的启动耗时 rootloongson-pc:/# systemd-analyze blame 1.3 显…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023