【无标题】

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量51 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73856881/article/details/130451086
版权

Java注解和反射笔记

什么是注解

Java.Annotation–JDK5.0开始引入的技术

作用：不是程序本身，但是可以对程序作出解释

​ 可以被其他程序读取解释

格式：@+注解名。还可以添加参数值

在哪里：package/class/method/field，相当于给这些部分添加了额外的辅助信息

​ 通过反射机制来访问这些信息

内置注解

@Override—重写，会自动检查方法签名

@Deprecated–不推荐程序员使用、现在已经被弃用

@SupressWarning–镇压警告，带参数的

元注解

作用 负责注解其他注解，Java定义了四个meta- annotation类型，它们被用来提供对其它annotation类型作说明

在java.lang.annotation包中可以找到（@Target，@Retention，@Documented，@Inherited）

@Target 用于描述注解的使用范围（被描述的注解可以用在什么地方）

@Retention 表示需要在什么级别保存该注解信息，用于描述注解的生命周期（SOURCE<CLASS<RUNTIME）

@Documented 说明该注解将被包含在javadoc中

@Inherited 说明子类可以继承父类中的该注解

定义一个注解

import java.lang.annotation.*;

public class test0 {
    //测试元注解
    @MyAnnotation
    public void test(){

    }

}
//target表示我们的注解可以用在什么地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//retention表示注解的有效期，也就是生命周期
//runtime>class>source
@Retention(value = RetentionPolicy.RUNTIME)
//documented表示是否将当前自定义的注解生成在JAVAdoc中
@Documented
//Inherited表示子类可以继承父类的注解
@Inherited
@interface MyAnnotation{

}

自定义注解

  • 使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

  • 分析

    • @interface用来声明一个注解，格式：public @ interface 注解名 {定义内容}

    • 其中的每一个方法实际上是声明了一个配置参数

    • 方法的名称就是参数的名称

    • 返回值类型就是参数的类型（返回值只能是基本类型，Class String enum）

    • 可以通过default来声明参数的默认值

    • 如果只有一个参数成员，一般参数名为value

    • 注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值

      package test111;


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

//自定义注解
public class test03 {

    //注解可以显示赋值，如果没有默认值就一定要在注解的括号内赋值
    @MyAnnotation2(name = "zzy",schools = {"北京交通大学"})
    public void test(){

    }


    @MyAnnotation3("曾子源")
    public void test1(){

    } 

}
@Target(value = {ElementType.TYPE,ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)

@interface  MyAnnotation2{
    //注解的参数：参数类型+参数名（）；
    String name() default "";
    int age() default 0;

    int id() default  -1;//默认值为-1，代表不存在

    String [] schools() default {"山西大学","北京交通大学"};

}
@Target(value = {ElementType.TYPE,ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();
    
}

反射

反射概述

通过反射机制可以让java变化为一个准动态语言

（创建对象：new clone 反射）

动态语言

是一类在运行时根据某些条件可以改变其结构的语言：Object-C C# JS PHP PYTHON

静态语言

运行时结构不可以改变

Java Reflection

反射时Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息

并能直接操作任意对象的内部属性及方法

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

加载完类之后，在堆内存的方法区就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。通过这个Class类对象看到原本类的结构的这个过程，就叫做反射。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SkaD7aFv-1682856456446)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430133352858.png)]

优缺点

adv：可以实现动态创建对象和编译，体现出很大的灵活性

dis：对性能影响大。反射是一种解释操作，慢于直接执行相同的操作

获取反射对象

package test111;


//什么是反射
public class test001 {
    //通过反射获取类的Class对象
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("test111.User");
        Class c2 = Class.forName("test111.User");
        Class c3 = Class.forName("test111.User");
        Class c4 = Class.forName("test111.User");

        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());


    }
}

//实体类 pojo , entity
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

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

得到Class类的几种方式

Class类

对象通过照镜子（反射、getClass）得到的信息：某个类的属性、方法和构造器、某个类实现了哪些接口。

对于每个类，JRE都为其保留一个不变的（final）Class类型的对象。一个Class对象包含了特定某个结构的有关信息。

  • Class本身是一个类
  • Class对象只能由系统建立
  • 一个加载的类在JVM中只会又一个Class实例
  • 每个类的实例都会记得自己是由哪个Class实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何想动态加载、运行的类，都必须先获得相应的Class对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-84lXEgnM-1682856456447)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430135141811.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8CcR8ubP-1682856456447)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430135215438.png)]

package test111;


