一、什么是注解?
Annotation是从JDK5.0开始引入的新技术。
Annotation的作用：可以被其他程序(如：编译器等)读取。
Annotation的格式：注解是以”@注释名”在代码中存在的，还可以添加一些参数值，如：@SuppressWarnings(value=”uncheched”) 作用：用于抑制编译器产生警告信息。
Annotation可以在哪里使用？可以在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。
二、内置注解
@Override：定义在java.lang.Override中，此注释只适用修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。
@Deprecated：定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，表示不鼓励程序员使用此元素。
jdk1.8的文档下载：传送
@SuppressWarnings:定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息。
与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好的。
@SuppressWarnings(“all”) // 抑制所有类型的警告
@SuppressWarnings(“unchecked”) // 抑制单类型的警告
@SuppressWarnings(“value={“unchecked”,”deprecation”}”) // 抑制多类型的警告
二、元注解
元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作用说明。
@Target：用于描述注解的使用范围。
@Retention：表示要在什么级别保存改注释信息（SOURCE(源码级别) < CLASS(类级别) < RUNTIME(运行时)）
@Document：说明该注解将包含在javadoc中。
@Inherited：说明子类可以继承父类中的该注解。
三、自定义注解
使用@Interface自定义注解时，自动继承了java.lang.anntation.Annotation接口
import java.lang.annotation.*;
/**
* @ClassName: Test02
* @Description: 测试元注解
* @author: xiaofei
*/
@MyAnnotation
public class Test02 {
@MyAnnotation
public void test() {
}
}
// 定义一个注解
// 表示我们的注解可以使用在那些地方
@Target(value = {ElementType.METHOD, ElementType.TYPE})
// 表示我们的注解在什么地方有效
// runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)
// 表示是否将我们注解生成在Javadoc中
@Documented
// 表示子类可以继承父类注解
@Inherited
@interface MyAnnotation {
}
四、反射机制
Reflection(反射) 是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
反射的优缺点：
优点：
可以实现动态创建对象和编译，体现出很大的灵活性。
缺点：
对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。
Class类的常用方法:
| 方法名 | 功能说明 |
|---|---|
| static ClassforName(String name) | 返回指定类名name的Class对象 |
| Object newInstance() | 调用缺省构造函数，返回Class对象的一个实例 |
| getName() | 返回Class对象所表示的实体(类，接口，数组类或void)的名称 |
| Class getSuperClass() | 返回当前Class对象的父类的Class对象 |
| Class[] gettinterfaces() | 获取当前Class对象的接口 |
| ClassLoader getClassLoader() | 返回该类的类加载器 |
| Constructor[] getConstructors() | 返回一个包含某些Constructor对象的数组 |
| Method getMothed(String name, Class.. T) | 返回一个Method对象，此对象的形参类型为paramType |
| Field[] getDeclaredFields() | 返回Field(字段)对象的一个数组 |
获取Class类的实例:
若已知具体的类，通过类的class属性获取，改方法最为安全可靠。
Class clazz = Person.class;
若已知某个类的实例，调用改实例的getClass()方法获取Class对象。
Class clazz = person.getClass();
若已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取。
Class clazz = Class.forName("demo01.Student")
内置基本数据类型可以直接用类名.Type，还可以利用ClassLoader。
/**
* @ClassName: Test02
* @Description: 测试class类的创建方式有哪些?
* @author: xiaofei
*/
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println(person.name);
// 1、通过对象获得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
// 2、forname获得
Class c2 = Class.forName("com.xffjs.reflection.Student");
System.out.println(c2.hashCode());
// 3、通过类名.class获得
Class<Student> c3 = Student.class;
System.out.println(c3.hashCode());
// 4、通过Type属性
Class c4 = Integer.TYPE;
System.out.println(c4);
// 获得父类类型
Class c5 = c1.getSuperclass();
System.out.println(c5);
}
}
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 = "老师";
}
}
类的加载与ClassLoader的理解
加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表类的java.lang.Class
对象。
链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。
初始化：
类的初始化
类的主动引用（会初始化）:
类的被动引用（不会初始化）:
双亲委派： 我们自定义的类通过类加载器实例化对象时，类加载会向上查找父类加载器所在的类对象。如果我们自定义的类与父类加载器所加载的类的类对象一致，则会报错。这样设计的好处就是从一定程度上防止了危险代码的植入。
获取类的信息
| 方法名 | 解释 |
|---|---|
| getFields() | 获取所有public修饰的字段 |
| getDeclaredFields() | 获取所有private修饰的字段 |
| getDeclaredField(“name”) | 获得指定属性的值 |
| getMethods() / getDeclaredMethods() / getMethod(“setName”, String.class) | 获取方法 |
| getConstructors() / getDeclaredConstructors() / getDeclaredConstructor(int.class, String.class) | 获取构造器 |
public class Test07 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("com.xffjs.reflection.User");
// 获取包名 + 类名
System.out.println(c1.getName());
// 获取类名
System.out.println(c1.getSimpleName());
// 获得类的属性--只能找到public属性
Field[] fields = c1.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("-------------------");
Field[] declaredFields = c1.getDeclaredFields();
for (Field field : declaredFields) {
System.out.println(field);
}
// 获得指定属性的值
Field name = c1.getDeclaredField("name");
System.out.println(name);
System.out.println("========获取类的方法========");
// 获得类的方法---获得本类及其父类的全部方法
Method[] methods1 = c1.getMethods();
for (Method method : methods1) {
System.out.println(method);
}
System.out.println("-------------------");
// 获得类的方法---获得本类方法
Method[] methods2 = c1.getDeclaredMethods();
for (Method method : methods2) {
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();
Constructor[] constructors2 = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
System.out.println("-------------------");
for (Constructor constructor : constructors2) {
System.out.println(constructor);
}
// 获得指定构造器
Constructor declaredConstructor = c1.getDeclaredConstructor(int.class, String.class);
System.out.println(declaredConstructor);
}
}
有了Class对象可以做什么？
创建类的对象：调用Class对象的newInstance()方法
调用指定的方法
通过反射，调用类中的方法，通过Method类完成。
1、通过Class类的getMethod(String name, Class… parameterTypes)方法取得一个Method对象，并设置此方法操作时需要的参数类型。
2、之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
Object invoke(Object obj, Object[] args)：
1、Object对应原方法的返回值，若原方法无返回值，此时返回null。
2、若原方法若为静态方法，此时形参Object obj为null。
3、若原方法参数列表为空，则Object[] args为null。
4、若原方法声明为private，则需要调用此invoke()方法之前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
// 获得Class对象
Class<?> c1 = Class.forName("com.xffjs.reflection.User");
// 通过反射调用普通方法
User user3 = (User) c1.newInstance();
// 通过反射获取一个方法
Method setName = c1.getDeclaredMethod("test", String.class);
// 不能直接操作私有属性，需要关闭安全监测
setName.setAccessible(true);
// invoke()参数：对象，方法值
setName.invoke(user3, "小飞");
System.out.println(user3.getName());
setAccessible：
Method和Field、Constructor对象都有setAccessible()方法。
setAccessible作用是启用和禁用访问安全检查的开关；
参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
反射操作泛型
public class Test10 {
public void test01(Map<String, User> map, List<User> list) {
System.out.println("test01");
}
public Map<String, User> test02() {
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test10.class.getMethod("test01", Map.class, List.class);
// 获取泛型的参数类型
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println(genericParameterType);
// 判断泛型参数类型是否一个参数化类型
if (genericParameterType instanceof ParameterizedType) {
// 获取泛型的参数信息
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
System.out.println("****************************");
method = Test10.class.getMethod("test02");
Type genericReturnType = method.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
// 获取泛型的参数信息
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
反射操作注解
public class Test11 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("com.xffjs.reflection.Student2");
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotatedInterface : annotations) {
System.out.println(annotatedInterface);
}
// 获取注解value的值
Tablexf tablexf = (Tablexf) c1.getAnnotation(Tablexf.class);
String value = tablexf.value();
System.out.println(value);
// 获取类指定的注解
Field f = c1.getDeclaredField("id");
Fieldxf annotation = f.getAnnotation(Fieldxf.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@Tablexf("db_student")
class Student2 {
@Fieldxf(columnName = "db_id", type = "int", length = 10)
private int id;
@Fieldxf(columnName = "db_name", type = "varchar", length = 3)
private String name;
public Student2() {
}
public Student2(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student2{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
// 类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tablexf {
String value();
}
// 属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldxf {
String columnName();
String type();
int length();
}
当前共有 0 条评论