JAVA语言学习-Day9

learnJava注解&反射

参考教学视频：秦疆

  • 注解：Annotation

  • 注释：comment

1.注解

 

Annotation是java1.5引入的新技术

  • Annotation的作用

    • 不是程序本身，可以对程序做出解释（这一点和注释没有什么区别）

    • 可以被其他程序（如：编译器等）读取

  • Annotation的格式

    • 注解是以"@注释名"在代码中存在的，还可以添加一些参数值。例如：@SuppressWarnings(value="unchecked")

  • Annotation可以在哪里使用

    • 可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制变成实现这些元数据的访问

1.1内置注解

@Override：定义在java.lang.Override中，只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明

@Deprecated：定义在java.lang.Deprecated中，可用于修饰方法、属性、类，表示不鼓励程序员使用这样的元素，通常是它很危险或存在更好的选择

@SuppressWarning：定义在java.lang.SuppressWarning中，用来抑制编译时的警告信息,需要添加一个参数才能正确的使用，参数：

  1. @SuppressWarning("all")

  2. @SuppressWarning("unchecked")

  3. @SuppressWarning("unchecked","deprecation")等等

1.2元注解

元注解的作用就是负责解释其他注解，JAVA定义了4个标准的meta-annotation

  • 这些注解和它们所支持的类在java.lang.annotation包中可以找到

  1. @Target：用于描述注解的使用范围

  2. @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期

    • source<class<Runtime

  3. @Document：说明该注解将被包含在javadoc中

  4. @Inherited：说明子类可以集成父类中的该注解

1.3自定义注解

//自定义注解
public class TestAnnotation {
    //注解可以显示默认值，如果没有则必须赋值
    @MyAnnotation(name="测试",school={"测试1","测试2"})
    public void test() {}
}
​
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //如果只有一个值建议value
    //注解的参数：参数类型+参数名（）
    String name() default "";
    int age() default 0;
    int id() default -1;//如果默认值为-1，代表不存在，如果indexof找不到，就返回-1
    String[] school();
}

2.反射

  • 动态语言

是一类在运行时可以改变其结构的语言。通俗来讲就是就是运行时，代码可以根据某些条件改变自身结构

主要动态语言：Object-c、C#、JavaScript、PHP、Python等

  • 静态语言

与动态语言相对，运行时结构不可变的就是静态语言。如Java、c、c++

java不是动态语言，但是java可以称之为“准动态语言”。即java有一定的动态性，可以利用反射机制获得类似动态语言的特性。

  • Reclection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期间借助Reflection Api取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

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

正常方式：引入需要的“包类”名称->通过new实例化->获得实例化对象

反射方式：实例化对象->getClass()方法->获得完整的包类名称

2.1获得Class类的几种方式

    //通过反射获取class类对象
    Class c1 = Class.forName("com.stujc.reflect.User");
    //通过对象获得class类对象
    User u = new User();
    Class c2 = u.getClass();
    //通过类名直接获得
    Class c3 = User.class;
    //基本内置类型的包装类都有一个Type属性
    Class c5 = Integer.TYPE;
    //一个类在内存中只有一个class对象
    //一个类被加载后，类的整个结构都会被封装在Class对象中
    Class c4 = Class.forName("com.stujc.reflect.User");
    //获取父类类型
    Class c6 = c1.getSuperclass();

2.2有Class对象的类型

  • class:外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类

  • interface：接口

  • []：数组

  • enum：枚举

  • annotation：注解@interface

  • primitive type：基本数据类型

  • void

2.2.1 内存分析

  1. 加载：将class字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.class对象

  2. 链接：将Java的二进制代码合并到JVM的运行状态之中的过程

    • 验证：确保加载的类符合JVM的规范，没有安全方面的问题

    • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些变量都将在方法区中进行分配

    • 解析：虚拟机常量池内的符号引用（常量名）替换为直接应用（地址）的过程

  3. 初始化

    • 执行类构造器<clinit>()方法的过程。类构造器方法是由编译器自动收集类中所有类变量的赋值和静态代码块中的语句合并产生的。

    • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需先触发其父类的初始化

    • 虚拟机会保证一个类的<clinit>()方法在多线程的环境中被正确加锁和同步

2.2.2 类的初始化

什么时候会发生类的初始化

  • 主动引用（一定会发生类的初始化）

    • 当虚拟机启动，先初始化main方法所在的类

    • new一个类的对象

    • 调用类的静态成员（除了final常量）和静态方法

    • 调用java.lang.reflect包的方法对类进行反射调用

    • 当初始化一个类，如果其父类没有被初始化，则会先初始化他的父类

  • 类的被动引用（不会发生类的初始化）

    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化

    • 通过数组定义类引用，不会触发此类的初始化

    • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

2.2.3 类加载器的作用

  • 类加载的作用：将class字节码文件内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.class对象，作为方法区中类数据的访问入口

  • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收期可以回收这些Class对象

  1. 引导类加载器

  2. 扩展类加载器

  3. 系统类加载器

