javaSE 注释和反射

原创

阿哲

发布于 2022-03-14 09:35:00

2310

发布于 2022-03-14 09:35:00

文章被收录于专栏：阿哲学习笔记

一.注解

1.什么是注解

Annotation是从JDK5.0开始引入的概念

eg：@override 重写的注解

1.不是程序本身给程序作出解释（）
2.可以被其他程序读取
非必须
3.格式：@注释+注释名，还可以加一些参数值
4.有检查和约束的作用
可以放在方法或者类等等上面

…..注释是给人看的,注解是给人和机器看的

2.内置注解

@override 指示方法声明旨在覆盖超类型中的方法声明。 @Deprecated 已过时不推荐使用的代码 @SuppressWarnings 镇压警告（可以放入参数）

3.元注解

作用：负责注解其他注解 4个标准的meta-annotation类型：

@Target 被描述的注解可以用在什么地方 java @Target(value =ElementType.METHOD) 说明作用域在方法上 @Target(ElementType.FIELD) 作用域在属性上（成员变量） @Target(value ={ElementType.METHOD,ElementType.TYPE}) 说明作用域在方法和类上
@Retention 表示需要在什么级别保存注释信息（一般都写RUNTIME）表示我们的注释在什么地方还有效 java @Retention(value =RetentionPolicy.RUNTIME)
@Documented 是否我们的注解生成在JAVAdoc中
@Inherited 表示子类能继承父类该注解4.自定义注解
使用@interface自定义注解时，自动继承注解接口
写在注解里的参数格式：参数类型 + 参数名（）；
default 设默认值注解显示赋值，如果没有默认值，我们必须赋值 java @interface MyAnnotion{ string name() default "" int id() default -1 //一般负一代表不存在 } @interface MyAnnotion2{ string value() } @MyAnnotion2("abc") //只有一个且名字是value时这样等价于 (value="'abc'") public viod test(){ } 二.反射 1.概念 Java（静态语言）被视为准动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 private 里的也可以操作

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象) ，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射

正常方式: 引入需要的”包类”名称一> 通过new实例化—>取得实例化对象反射方式:实例化对象一> getClass)方法—>得到完整的“包类”名称

2.class类的创建方式

java

public class test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person =new Student();
        System.out.println("这个人是："+person.name);
        //通过对象获得
        Class c1 = person.getClass();
        //forname获得
        Class c2 = Class.forName("lesson05.Student");
        //通过类名.class获得
        Class c3 = Student.class;
        
        //获得父类类型
        Class c5 = c1.getSuperclass();
    }

    
    
}

class Person{
   public String name;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student() {
       this.name="学生";
    }
}

class Teacher extends Person{
    public Teacher() {
        this.name="老师";
    }
}

3.那些类型有Class对象

java

public class test04 {
    public static void main(String[] args) {
        Class objectClass = Object.class;//类
        Class comparableClass = Comparable.class;//接口
        Class aClass = String[].class;//一维数组
        Class aClass1 = int[][].class; //二维数组
        Class overrideClass = Override.class;//注解
        Class elementTypeClass = ElementType.class; //枚举
        Class  integerClass = Integer.class;//基本数据类型
        Class voidClass = void.class;//void
        Class classClass = Class.class;//Class
    }
}

4.分析类初始化

(1.) 类的主动引用(一定会发生类的初始化)

当虚拟机启动，先初始化main方法所在的类
new 一个类的对象
调用类的静态成员(除了final常量)和静态方法
使用java.lang.reflect包的方法对类进行反射调用
当初始化一个类,如果其父类没有被初始化，则先会初始化它的父类 (2.)类的被动引用(不会发生类的初始化)
当访问一个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化
通过数组定义类引用，不会触发此类的初始化
引用常量（final）不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了) java public class test05 { public static void main(String[] args) throws ClassNotFoundException { System.out.println("main调用"); //(1.) 类的主动引用(一定会发生类的初始化) ///zi son = new zi(); //System.out.println(Fu.b); // Class.forName("lesson05.zi"); //Class.forName("lesson05.Fu"); //(2.)类的被动引用(不会发生类的初始化) //System.out.println(zi.b); //zi[] zis = new zi[5]; //System.out.println(zi.m); } } class Fu { static int b=2; static { System.out.println("父类被调用"); } } class zi extends Fu{ final static int m=0; static { System.out.println("子类被调用"); } }

补充：

1.static方法

　　static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

　　但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。

2.static变量

　　static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

　　static成员变量的初始化顺序按照定义的顺序进行初始化。

3.static代码块

　　static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

4.static作用于成员变量用来表示只保存一份副本，final的作用是用来保证变量不可变

5.类加载内存分析

20211201120121

测试代码：

20211201125030

运行结果：

20211201125036

分析：

20211201120508

20211201124815

注意：静态代码块和静态变量执行的先后顺序取决于代码编写的顺序 在时完成

image-20211201130716568

image-20211201132233921

6.类加载器

引导类加载器

none

引导类加载器:用C++编写的， 是JVM自带的类
加载器，负责Java平台核心库（rt.jar），用来装载核心类
库。该加载器无法直接获取

扩展类加载器

none

扩展类加载器:负责jre/ib/ext目录下的jar包或-
D java.ext.dirs指定目录下的jar包装入工作库

系统类加载器

none

系统类加载器:负责java - classpath或-D
java.class. path所指的目录下的类与jar包装入工
作库，是最常用的加载器

7.获取运行时类的完整结构

java

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

//获取类的信息
public class test06 {
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
        USer uSer = new USer();
        Class c1 = uSer.getClass();
        //获取类的名字
        System.out.println(c1.getName());

//        //获得类的属性
//        System.out.println("===========================================");
//        Field[] fields = c1.getFields(); //只能找到public属性
//        for (Field field : fields) {
//            System.out.println(field);
//        }
//        System.out.println("===========================================");
//        Field[] fields1 = c1.getDeclaredFields();//找到全部属性
//        for (Field field : fields1) {
//            System.out.println(field);

        //获得指定属性
            System.out.println("===========================================");
            System.out.println(c1.getDeclaredField("name"));

        //获得类的方法
            System.out.println("===========================================");
            Method[] methods = c1.getMethods();  //本类及父类所有方法
        
            for (Method method : methods) {
                System.out.println("正常的："+method);
            }
            System.out.println("===========================================");
            Method[] declaredMethods = c1.getDeclaredMethods();//本类的所有方法
        
            for (Method declaredMethod : declaredMethods) {
                System.out.println("getDeclaredMethods的："+declaredMethod);
        }
        //获得指定方法
        //可能会发生重载 所以要传入参数 丢进去一个类型就可以了
            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("===========================================");
            Constructor[] constructors = c1.getConstructors();//本类public构造方法
        
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }

            System.out.println("===========================================");
            Constructor[] constructors1 = c1.getDeclaredConstructors(); //本类全部构造方法
        
            for (Constructor constructor1 : constructors1) {
                System.out.println(constructor1);
            }

        //获得指定构造器
            System.out.println("===========================================");
            System.out.println(c1.getConstructor(String.class, int.class, int.class));


    }
}

