Java基础之注解与反射
注解
注解是从JDK1.5之后引入使用的,注解可以作用在类、方法、成员变量等上面,用于给编译器看的
内置注解
内置注解是JDK自带的注解,常用的有:
1、@Override,修饰方法,表示该方法将要重写父类中的另一个同名方法
2、@Deprecated,修饰方法,表示该方法已经过时,或者有更好的替代方法,不鼓励使用,但是使用程序也是不会报错的(特征是,该方法中间会有一条横线)
3、@SuppressWarning(),该注解需要传入参数,修饰类、成员方法等,抑制警告信息
public class Dog extends Animal {
//该方法重写了父类的method方法
@Override
public void method() {
System.out.println("狗吃肉");
}
}
public class Demo01AnnotationTest {
@Deprecated
public static void test01(){
System.out.println("deprecated");
}
//使用SuppressWarning可以抑制掉方法test02()未被使用的警告
@SuppressWarnings("all")
public static void test02(){
System.out.println("SuppressWarnings");
}
public static void main(String[] args) {
test01();//在使用被@Deprecated注解过的方法,中间会出现横杠,编译不会报错
}
}
元注解
元注解是使用在注解上的注解,有以下四种:
1、@Target:用于描述注解的使用范围
ElementType.TYPE 该注解用于类、接口
ElementType.FIFLD 该注解用于成员变量
ElementType.METHOD 该注解用于成员方法
ElementType.PARAMETER 该注解用于方法参数
ElementType.CONSTRUCTOR 该注解用于构造器
ElementType.PACHAGE 该注解用于包
ElementType.ANNOTATION 该注解用于注解
例子
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
2、@Retention:用于描述注解的生命周期
RetentionPolicy.RUNTIME 运行时注解
RetentionPolicy.CLASS class文件
RetentionPolicy.SOURCE 编译时注解
生命周期: RUNTIME>CLASS>SOURCE
3、@Document:说明该注解将被包含于javadoc中
4、@Inherited:说明子类可以继承父类中的该注解
自定义注解
自定义注解,格式:
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//自定义注解需要有元注解
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation2 {
String[] name(); //注解中如果设置了参数,那么在使用该注解时,需要给参数赋值
int age() default 18; //如果参数设置了默认值,则不再需要赋值,也可以再次赋值
int id() default -1; //如果默认值设置为-1,则表示不存在
String value();
}
使用该注解:
public class Test02Annotation {
@MyAnnotation2(name={"施瓦辛格"},value="10000000")
public void test02(){
}
}
如果注解只有一个参数,参数名称可以设置为value,在使用注解给参数赋值时,可以不写参数名称
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation2 {
String value();
}
使用:
public class Test02Annotation {
@MyAnnotation2("施瓦辛格")
public void test02(){
}
}
反射机制
反射的概念
Reflection(反射)是Java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能操作任意对象的内部属性及方法
Class c1 = Class.forName("java.lang.String");
// 调用时,调用类需要抛出ClassNotFoundException异常
在加载完类之后,在堆内存的方法区中就会产生一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完成的类结构信息,我们可以通过这个对象得到类的结构
Java反射机制的功能
1、在运行时判断任意一个对象所属的类
2、在运行时构造一个类的对象
3、在运行时获得任意一个类所具有的成员变量和方法
4、在运行时获取泛型信息
5、在运行时调用任意一个对象的成员变量和方法
6、在运行时处理注解
等等,还有其他功能
public class reflectionTest01 {
public static void main(String[] args) throws ClassNotFoundException {
Class c1 = Class.forName("com.itheima.demo05.Reflection.User");
Class c2 = Class.forName("com.itheima.demo05.Reflection.User");
Class c3 = Class.forName("com.itheima.demo05.Reflection.User");
Class c4 = Class.forName("java.lang.String");
System.out.println(c4.hashCode());
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
}
}
运行结果:
同一个类反射得到的对象的hashCode的值是一样的,说明一个类只能得到一个Class对象
D:\jdk1.8\bin\java "-javaagent:D:\IDEA\IntelliJ IDEA 2017.2.6\lib\idea_rt.jar=65508:D:\IDEA\IntelliJ IDEA 2017.2.6\bin" -Dfile.encoding=UTF-8 -classpath
460141958
1163157884
1163157884
1163157884
Class类
1、对于每个类而言,JRE都会给其保留一个不变的Class对象,Class本身也是一个类,Class对象只能由系统建立;
2、一个Class对象对应的是一个加载到JVM中的一个 .class文件;
3、Class类是Reflection的基础,任何动态加载、运行的类,都要先获得相应的Class对象
Class类的常用方法
方法名 | 说明 |
---|---|
static Class.forName(String name) | 返回指定类名name的Class对象 |
Object newInstance() | 调用缺省构造函数,返回Class对象的一个实例 |
GetName() | 返回此Class对象所表示的实体的名称 |
Class getSuperClass() | 返回当前Class对象的父类的Class对象 |
Class[] getInterfaces() | 获取当前Class对象的接口 |
ClassLoader getClassLoader() | 返回该类的类加载器 |
通过反射获取Class对象的几种方式
获得Class对象的方式有几种:可以通过类的对象获得,可以通过Class类的方法获得,可以通过类名.class获得,下面用一个例子说明一下
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("我是一名"+person.name);
//通过类名.class获得,因为通过类名获得的对象,类型已经确认为Student,所以这种方式效率是最高的
Class c1 = Student.class;
System.out.println(c1.hashCode());
//通过对象调用getClass方法获得
Class c2 = person.getClass();
System.out.println(c2.hashCode());
//通过Class类方法获得
Class c3 = Class.forName("包路径.Student");
System.out.println(c3.hashCode());
//一个类只有一个Class对象,所以上面三种方法获得的对象的hashCode值会是一样的
}
}
class Person{
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
}
class Student extends Person{
public Student(){
this.name = "学生";
}
}
class Teacher extends Person{
public Teacher(){
this.name = "老师";
}
}
基本的内置类型的包装类都有一个Type属性可以获取类的Class对象
//获取包装类的Class对象
Class int1 = Integer.TYPE;
还可以通过子类的Class对象获得父类的Class对象
//可以通过子类的Class对象获得父类的Class对象
Class c1Superclass = c1.getSuperclass();
类加载器内存分析
类加载过程:类加载(Load) → 类的链接(Link)→ 类的初始化(Initialize)
类会先初始化静态代码块,再初始化构造函数
1、加载到内存,会产生一个类对应的Class对象
2、链接,链接结束后 m = 0
3、初始化
(){
System.out.println(“初始化静态代码块”);
m = 300;
m = 100;
}
public class Test05 {
public static void main(String[] args) {
A a = new A();
System.out.println(a.m);
}
}
class A{
static {
System.out.println("初始化静态代码块");
int m = 300;
}
static int m = 100;
public A(){
System.out.println("初始化构造方法");
}
}
运行结果
注意事项:1、通过子类调用父类的静态方法、成员变量,不会初始化子类
2、用子类来定义一个数组类型,该类不会被初始化
3、调用类中被final修饰的常量,该类不会被初始化
4、Method和Field、Constructor对象都有setAccessible()方法,作用是启动(false)和禁用(true)访问安全检查的开关,使得使用反射也可以访问private修饰的方法和属性
类加载器的作用
类加载的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口
类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间。最后通过JVM的垃圾回收机制清除
类加载会使用双亲委派机制,保证类加载的安全性
使用反射对性能的影响
public class Test10 {
public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
test01();
test02();
test03();
}
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));
}
public static void test02() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<User> c1 = User.class;
User user = c1.newInstance();
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));
}
public static void test03() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<User> c1 = User.class;
User user = c1.newInstance();
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));
}
}
运行结果:
通过反射获取注解信息
分别定义作用类和属性的注解
1、TableAnnotation.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableAnnotation {
String value();
}
2、FieldAnnotation.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author hfr
* @date 2021/3/20 - 19:15
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldAnnotation {
String columnName();
String type();
int length();
}
定义一个类StudentOne.java,用以上两个注解进行修饰
@TableAnnotation("db_student")
public class StudentOne {
@FieldAnnotation(columnName = "姓名",type = "String",length = 20)
private String name;
@FieldAnnotation(columnName = "年龄",type = "String",length = 2)
private int age;
@FieldAnnotation(columnName = "编号",type = "Int",length = 10)
private int id;
public StudentOne() {
}
public StudentOne(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "StudentOne{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
'}';
}
}
使用反射将类和属性的注解的值打印出来
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
public class Test12 {
public static void main(String[] args) throws NoSuchFieldException {
Class<StudentOne> c1 = StudentOne.class;
//通过反射获取注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获取类的注解的value值
TableAnnotation tableAnnotation = (TableAnnotation)c1.getAnnotation(TableAnnotation.class);
String value = tableAnnotation.value();
System.out.println(value);
//获取属性的注解的值
Field name = c1.getDeclaredField("name");
FieldAnnotation fieldAnnotation = name.getAnnotation(FieldAnnotation.class);
System.out.println(fieldAnnotation.columnName());
System.out.println(fieldAnnotation.type());
System.out.println(fieldAnnotation.length());
}
}
运行结果
总结
断断续续利用业余时间把注解和反射的知识学习完了,其中有很多的地方看一遍不懂,需要看几次才能理解,总的来说还是需要愿意花费时间和心思,多思考,还要把所有的代码都敲一遍。
学习程序,需要付出极多的时间和耐心,不能浮躁。