//测试CLass类的创建方式
public class test0001 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println(person.name);

        //方式一：通过对象获得（getClass方法）
        Class c1 = person.getClass();

        //方式二：forName获得
        Class c2 = Class.forName("test111.Student");

        //方式三：通过xx.class获得
        Class c3 = Student.class;

        //方式四：基本内置类型的包装类都有一个TYPE属性
        Class c4 = Integer.class;

        //通过hashcode判断是不是一样的
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());

        //获得父类类型
        Class c5 = c1.getSuperclass();
        Class c6 = Teacher.class.getSuperclass();

        System.out.println(c5.hashCode());
        System.out.println(c6.hashCode());
    }
}


class Person{
    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 = "老师";
    }

}

所有类型的Class对象

  • class：外部类，成员，局部内部类，匿名内部类
  • interface
  • []：数组
  • enum
  • annotation
  • primitive type
  • void
package test111;


import java.lang.annotation.ElementType;

//测试所有类型的Class对象
public class test1231 {
    public static void main(String[] args) {
        Class c1 = Object.class; //类
        Class c2 = Comparable.class; //接口
        Class c3 = String[].class;  //一维数组
        Class C4 = int[][].class; //二维数组
        Class c5 = Override.class; //注解
        Class c6 = ElementType.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);
    }
}

类加载内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VySUeZQR-1682856456447)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430144018900.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SABNN1nN-1682856456447)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430144056632.png)]

类的加载和ClassLoader的理解

加载：

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

链接：

​ 将Java类的二进制代码合并到JVM的运行状态之中的过程

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

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

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

初始化：

​ 1.类构造器( )方法，构造类信息

​ 2.如果父类还没有初始化，就需要先触发其父类的初始化

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

//类加载
public class test06 {
    public static void main(String[] args) {
        K k = new K();
        System.out.println(K.m);
      /*
      1.加载到内存，会产生一个类对应的Class对象
      2.链接，链接结束后m = 0
      3.初始化：
      		<clinit>(){
      					System.out.println("K类静态代码块初始化");
      					m = 300
      					System.out.println("K类的无参构造初始化");
      					m = 100
      		}
      */
    }
}
class K{
    static {
        System.out.println("K类静态代码块初始化");
        m = 300;
    }
    static  int m = 100;
    public  K(){
        System.out.println("K类的无参构造初始化");
    }

}

分析类初始化

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

  • 当虚拟机驱动，先初始化main方法所在的类
  • new一个类的对象
  • 调用类的静态成员（除了final和常量）和静态方法
  • 使用java.lang,reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类没有被初始化，则先初始化父类

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

  • 当访问一个静态域，只有真正声明这个域的类才会被初始化。如：通过子类引用父类的静态变量，不会导致子类初始化
  • 通过数组定义类引用，不会触发此类的初始化
  • 引用常量不会触发此类的初始化
package test111;


//测试类什么时候会被初始化
public class test07 {
    static {
        System.out.println("Main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1·主动引用
        //Son son = new Son();

        //2·反射也会产生主动引用
        //Class c1 = Class.forName("test111.Son");

        //3·不会产生类引用的方法
        // System.out.println(Son.b);//通过子类调用父类的静态变量或者方法，不会初始化子类

        //Son [] array = new Son[5]; // 数组只是申请了一些空间
        //System.out.println(Son.M);  //子类调用常量，但是常量在链接阶段就在常量池中，并不需要加载子类
    }
}
class Father{
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

类加载器

类加载器的作用

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QUgZgaLP-1682856456448)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430151329676.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MuZDAoeP-1682856456448)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430151436702.png)]

public class test08 {
    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++)
        ClassLoader root = systemClassLoader.getParent().getParent();
        System.out.println(root);

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

        //测试JDK内置的类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);
      
      	//如何获取系统类加载器可以加载的路径
        System.out.println("你可以加载："+System.getProperty("java.class.path"));
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BggqnQwM-1682856456448)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430152152206.png)]

获取运行时类的完整结构

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

Field、Method、Constructor、Superclass、Interface、Annotation

  • 实现的全部接口
  • 所继承的父类
  • 全部的构造器
  • 全部的方法
  • 全部的field
  • 注解
  • …
package test111;


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

//获得类的信息
public class test09 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("test111.User");
        //获得类的名字
        System.out.println(c1.getName());       //获得包名+类名
        System.out.println(c1.getSimpleName());  //获得类名

        //获得类的属性
        System.out.println("----------------- ");
        Field[] fields = c1.getFields();    //只能找到public
        fields = c1.getDeclaredFields();    //能找到所有的
        for (Field field : fields) {
            System.out.println(field);
        }
        //获得指定属性的值
        System.out.println("----------------- ");
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
        //获得类的方法
        System.out.println("----------------- ");
        Method[] methods = c1.getMethods();  //获得本类和父类的全部public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        methods = c1.getDeclaredMethods();    //获得本类的所有方法
        for (Method method : methods) {
            System.out.println(method);
        }

        //获得指定的方法
        //需要参数是因为重载
        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();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        //获得指定的构造器
        Constructor constructor =  c1.getConstructor(String.class,int.class,int.class);
        System.out.println(constructor);
    }
}