7. 动态创建对象执行方法

其中没有参数的给null

java

//通过反射，动态创建对象
public class test07 {
    public static void main(String[] args) throws Exception {
        //获得class对象
        Class c1 = Class.forName("lesson05.USer");

        //构造对象
        USer user = (USer) c1.newInstance();//本质调用了无参构造器
        System.out.println(user);

        //通过构造器创建对象
        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
        USer user2  = (USer) constructor.newInstance("dongGEi", 01, 18);
        System.out.println(user2);

        //通过反射调用普通方法
        USer user3 = (USer) c1.newInstance();
        //通过反射获得方法
        Method setName = c1.getMethod("setName", String.class);
        setName.invoke(user3,"abcd"); //invoke 激活，给user3这个对象 参数是abcd
        System.out.println(user3);
        //通过反射操作属性
        USer user4 = (USer) c1.newInstance();
        Field name = c1.getDeclaredField("name");
            //不能直接操作私有属性，需要先关闭安全检测，属性和方法都是setAccessible(true)
        name.setAccessible(true);//设置权限
        name.set(user4,"abcd222");
        System.out.println(user4);

    }
}

8.性能对比

普通方法 new User 出来的进行set get等等操作
反射方法 uesr.getClass 然后获得方法然后invoke
关闭权限检测的反射调用加一个setAccessible（true）

速度普通>关闭权限检测的反射>反射方法

需要反射时可以关闭权限检测提高速度

9.反射获取泛型信息

image-20211201151837962

解释上面代码：test01 是一个参数为Map和List的方法，

反射拿到这个方法然后获得参数列表

遍历参数列表然后参数类型是参数化类型（加<>的；泛型）的强转成参数化类型

再遍历拿到真真实参数

（口语化有点绕=.=）

10. 反射获取注解信息

ORM对象关系映射

◆类和表结构对应

◆属性和字段对应

◆对象和记录对应

要求:利用注解和反射完成类和表结构的映射关系

image-20211202082253348

先看下面再看psvm

java

package test;

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

public class Test {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("test.Student");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解value的值
        //获得指定注解 传进注解的class
        TableDong tableDong = c1.getAnnotation(TableDong.class);
        String value = tableDong.value();
        System.out.println(value);

        //获得指定属性 （成员变量）
        Field f = c1.getDeclaredField("name");
        //获得属性上的 指定注解 取出注解的值
        FieldDong fieldDong = f.getAnnotation(FieldDong.class);
        System.out.println(fieldDong.columName());
        System.out.println(fieldDong.length());
        System.out.println(fieldDong.type());
        System.out.println("---------------");

        f = c1.getDeclaredField("id");
        //获得指定注解
        fieldDong = f.getAnnotation(FieldDong.class);
        System.out.println(fieldDong.columName());
        System.out.println(fieldDong.length());
        System.out.println(fieldDong.type());
    }
}
@TableDong("db_student")
class Student{
    @FieldDong(columName = "db_id",type = "varchar",length = 10)
    private String id;
    @FieldDong(columName = "db_age",type = "int",length = 3)
    private int age;
    @FieldDong(columName = "db_name",type = "varchar",length = 10)
    private String name;

    public Student() {
    }

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

    public String getId() {
        return id;
    }

    public void setId(String 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 "Student{" +
                "id='" + id + '\'' +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableDong{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldDong{
    String columName(); //列名（不是学生名）
    String type();
    int length();
}