java注解与反射

笔记

java注解与反射

1.注解

Annotation是从jdk5.0开始引入的新技术

Annotation的作用：

不是程序本身，可以对程序作出解释(这一点和注释[comment]没有区别)
可以被其他程序(如：编译器)读取

Annotation的格式：

注解是以"@注释名"在代码中存在的，还可以添加一些参数值，例：

@SuppressWarnings(value="unchecked")

Annotation在哪里使用？

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

①例子：

//@Override重写的注解

@Override

//@Deprecated 不推荐程序员使用

@Deprecated

//抑制警告

@SuppressWarnings("all")

public class Demo01 extends Object{

②元注解

//定义一个注解
//@Target 表示我们的注解可以用在哪些地方
@Target(value = {ElementType.FIELD,ElementType.METHOD,ElementType.TYPE,ElementType.CONSTRUCTOR})

//@Retention 表示我们的注解可在什么地方还有效 runtime>class>sources(范围递减)
@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作为默认值

//自定义注解
public class Demo03 {

//    @MyAnnotation02(name = "gg")
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
//    @MyAnnotation02()
    @MyAnnotation02(schools = {"2","p"})
    public void test(){
    }

    @MyAnnotation03("mu")
    public void test1(){
    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation02{
    //注解的参数 : 参数类型 + 参数名
//    String name();
    String name() default "yt";
    int age() default 0;
    int id() default -1;    //如果默认值为-1，代表不存在
    String[] schools() default {"S1","S2"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation03{
    //当只有一个参数时，应命名为value，在注解中可省略 value=
    String value();
}

2.反射

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

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

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

java反射机制研究和应用：

java反射机制提供的功能

在运行时判断任意一个对象所属的类

在运行时构造任意一个类的对象

在运行时判断任意一个类所具有的成员变量和方法

在运行时获取泛型信息

在运行时调用任意一个对象的成员变量和方法

在运行时处理注解

生成动态代理

java反射优点和缺点

优点：

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

缺点：

对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作

反射相关的主要API

java.lang.Class：代表一个类

java.lang.reflect.Field：代表类的成员变量

java.lang.reflect.Method：代表类的方法

java.lang.reflect.Constructor：代表类的构造器

Class类：

在Object中定义了以下的方法，此方法将被所有子类继承

public final Class getClass()

以上的方法返回值的类型是一个Class类，此类是java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

Class类的常用方法

static ClassforName(String name):返回指定类名name的Class对象

Object newInstance():调用缺省构造函数，返回Class对象的一个实例

getName():返回此Class对象所表示的实体(类，接口，数组类或void)的名称

Class getSuperClass()：返回当前Class对象的父类的Class对象

Class[] getinterfaces():获取当前Class对象的接口

ClassLoader getConstructors()：返回一个包含某些Constructor对象的数组

Method getMethod(String name,Class)：返回一个Method对象，此对象的形参类型为paramType

Field[] getDeclaredFields():返回Field对象的一个数组

获取Class类的实例

1.已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高

Class clazz = Person.class

2.已知某个类的实例，调用该实例的getClass()方法获取Class对象

Class clazz = person.getClass()

3.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

Class clazz = Class.forName("demo01.Student")

4.内置基本数据类型可以直接用类名.Type

5.还可以利用ClassLoader

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

// 方式二：通过forName
Class c2 = Class.forName("com.gg.reflection.Student");
System.out.println(c2.hashCode());

// 方式三：通过类名.class获得
Class c3 = Student.class;
System.out.println(c3.hashCode());

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

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

哪些类型可以有Class对象

1.class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类

2.interface：接口

3.[]：数组

4.enum：枚举

5.annotation：注解@interface

6.primitive type：基本数据类型

7.void

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

//只要元素类型与维度一样，就是同一个Class
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());

java内存：

存放new的对象和数组
可以被所有的线程共享，不会存放别的对象引用

存放基本变量类型(会包含这个基本类型的具体数值)
引用对象的变量(会存放这个引用在堆里面的具体地址)

方法区

可以被所有的线程共享
包含了所有的class和static变量

类的加载过程

/*==会引起类的初始化==*/

        // 1.主动引用
//        Son son = new Son();
        // 2.返回类也会产生主动引用
//        Class c1 = Class.forName("com.gg.reflection.Son");
        //3.调用类的静态成员和静态方法
//        System.out.println(Son.m);

/*==不会会引起类的初始化==*/
        //1.访问继承父类的静态成员
//        System.out.println(Son.b);
        //2.新建数组对象
//        Son[] array = new Son[4];
        //3.访问静态final常量
//        System.out.println(Son.M);

获取类的信息

//获取类的信息
public class Demo07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.gg.reflection.User");

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

        //获得类的属性
        Field[] fields = c1.getFields();    //只能找到public属性

        Field[] fields1 = c1.getDeclaredFields();   //获取所有的属性
        for (Field field : fields1) {
            System.out.println(field);
        }
        //获取指定类的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        Method[] methods = c1.getMethods(); //获得本类及其父类的全部public方法
//        for (Method method : methods) {
//            System.out.println(method);
//        }

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

        Method[] declaredMethods = c1.getDeclaredMethods(); //获得本类的所有方法
//        for (Method declaredMethod : declaredMethods) {
//            System.out.println(declaredMethod);
//        }

        //获得指定方法
        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);
        }

        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }

