注解
- Annotation是从JDK5.0开始引入的新技术
- Annotation的作用:
- 不是程序本身,可以对程序作出解释
- 可以被其他程序读取
- Annotation的格式:
- 注解是以 @注释名 在代码中存在的,还可以添加一些参数值。
- Annotation在哪里使用:
- 可以附加在package,class,method,field等上面,相当于给他们添加了额外的辅助信息,可以通过反射机制编程实现对这些元数据的访问
内置注解
@Override
此注释只适用于修辞方法,表示一个方法声明打算重写超类中的另一个方法声明
//@Override 重写的注解
@Override
public String toString(){
return super.toString();
}
@Deprecated
磁珠是可以用于修辞方法,属性,类,表示不鼓励程序员使用这样的元素,通常是因为它很危险或者存在更好的选择
//@Deprecated 不推荐程序员使用,但是可以使用,或者存在更好的方式
@Deprecated
public static void test(){
System.out.println("Deprecated");
}
@SuppressWarnings
用来抑制编译时的警告信息。需要添加参数
//@SuppressWarnings 镇压警告
@SuppressWarnings("all")
public void test02(){
List list = new ArrayList();
}
元注解
- 元注解的作用就是负责注解其他注解,Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明
- 这些类型和它们所支持的类在Java.lang.annotation包中可以找到
- @Target:用于描述注解的适用范围
- @Retention:表示需要在什么级别保存该注释信息,用于描述注解的生命周期
- (SOURCE(源码)<CLASS(类)<RUNTIME(运行时))
- @Document:说明该注解将被包含在javadoczhong
- @Inherited:说明子类可以继承父类中的该注解
//Target表示我们的注解在什么地方可以使用
@Target(value = ElementType.METHOD)
//Retention表示注解在什么地方有效
@Retention(value = RetentionPolicy.RUNTIME)
//Documented表示是否将注解生成在Javadoc中
@Documented
//Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{}//定义一个注解
自定义注解
package Annotation;
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)
@interface MyAnnotation2{
//注解的参数:参数类型+参数名() default "默认值";
String name() default "";
int age() default 0;
int id() default -1;// 如果默认值为-1 代表不存在
String[] schooles();
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
String value();//只有一个参数且名为value时 可以不用写参数名直接传参
}
public class Test03 {
//注解可以显示赋值,如果没有默认值,就必须给注解赋值
@MyAnnotation2(schooles = "洛师")
public void test1(){}
@MyAnnotation3("value")
public void test2(){}
}
反射
静态&动态
动态语言
- 是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进,已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
- 主要动态语言:Object-C,C#.JavaScript,PHP,python等.
静态语言
- 与动态语言相对应的,运行时结构不可变的语言就是静态语言.如Java,C,C++.
- Java不是动态语言,但Java可以称之为"准动态语言".即Java有一定的动态性,我们可以利用反射机制获得类似动态语言的特性.Java的动态性让编程的时候更加灵活
Java Reflection
-
Reflection(反射)是Java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法.
-
Class c = Class.forName(“java.lang.String”)
加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构.我们可以通过这个对象看到类的结构.这个对象就像一面镜子,透过这个镜子可以看到类的结构,所以称之为反射.
反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
反射的优缺点
优点:可以实现动态创建对象和编译,体现出很大的灵活性
**缺点:**对性能有影响.使用反射基本上是一种解释操作,可以告诉JVM,我们希望做什么并且它满足我们的要求.这类操作总是慢于直接执行相同的操作
反射获得class
package Reflection;
//什么叫反射
public class Test01 {
public static void main(String[] args) throws ClassNotFoundException {
//通过反射获取类的class对象
Class user = Class.forName("Reflection.User");
//一个类在内存中只有一个class对象
//一个类被加载后,类的整个结构都会被封装在class对象中
System.out.println(user);
}
}
//实体类
class User{
private String name;
private int id;
private String pwd;
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 String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
Class类
对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言,JRE 都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
- Class本身也是一个类
- Class对象只能由系统建立对象
- 一个加载的类在JVM中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个class文件
- 每个类的实例都会记得自己是由哪个Class实例所生成的
- 通过Class可以完整的得到一个类中的所有被加载的结构
- Class类是Reflection的根源,针对任何你想动态加载,运行的类,唯有先获得相应的Class对象
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MVvRzEkO-1623026682221)(注解1.png)]
获得Class类的方法
-
已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高
Class c=Person.class
-
已知某个类的实例,调用该实例的getClass()fangfa获取Class对象
Class c = person.getClass()
-
已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,
Class c = Class.forName(“demo01.Student”)
-
内置基本数据类型可以直接用 类名.Type
类加载机制
JVM把class文件加载到内存,并对数据进行校验、准备、解析、初始化,最终形成JVM可以直接使用的Java类型的过程。
1、加载
将class字节码文件加载到内存中,并将这些数据转换成方法区中的运行时数据(静态变量、静态代码块、常量池等),在堆中生成一个Class类对象代表这个类(反射原理),作为方法区类数据的访问入口。
2、链接
将Java类的二进制代码合并到JVM的运行状态之中。
• 验证
确保加载的类信息符合JVM规范,没有安全方面的问题。
• 准备
正式为类变量(static变量)分配内存并设置类变量初始值的阶段,这些内存都将在方法区中进行分配。注意此时的设置初始值为默认值,具体赋值在初始化阶段完成。
• 解析
虚拟机常量池内的符号引用替换为直接引用(地址引用)的过程。
3、初始化
初始化阶段是执行类构造器()方法的过程。类构造器()方法是由编译器自动收集类中的所有类变量的赋值动作和**静态语句块(static块)**中的语句合并产生的。
- 当初始化一个类的时候,如果发现其父类还没有进行过初始化、则需要先初始化其父类。
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。
类的引用
1、主动引用(一定会初始化)
- new一个类的对象。
- 调用类的静态成员(除了final常量)和静态方法。
- 使用java.lang.reflect包的方法对类进行反射调用。
- 当虚拟机启动,java Hello,则一定会初始化Hello类。说白了就是先启动main方法所在的类。
- 当初始化一个类,如果其父类没有被初始化,则先会初始化他的父类
2、被动引用
- 当访问一个静态域时,只有真正声明这个域的类才会被初始化。例如:通过子类引用父类的静态变量,不会导致子类初始化。
- 通过数组定义类引用,不会触发此类的初始化。
- 引用常量不会触发此类的初始化(常量在编译阶段就存入调用类的常量池中了)。
public class Demo02 {
public static void main(String[] args) throws ClassNotFoundException {
//主动引用:new一个类的对象
// People people = new People();
//主动引用:调用类的静态成员(除了final常量)和静态方法
// People.getAge();
// System.out.println(People.age);
//主动调用:使用java.lang.reflect包的方法对类进行反射调用
// Class.forName("pri.xiaowd.classloader.People");
//被动引用:当访问一个静态域时,只有真正声明这个域的类才会被初始化。
// System.out.println(WhitePeople.age);
//被动引用:通过数组定义引用,不会初始化
// People[] people = new People[10];
//被动引用:引用常量不会触发此类的初始化
System.out.println(People.num);
}
//主动调用:先启动main方法所在的类
// static {
// System.out.println("main方法所在的类在虚拟机启动时就加载");
// }
}
class People{
static int age = 3;
static final int num = 20;
static {
System.out.println("People被初始化了!");
}
public People() {
}
public static int getAge() {
return age;
}
public static void setAge(int age) {
People.age = age;
}
}
class WhitePeople extends People{
static {
System.out.println("WhitePeople被初始化了!");
}
}
类加载器
1、类缓存
标准的Java SE类加载器可以按要求查找类,一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间。不过,JVM垃圾收集器可以回收这些Class对象。
2、类加载器的分类
引导类加载器(bootstrap class loader)
(1)它用来加载 Java 的核心库(JAVA_HOME/jre/lib/rt.jar,sun.boot.class.path路径下的内容),是用原生代码(C语言)来实现的,并不继承自 java.lang.ClassLoader。
(2)加载扩展类和应用程序类加载器。并指定他们的父类加载器。
扩展类加载器(extensions class loader)
(1)用来加载 Java 的扩展库(JAVA_HOME/jre/ext/*.jar,或java.ext.dirs路径下的内容) 。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java类。
(2)由sun.misc.Launcher$ExtClassLoader实现。
应用程序类加载器(application class loader)
(1)它根据 Java 应用的类路径(classpath,java.class.path 路径下的内容)来加载 Java 类。一般来说,Java 应用的类都是由它来完成加载的。
(2)由sun.misc.Launcher$AppClassLoader实现。
自定义类加载器
(1)开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器,以满足一些特殊的需求。
3、java.class.ClassLoader类
(1)作用:
- java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称,找到或者生成其对应的字节代码,然后从这些字节代码中定义出一个Java类,即java.lang.Class类的一个实例。
- ClassLoader还负责加载 Java 应用所需的资源,如图像文件和配置文件等。
(2)常用方法: - getParent() 返回该类加载器的父类加载器。
- loadClass(String name) 加载名称为 name的类,返回的结果是java.lang.Class类的实例。
此方法负责加载指定名字的类,首先会从已加载的类中去寻找,如果没有找到;从parent ClassLoader[ExtClassLoader]中加载;如果没有加载到,则从Bootstrap ClassLoader中尝试加载(findBootstrapClassOrNull方法), 如果还是加载失败,则自己加载。如果还不能加载,则抛出异常ClassNotFoundException。 - findClass(String name) 查找名称为 name的类,返回的结果是java.lang.Class类的实例。
- findLoadedClass(String name) 查找名称为 name的已经被加载过的类,返回的结果是 java.lang.Class类的实例。
- defineClass(String name, byte[] b, int off, int len) 把字节数组 b中的内容转换成 Java 类,返回的结果是java.lang.Class类的实例。这个方法被声明为 final的。
- resolveClass(Class<?> c) 链接指定的 Java 类。
获取类的结构
package Reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//获得类的信息
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class user = Class.forName("Reflection.User");
//获得类的名字
System.out.println(user.getName()); //获得包名+类名
System.out.println(user.getSimpleName());//获得类名
//获得类的属性
System.out.println("=============================");
Field[] fields = user.getFields();//只能找到public属性
for (Field field : fields) {
System.out.println(field);
}
fields = user.getDeclaredFields();//找到全部的属性
for (Field field : fields) {
System.out.println(field);
}
//Field name = user.getField("name");//找到指定的public属性
Field name = user.getDeclaredField("name");//找到指定的属性
System.out.println(name);
//获得类的方法
System.out.println("=============================");
Method[] methods = user.getMethods();//获得本类和父类的所有public方法
for (Method method : methods) {
System.out.println(method);
}
System.out.println("=============================");
methods = user.getDeclaredMethods();//获得本类的所有方法
for (Method method : methods) {
System.out.println(method);
}
//获得指定的方法
//方法可能会重载,所以需要传入参数
Method getName = user.getMethod("getName", null);
Method setId = user.getMethod("setId", int.class);
System.out.println(getName);
System.out.println(setId);
}
}
package Reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class cu = Class.forName("Reflection.User");
//构造一个对象
/*User u1 = (User)cu.newInstance();//本质是调用了类的无参构造
System.out.println(u1);*/
//通过构造器创建对象
/*Constructor constructor = cu.getConstructor(String.class, int.class, String.class);
User u2 = (User) constructor.newInstance("李四", 1, "123");
System.out.println(u2);*/
//通过反射调用普通方法
User u3 =(User) cu.newInstance();
//通过反射获取一个方法
Method setName = cu.getMethod("setName", String.class);
//invoke(对象,"方法的值"):激活
setName.invoke(u3,"lisa");
//通过反射操作属性
//不能直接操作私有属性,需要关闭程序的安全检测,属性或者方法的setAccessible()
Field id = cu.getDeclaredField("id");
id.setAccessible(true);//
id.set(u3,5);
System.out.println(u3);
}
}
获得注解
package Reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
public class Test04 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("Reflection.Student");
//通过反射获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
//获得注解的值
ClassAnnnotation classAnnnotation = (ClassAnnnotation) annotation;
System.out.println(classAnnnotation.value());
}
//获得指定的注解
Field name = c1.getDeclaredField("name");
FieldAnnotation annotation = name.getAnnotation(FieldAnnotation.class);
System.out.println(annotation.length());
System.out.println(annotation.name());
System.out.println(annotation.type());
}
}
@ClassAnnnotation("db_student")
class Student{
@FieldAnnotation(name="db_name",type = "String",length = 10)
private String name;
@FieldAnnotation(name="db_age",type = "int",length = 3)
private int age;
@FieldAnnotation(name="db_grade",type = "int",length = 3)
private int grade;
public Student() {
}
public Student(String name, int age, int grade) {
this.name = name;
this.age = age;
this.grade = grade;
}
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 getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", grade=" + grade +
'}';
}
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface ClassAnnnotation{
String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAnnotation{
String name();
String type();
int length();
}
this.grade = grade;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", grade=" + grade +
'}';
}
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface ClassAnnnotation{
String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAnnotation{
String name();
String type();
int length();
}