总结

  • 在实际的操作中，取得类的信息的操作代码，并不会经常开发
  • 一定要熟悉java.lang.reflect包的作用，反射机制
  • 如何取得属性、方法、构造器的名称、修饰符等

有了Class对象可以做什么

1.创建类的对象：调用Class对象的newInstance方法

​ 类必须有一个无参数的构造器

​ 类的构造器的访问权限要足够

2.如果不调用无参的构造器，还可以：(本质上都是构造)

​ （1）通过Class类的getDeclaredConstructor（）取得本类的指定形参类型的构造器

​ （2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需要的各个参数

​ （3）通过Constructor实例化对象

3.调用指定的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZvYEcHl8-1682856456448)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430184909176.png)]

Object invoke(Object obj, Object… args)

  • Object对应原方法的返回值，若原方法无返回值，此时返回null
  • 若原方法为静态方法，此时形参Object obj可为null
  • 若原方法形参列表为空，则Object[] args为null
  • 若原方法声明为private，则需要在调用此invoke方法前，显示调用方法对象的setAccessible（true）方法，就可以访问private方法
  • 4.通过反射操作属性
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GlnpjpMF-1682856456449)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430184733531.png)]
package test111;

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

//动态的创建对象，通过反射
public class test10 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得完Class对象
        Class c1 = Class.forName("test111.User");

        //构造一个对象
        User user = (User) c1.newInstance(); //本质上是调用了无参构造器
        System.out.println(user.toString());

        //通过构造器创建对象
        Constructor constructor = c1.getConstructor(String.class,int.class,int.class);
        User user2 = (User) constructor.newInstance("九九",110,23);
        System.out.println(user2.toString());

        //通过反射调用普通方法
        User user3 = (User) c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke：激活
        //（对象，"方法的值"）
        setName.invoke(user3,"曾子源");
        System.out.println(user3.getName());

        //反射操作属性
        User user4 = (User) c1.newInstance();
        //通过反射获取一个属性
        Field name = c1.getDeclaredField("name"); //私有的也可以获取
        name.setAccessible(true); //关闭权限检测，因为不能直接操作私有属性
        name.set(user4,"源子曾");
        System.out.println(user4.getName());
    }
}

性能对比分析

package test111;

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

//分析性能问题
public class test11 {
    //普通方法调用
    public static void test01(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方法获取10亿次对象名字需要"+(endTime-startTime)+"ms");
    }

    //反射方式调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName",null);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方法获取10亿次对象名字需要"+(endTime-startTime)+"ms");
    }

    //反射方式i调用，关闭检测
    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName",null);
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("关闭检测后获取10亿次对象名字需要"+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        test01();
        test02();
        test03();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S76MqPFT-1682856456449)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430185918449.png)]

获取泛型信息

反射操作泛型

  • Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
  • 为了通过反射操作这些泛型，Java新增了ParameterizedType、GenericArrayType、TypeVariable、WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YMTNCGce-1682856456449)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430190524117.png)]

package test111;


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

//通过反射操作泛型
public class test12 {
    public void test01(Map<String,User> map, List<User> list){

    }

    public Map<String,User> test02(){
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        //获取泛型方法
        Method method =  test12.class.getMethod("test01", Map.class, List.class);
        //获取泛型方法的参数类型（参数列表、返回、异常）
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            //判断参数是否是ParameterizedType（结构化参数类型）
            if(genericParameterType instanceof ParameterizedType){
                //强制转换出来，调用getActualTypeArguments()获得真实信息
                Type[] actualTypeArguments = ((ParameterizedType)genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        System.out.println("==============================================");
        //获取第二个方法
        method =  test12.class.getMethod("test02",null);
        Type genericReturnType = method.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            //强制转换出来，调用getActualTypeArguments()获得真实信息
            Type[] actualTypeArguments = ((ParameterizedType)genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

获取注解信息

练习ORM

  • Object Relationship Mapping---->对象关系映射

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JPoXESgW-1682856456449)(/Users/cengziyuan/Library/Application Support/typora-user-images/image-20230430193114278.png)]

package test111;


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

//练习反射操作直接
public class test13 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("test111.Student2");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解中value的值
        TableZZY tableZZY = (TableZZY) c1.getAnnotation(TableZZY.class);
        String value = tableZZY.value();
        System.out.println(value);
        //获得类指定的注解
        Field field = c1.getDeclaredField("id");
        FieldZZY fieldZZY = field.getAnnotation(FieldZZY.class);
        System.out.println(fieldZZY.columName());
        System.out.println(fieldZZY.type());
        System.out.println(fieldZZY.length());
    }
}
@TableZZY("db_student")
class Student2{

