一、 注解
1.元注解
@Taget //描述注解的使用范围
@Retention //表示注解的生命周期
@Document //说明该注解将要被包含在javadoc中
@Inherited //说明子类可以继承父类中的该注解
2.自定义注解
@interface //定义注解
package com.yyb;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class Test03 {
@MyAnnotation(name = "yyb", age = 5)
public void Test() {
}
}
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
//定义注解的参数 参数类型+参数名() 可以设置默认值
String name() default "";
int age();
int id() default -1;
String[] schoocs() default {"1111", "222"};
}
二、反射
1.获得class类
//方式一 通过对象获得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
//方式二 forName获得
Class c2 = Class.forName("com.yyb.Student");
System.out.println(c2.hashCode());
//方式三 通过.class 或得
Class c3 = Student.class;
System.out.println(c3.hashCode());
2.通过反射获取类的属性和方法
Class c1 = Class.forName("com.yyb.User");
//获得类的名 包名+类名
System.out.println(c1.getName());
//获得类名
System.out.println(c1.getSimpleName());
//获得累的属性
Field[] fields = c1.getDeclaredFields(); //找到全部的属性
for(Field field:fields){
System.out.println(field);
}
//获得指定属性的值
Field name = c1.getDeclaredField("name");
System.out.println(name);
//获得类的方法
Method[] methods = c1.getMethods(); //获取本类及其子类的所有方法
for(Method method:methods){
System.out.println("正常的"+method);
}
methods=c1.getDeclaredMethods(); //获取本类的所有方法
for(Method method:methods){
System.out.println("getDeclaredMethods"+method);
}
//获得指定方法
Method getName = c1.getMethod("getName", null);
System.out.println(getName);
Method setName = c1.getMethod("setName", String.class);
System.out.println(setName);
//获得全部构造器
Constructor[] constructors = c1.getConstructors();
for(Constructor constructor:constructors){
System.out.println(constructor);
}
Constructor[] declaredConstructors = c1.getDeclaredConstructors();
for(Constructor constructor:declaredConstructors){
System.out.println(constructor);
}
//获得指定构造器
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
System.out.println(declaredConstructor
3.通过反射调用方法和属性
Class c1 = Class.forName("com.yyb.User");
//构造一个对象
// User user = (User)c1.newInstance(); //本质是调用无参构造器
// System.out.println(user);
//通过构造器创建对象
// Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
// User user2 = (User)declaredConstructor.newInstance("yyb", 01, 12);
// System.out.println(user2);
//通过反射调用普通方法
User user3 = (User) c1.newInstance();
//通过反射获取方法
Method setName = c1.getDeclaredMethod("setName", String.class);
/**
* invoke 激活
* (对象,"方法的值")
*/
setName.invoke(user3, "杨亚斌");
System.out.println(user3.getName());
//通过反射操作属性
User user4 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");
name.setAccessible(true); //关掉权限检测 可以操作私有属性
name.set(user4, "杨亚斌1"); //无法操作私有的属性
System.out.println(user4.getName());
4.反射操作注解
package com.yyb;
import java.lang.annotation.*;
import java.lang.reflect.Field;
public class Test12 extends Object {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class aClass = Class.forName("com.yyb.Student1");
//通过反射获得注解
Annotation[] annotations = aClass.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获得注解的value值
Tableyyb tableyyb = (Tableyyb) aClass.getAnnotation(Tableyyb.class);
String value = tableyyb.value();
System.out.println(value);
//获得类指定的注解
Field field = aClass.getDeclaredField("name");
Fieldyyb annotation = field.getAnnotation(Fieldyyb.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@Tableyyb("db_student")
class Student1 {
@Fieldyyb(columnName = "db_id", type = "int", length = 10)
private int id;
@Fieldyyb(columnName = "db_age", type = "int", length = 10)
private int age;
@Fieldyyb(columnName = "db_name", type = "Varchar", length = 10)
private String name;
public Student1() {
}
public Student1(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student1{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tableyyb {
String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldyyb {
String columnName(); //列名
String type(); //类型
int length(); //长度
}
最后总结:
- 获取class类的方式
- 通过对象获得
- 通过forName获得
- 通过.class获得
- 通过反射获得属性和方法
- getDeclaredFields() 获得本类的所有属性
- getDeclaredFields(“要获取的属性名称”) 获取本类的指定属性
- getFields() 获取本类及其父类的所有属性
- getFields(“要获取的属性名称”) 获取本类及其父类的指定属性
- getMethods(); 获取本类及其子类的所有方法
- getMethod(“getName”, null);获取本类及其子类的指定方法 第一个参数为方法名 第二个参数为需要传递的参数(例如:get方法一般为null,set方法为int.class或者其它类型的.class形式)
- getDeclaredMethods(); 获取本类的所有方法
- getDeclaredMethod(“getName”, null)获取本类的指定方法
- 通过反射调用指定的方法
- invoke(对象,“方法的值”)方法
- setAccessible(true) 关掉权限检测
具体操作请看上文例子