        //获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println(declaredConstructor);
    }
}

通过反射，动态创建对象

//获得Class对象
        Class c1 = Class.forName("com.gg.reflection.User");

//        User user = (User)c1.newInstance(); //本质上是调用了类的无参构造器
//        System.out.println(user);

        //通过构造器创建对象
//        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
//        User user1 = (User) constructor.newInstance("星星", 23, 67);
//        System.out.println(user1);

        //通过反射调用普通方法
        User user2 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke调用方法[方法.invoke(对象，参数)]
        setName.invoke(user2, "gg");
        System.out.println(user2.getName());

        //关闭安全监测
        Method getName1 = c1.getDeclaredMethod("getName1", null);
        getName1.setAccessible(true);
        //invoke调用方法[方法.invoke(对象，参数)]
        getName1.invoke(user2,null);
        System.out.println(user2.getName());

        //关闭安全监测
        Method getAll = c1.getDeclaredMethod("getAll", String.class, int.class, int.class);
        getAll.setAccessible(true);
        getAll.invoke(user2,"name",23,67);
        System.out.println(user2.getName()+user2.getId()+user2.getAge());
//        System.out.println(user2.getName());

        //通过反射操作属性
        User user3 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //不能直接操作private私有属性，需要关闭程序的安全监测
        name.setAccessible(true);

        name.set(user3,"gg1");
        System.out.println(user3.getName());

//获取方法
Method method = Demo10.class.getMethod("test01", Map.class, List.class);
//得到参数类型数组
Type[] parameterTypes = method.getGenericParameterTypes();
//遍历
for (Type parameterType : parameterTypes) {
    System.out.println("#"+parameterType);
    //判断是否为ParameterizedType类型
    if (parameterType instanceof ParameterizedType){
        //是，强转为ParameterizedType调用getActualTypeArguments()返回Type[]
        Type[] arguments = ((ParameterizedType) parameterType).getActualTypeArguments();
        for (Type argument : arguments) {
            //输出参数类型
            System.out.println(argument);
        }
    }
}


System.out.println("========");
Method method1 = Demo10.class.getMethod("test02", null);
Type returnType = method1.getGenericReturnType();
if(returnType instanceof ParameterizedType){
    Type[] arguments = ((ParameterizedType) returnType).getActualTypeArguments();
    for (Type argument : arguments) {
        System.out.println(argument);
    }
}

反射操作注解

Class c1 = Class.forName("com.gg.reflection.Student2");

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

//获得value的值
Tablegg tablegg = (Tablegg)c1.getAnnotation(Tablegg.class);
String value = tablegg.value();
System.out.println(value);

//获得类指定的注解
Field field = c1.getDeclaredField("name");
Fieldgg fNameAnnotation = field.getAnnotation(Fieldgg.class);
System.out.println(fNameAnnotation.columnName());
System.out.println(fNameAnnotation.type());
System.out.println(fNameAnnotation.length());


Field field1 = c1.getDeclaredField("id");
Fieldgg fNameAnnotation1 = field1.getAnnotation(Fieldgg.class);
System.out.println(fNameAnnotation1.columnName());
System.out.println(fNameAnnotation1.type());
System.out.println(fNameAnnotation1.length());

Field field2 = c1.getDeclaredField("age");
Fieldgg fNameAnnotation2 = field2.getAnnotation(Fieldgg.class);
System.out.println(fNameAnnotation2.columnName());
System.out.println(fNameAnnotation2.type());
System.out.println(fNameAnnotation2.length());

posted @ 2021-04-27 17:53 G-G 阅读(76) 评论(0) 收藏举报

刷新页面返回顶部

业精于勤,荒于嬉;行成于思,毁于随

摸鱼小能手

java注解与反射

公告