当前位置：首页 > news >正文

java的注解和反射

news 2025/7/6 7:19:58

什么是注解？

注解也就是Annotation是从JDK5.0开始引入的新技术。

注解的作用：

不是程序本身，但是可以对程序作出解释。
可以被其他程序比如编译器等读取。

注解的格式也很简单："@注释名"

java常见的内置注解：@Override(重写),@Deprecated（不推荐使用）,@SuppressWarnings(参数)（镇压警告）

元注解

元注解的作用就是负责注解其它注解，也就是说他可以定义其他注解，java定义的四个元注解（meta-annotation）

元注解的四个类型：

@Target：用来描述注解，表示我们的注解可以用到哪些地方。
@Retention：表示我们的注解的作用范围。（Runtime>class>sources）
@Documented：表示是否将我们的注解生成在java的文档中。
@Inherited表示注解是能被子类继承。

自定义注解

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

@interface用来声明一个注解，格式：@interface 注解名{定义内容}
方法的名称就是注解的名称。
返回值类型只能是基本类型。
注解内可以使用default来声明参数的默认值。
如果只有一个参数，一般默认声明为value，我们在使用的时候可以省略不写

反射机制

学习反射之前我们需要知道什么是动态语言和静态语言

动态语言

举一个简单的例子，我们的javaScript就是一种动态语言，也就是说在我们运行的时候，可以对代码进行改变,比方说运行的时候可以引入一些新的变量或者对象。

静态语言

与动态语言相反，静态语言就是指运行时结构不可变的语言就是静态语言，比方说java，c++

反射的存在使java可以称为准动态语言，拥有了一定的动态性，java的动态性让java编程的时候更加的灵活，同时也带来了一些不安全的方面。

反射（Reflection）是java被视为动态语言的关键，反射机制允许程序执行期间通过Reflection API获得任何类的内部消息，同时也能对其进行操作，正常的类加载完之后，在堆内存就产生了一个Class类型的对象，介于一个类只有一个反射对象，这个对象包含了完整的类的结构信息。正常获得对象的时候需要先引入“包类”名称然后通过new实例化，才能够取得实例化对象，反射与之相反，通过实例化对象使用getClass（）方法得到完整的“包类”名称。

下面为一个简单的反射实例。

package com.kang.JavaReflection;

public class Demo1 {public static void main(String[] args) throws ClassNotFoundException {Class class1 = Class.forName("com.kang.JavaReflection.User");Class class2 = Class.forName("com.kang.JavaReflection.User");Class class3 = Class.forName("com.kang.JavaReflection.User");Class class4 = Class.forName("com.kang.JavaReflection.User");
System.out.println(class1);
System.out.println(class2.hashCode());System.out.println(class3.hashCode());System.out.println(class4.hashCode());
}
}
class User{private int age;private String name;
User(int age, String name) {this.age = age;this.name = name;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
}

java反射机制提供的功能

在运行时构造任意一个类的对象。
判断任意一个类所以具有的成员变量和方法。
在运行时调用任意一个对象的成员变量和方法。
生成动态代理。
判断任意一个对象所属于的类。

事实上这个class创建的时候，我们可以从Object类中找到，getClass方法被所有的子类给继承。这个Class是java反射的源头，所以反射也就很容易理解了，可以通过对象反射求出类的名称。

java反射的优点在于动态创建对象和编译，体现出很大的灵活性。

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

Class创建

package com.kang.JavaReflection;

public class Demo2 {public static void main(String[] args) throws ClassNotFoundException {people people = new student();System.out.println(people.name);
//通过对象获得Class aClass = people.getClass();System.out.println(aClass.hashCode());//通过forname获得Class aClass1 = Class.forName("com.kang.JavaReflection.student");System.out.println(aClass1.hashCode());//通过类名.class获得Class aclass2 = student.class;System.out.println(aclass2.hashCode());//通过基本内置类的包装类的Type属性Class<Integer> type = Integer.TYPE;System.out.println(type.hashCode());}
}


class people{public String name;
public people() {}
@Overridepublic String toString() {return "people{" +"name='" + name + '\'' +'}';}
people(String name) {this.name = name;}
}
class teacher extends people{public teacher() {this.name = "teacher";}
}
class student extends  people{public student(){this.name="student";}
}

哪些类型可以有Class对象

class:外部类，成员(成员内部类，静态内部类)，局部内部类，名内部类。
interface:接口
数组
enum:枚举
annotation:注解@interface
primitive type:基本数据类型
void

package com.kang.JavaReflection;

import java.lang.annotation.ElementType;

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

注意！！

只要元素的类型和维度一样，就是同一个Class，比方说下图两个数组继承的都是一个class