    @FieldZZY(columName = "db_id",type = "int",length = 10)
    private int id;
    @FieldZZY(columName = "db_age",type = "int",length = 10)
    private int age;
    @FieldZZY(columName = "db_name",type = "varchar",length = 3)
    private String name;

    public Student2() {
    }

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



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

//属性的注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldZZY{
    String columName();
    String type();
    int length();
}
您可能认错人了ya
关注
C# winform中无标题栏窗口如何实现鼠标拖动？
汽车电子软件领域知识分享
08-23 1332
在C# winform中，可以通过重写窗体的鼠标事件来实现无标题栏窗体的拖动。
Qt-无标题窗口
学而思
05-21 7652
        今天学习了下无标题窗口，于是来记录下我的学习过程首先建立一个Qt Widgets Application继承QWidget类创建完后直接运行就得到了如下效果那么，既然是无标题窗口就要去掉窗口栏啊，于是加上setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);去掉标题栏，但是这样整个窗口就不能移动...
谷歌浏览器打开无标题
mp2020xuexi的博客
01-16 988
谷歌浏览器
C#中实现无标题栏窗体拖动的代码
热门推荐
百锦再的博客
01-18 1万+
事件来实现拖动功能。当鼠标按下时，我们标记鼠标正在拖动，并保存当前坐标。在鼠标移动时，如果鼠标正在拖动，我们更新窗体的位置，使其跟随鼠标移动。当鼠标释放时，我们取消拖动标记。请注意，在窗体上添加了对应事件处理程序的窗体控件属性应该设置为对应的事件处理程序方法。在窗体设计视图，选择属性窗格，在事件选项卡中为。在C#中实现无标题栏窗体拖动的代码可以通过处理鼠标事件来实现。这样，当你在运行窗体时，你就可以通过鼠标拖动窗体来改变其位置。事件分别选择对应的处理程序方法。在这个示例代码中，我们通过处理。
C# 移动无标题栏无边框窗体的3种方法
SabreWulf
03-13 2282
目录 第一种：手工移动 第二种：调用系统API 1.引入下面代码 前提需要引入命名空间using System.Runtime.InteropServices 2.增加鼠标按下事件发送消息，让系统误以为按下是标题栏 第三种，重写 WndProc 第一种：手工移动 直接通过修改窗体位置从而达到移动窗体的效果 //定义一个位置信息Point用于存储鼠标位置 private Point mPoint; /// <summary>
Qt实现改变无标题栏窗体大小及移动窗体
danshiming的博客
11-10 3578
Qt实现鼠标左键拖动无标题栏窗体右下角改变窗体大小及移动窗体
Chrome显示无标题错误代码STATUS_INVALID_IMAGE_HASH
precy_wm的博客
01-03 1673
Chrome显示无标题错误代码STATUS_INVALID_IMAGE_HASH
Chrome 无标题 哭脸 已崩溃
wkj52719的博客
05-24 4731
谷歌浏览器chrome突然打开后任何页面均显示为无标题，哭脸。鼠标选中sheet页面时，提示已崩溃。 无法打开设置、开发工具箱 经过检查，是chrome的Userdata数据出错，导致页面加载无法正常展示页面。 修复办法： 打开文件夹C:\Users\{privateUserId}\AppData\Local\Google\Chrome，删除User data文件夹，如果需要备份UserData,请备份User Data到其他地方。 ...
WIN32无标题栏窗口移动方法种种
ZDT_zdh的博客
11-02 2201
WIN32无标题栏窗口移动方法种种 转载来源：http://blog.csdn.net/fuyun_cloud/article/details/8008197     首先，看看在正常情况下系统是怎样来移动程序窗口的。当使用者在程序窗口标题栏区域（非工作区）内，按下鼠标左键时将会发生下列事情：  ◆ 系统向该窗口过程函数发送WM_NCLBUTTONDOWN消息。  ◆ WM_NC...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
C#创建无标题栏窗体
03-16
摘要:C#源码,菜单窗体,无标题栏窗体　C#创建无标题栏窗体源码，实际上是动态显示或隐藏窗体的标题栏，当隐藏的时候就类似窗体没有了标题栏，当显示标题栏的时候，鼠标按住标题栏即可拖动窗体，以前记得网友需要此...
Delphi实现拖动按钮移动无标题栏窗口
05-11
摘要:Delphi源码,界面编程,窗体拖动,无标题栏 无标题栏的窗体的拖动功能实现，Delphi添加一个可拖动窗体的按钮，通过对此按钮的控制可移动窗体，实现按住标题栏移动窗口的功能，无标题栏也就不能显示最大化、最小化...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
工厂模式的介绍及实现
户伟伟的博客
09-25 109
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1067
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 360
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 881
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
设置无标题 android
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值