//获取系统类加载器
ClassLoader c = ClassLoader.getSystemClassLoader();
System.out.println(c);
//获取系统类加载器父类的加载器->拓展类加载器
ClassLoader c1 = c.getParent();
System.out.println(c1);
//获取拓展类加载器父类的加载器->根加载器(C/C++)
ClassLoader c2 = c1.getParent();
System.out.println(c2);
//获取系统类加载器可以加载的路径
System.out.println(System.getProperty("java.class.path"));

2.3获取运行时类的完整结构

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

Field、Method、Constructor、Superclass、Interface、Annotation

        Class c1 = Class.forName("com.stujc.reflect.User");
//      User uc = new User();
//      c1 = uc.getClass();
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());
        Field[] fs = c1.getFields();//只能查看public属性
        fs = c1.getDeclaredFields();//可以查看所有属性
        Method[] ms = c1.getMethods();//获得本类及父类所有的public方法
        ms = c1.getDeclaredMethods();//获得本类的所有方法
        Constructor[] cs = c1.getConstructors();//获得本类的public构造方法
        cs = c1.getDeclaredConstructors();//获得本类所有的构造方法

2.4动态创建对象，执行方法

        Class c1 = Class.forName("com.stujc.reflect.User");
        User u1 = (User)c1.newInstance(); //本质上是调用了类的无参构造器，没有无参构造报错,访问权限需要足够
        Constructor c2 = c1.getConstructor(String.class,int.class,int.class);
        User u2 = (User)c2.newInstance("测试",001,28); //通过构造器创建对象
        //通过反射操作方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(u2, "啊啊");
        System.out.println(u2.getName());
        //通过反射操作属性
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);//关闭程序的安全检测
        name.set(u1, "劳资天下第一！");
        System.out.println(u1.getName());

2.5性能对比

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

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

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

    • 提高反射的效率，如果代码中必须用反射，而该句代码需要频繁的调用，那么设置为true

    • 使得原本无法访问的私有成员也可以访问

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

2.6其他

2.6.1 获取泛型信息

  • Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是一旦编译成功，所有和泛型有关的类型全部擦除

  • 为了通过反射操作这些类型，Java新增了ParameterizedType、GenericArrayType、TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型，但是又和原始类型齐名的类型

  • ParameterizedType：表示一种参数化类型，比如Collection<String>

  • GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型

  • TypeVariable：是各种类型变量的公共父接口

  • WildcardType：代表一种通配符类型表达式

public class TestOther01 {
    public void test01(Map<String,User> map,List<User> list) {}
    public Map<String,User> test02(){return null;}
    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
        Method m1 = TestOther01.class.getMethod("test01", Map.class,List.class);
        Type[] ts = m1.getGenericParameterTypes();
        for(Type t:ts) {
            System.out.println("#"+t);
            if(t instanceof ParameterizedType) {
                Type[] ts1 = ((ParameterizedType)t).getActualTypeArguments();
                for (Type t1 : ts1) {
                    System.out.println("$"+t1);
                }
            }
        }
        
        Method m2 = TestOther01.class.getMethod("test02", null);
        Type t2 = m2.getGenericReturnType();
        System.out.println("="+t2);
        if(t2 instanceof ParameterizedType) {
            Type[] ts2 = ((ParameterizedType)t2).getActualTypeArguments();
            for(Type t3:ts2) {
                System.out.println("*"+t3);
            }
        }
    }
}

2.6.2 获取注解信息

  • ORM:Object relationship Mapping -->对象关系映射

    • 类和表结构对应

    • 属性和字段对应

    • 对象和记录对应

public class TestOther02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
        Class c1 = Class.forName("com.stujc.reflect.Student");
        //通过反射获得注解
        Annotation[] ans = c1.getAnnotations();
        for(Annotation a:ans) {
            System.out.println(a);
        }
        //获得注解的value的值
        TableTest t = (TableTest)c1.getAnnotation(TableTest.class);
        System.out.println(t.value());
        //获得类指定的注解
        Field f = c1.getDeclaredField("name");
        FieldTest01 f01 = f.getAnnotation(FieldTest01.class);
        System.out.println(f01.columnName()+" "+f01.type()+" "+f01.length());
    }
}
​
@TableTest("db_student")
class Student{
    @FieldTest01(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FieldTest01(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FieldTest01(columnName = "db_age",type = "varChar",length = 3)
    private String name;
    
    public Student() {
        super();
    }
    public Student(int id, int age, String name) {
        super();
        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 "Student [id=" + id + ", age=" + age + ", name=" + name + "]";
    }
}
​
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableTest{
    String value();
}
​
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldTest01{
    String columnName();
    String type();
    int length();
}
 

 

posted @ 2024-04-12 15:09  孟秋廿六  阅读(33)  评论(0)    收藏  举报