反射与注解-CSDN博客

本文链接：https://blog.csdn.net/qq_50545335/article/details/123787013

反射 : 动态机制

定义：唯一的一个动态机制
Java反射机制，可以实现以下功能：

    ①在运行时判断任意一个对象所属的类；
    ②在运行时构造任意一个类的对象；
    ③在运行时判断任意一个类所具有的成员变量和方法；
    ④在运行时调用任意一个对象的方法；
    ⑤生成动态代理；

发生在程序运行期间

反射的源头  : Class类型的对象

代码：

public class Class001_Reflect {
public static void main(String[] args) throws Exception {
    Properties pro = new Properties();
    pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("classname.properties"));
    Person p = (Person) Class.forName(pro.getProperty("classname")).newInstance();
    p.sleep();
}
}
class Person{
    public void sleep(){
        System.out.println("闭着眼睛休息");
    }
}
class Student extends Person{
    public void sleep(){
        System.out.println("一边上课一边睡觉");
    }
}
class Teacher extends Person{
    public void sleep(){
        System.out.println("一边敲代码一边睡觉");
    }
}

反射的源头 : Class : 类类实例表示正在运行的Java应用程序中的类和接口。

Class对象 : 当类加载到内存中,就会存在这个表示这个类型的Class对象,唯一的,不变的,独一份的

获取反射源头的方式:

    1.类名.class
    2.Class.forName("权限定名") -->推荐
    3.对象.getClass()

代码：

   public class Class002_Reflect {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<String> cls1 = String.class;
        System.out.println(cls1.toString());

    Class cls2 = Class.forName("java.lang.String");
    System.out.println(cls1==cls2);

    Class cls3 = "".getClass();
    System.out.println(cls1==cls3);

    //基本数据类型的Class对象
    Class cls = int.class;
    System.out.println(cls);

    System.out.println(cls==Integer.TYPE);  //T
    System.out.println(Integer.class);

    //类<?>[] getInterfaces() 返回由此对象表示的类或接口直接实现的接口。
    Class[] arr=  cls1.getInterfaces();
    System.out.println(Arrays.toString(arr));

    System.out.println(cls1.getSuperclass());

    //int getModifiers() 返回此类或接口的Java语言修饰符，以整数编码。
    System.out.println(cls1.getModifiers());
    System.out.println(Modifier.toString(cls1.getModifiers()));

    System.out.println(cls1.getName());
    System.out.println(cls1.getSimpleName());
}
}

通过反射创建对象

1.Class ->newInstance() 默认调用空构造为对象初始化信息–>不推荐使用
2.Constructor->newInstance() 创建对象

1.获取某一个类中构造器
    构造器<T> getConstructor(类<?>... parameterTypes) 返回一个 构造器对象，该对象反映此 类对象所表示的类的指定公共构造函数。
    构造器<?>[] getConstructors() 返回一个包含 构造器对象的数组， 构造器对象反映了此 类对象所表示的类的所有公共构造函数。
    构造器<T> getDeclaredConstructor(类<?>... parameterTypes) 返回一个 构造器对象，该对象反映此 类对象所表示的类或接口的指定构造函数。
    构造器<?>[] getDeclaredConstructors() 返回 构造器对象的数组， 构造器对象反映由此 类对象表示的类声明的所有构造函数。

2.调用Constructor类提供的newInstance方法,创建对象的时候调用当前构造器初始化信息

代码：

  public class Class003_Constructor {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    //1.创建对象
    System.out.println(Employee.class.newInstance());
    //获取构造器
    Constructor[] cons=Employee.class.getConstructors();
    System.out.println(Arrays.toString(cons));
    System.out.println("----------------------");
    Constructor<Employee>con=  Employee.class.getDeclaredConstructor(int.class,String.class);
    System.out.println(con);

    //2.创建 对象
    //私有的构造器先忽略权限再次使用
    con.setAccessible(true);
    Employee emp=  con.newInstance(1001,"刘亦菲");
    System.out.println(emp);
}
}

通过反射操作成员

操作方法

1.获取方法
       方法 getMethod(String name, 类<?>... parameterTypes) 返回 方法对象，该对象反映此 类对象表示的类或接口的指定公共成员方法。
       方法[] getMethods() 返回一个包含 方法对象的数组， 方法对象反映此 类对象所表示的类或接口的所有公共方法，包括由类或接口声明的那些以及从超类和超接口继承的那些。
       方法 getDeclaredMethod(String name, 类<?>... parameterTypes) 返回 方法对象，该对象反映此 类对象表示的类或接口的指定声明方法。
       方法[] getDeclaredMethods() 返回一个包含 方法对象的数组， 方法对象反映此 类对象表示的类或接口的所有已声明方法，包括public，protected，default（package）访问和私有方法，但不包括继承的方法。

2.调用方法
       Object invoke(Object obj, Object... args) 在具有指定参数的指定对象上调用此 方法对象表示的基础方法。

操作属性

1.获取属性
       字段 getField(String name) 返回 字段对象，该对象反映此 类对象表示的类或接口的指定公共成员字段。
       字段[] getFields() 返回一个包含 字段对象的数组， 字段对象反映此 类对象所表示的类或接口的所有可访问公共字段。
       字段 getDeclaredField(String name) 返回 字段对象，该对象反映此 类对象表示的类或接口的指定声明字段。
       字段[] getDeclaredFields() 返回 字段对象的数组， 字段对象反映由此 类对象表示的类或接口声明的所有字段。

2.获取属性值
       Object get(Object obj) 返回指定对象上此 字段表示的字段的值。
3.设置属性值
       void set(Object obj, Object value) 将指定对象参数上此 字段对象表示的字段设置为指定的新值。

代码：

//通过反射操作成员
public class Class004_Member {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Employee emp=new Employee();
        testMethod(Employee.class,emp);
        testField(Employee.class,emp);
    }
    // 操作方法
    public  static void testMethod(Class<Employee> cls, Employee emp) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //获取所有公共的方法
       Method[] arr= cls.getMethods();
       Arrays.stream(arr).forEach(System.out::println);
       //获取指定的方法
       Method method= cls.getDeclaredMethod("testPrivate");
        System.out.println(method);

        method.setAccessible(true);
        //调用方法
        System.out.println(method.invoke(emp));
        //静态方法 存在返回值  可以跟随对象调用|可以跟随类名调用
        for (Method m:arr){
            if ("testStatic".equals(m.getName())){
                System.out.println(m.invoke(null,1000));
            }
        }

}
//操作属性
public  static void testField(Class<Employee> cls,Employee emp) throws NoSuchFieldException, IllegalAccessException {
    //获取所有公共的
  Field[] fields= cls.getFields();
    System.out.println(Arrays.toString(fields));
    //根据属性名获取指定的属性
   Field field= cls.getDeclaredField("name");
    System.out.println(field);
    //忽略权限
    field.setAccessible(true);
    field.set(emp,"刘亦菲");
    System.out.println(field.get(emp));

}
}

Properties

定义：Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。属性列表中的每个键及其对应的值都是一个字符串。
Properties常用做配置文件使用
定义使用步骤：

1.src下新建文件 xx.properties
2.创建Properties类型的对象
3.调用load(InputStream|Reader)
4.根据key获取value  getProperty(key)

代码：

public class Class001_Properties {
public static void main(String[] args) throws IOException {
    Properties pro = new Properties();
    //从流中加载数据
    pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));

    System.out.println(pro.getProperty("username"));
    System.out.println(pro.getProperty("password"));
}
}

注解：标注

dk1.5新增
作用：

1.具有解释说明的作用
2.强制检查，检测的作用
3.注解可以存在Class文件中
4.定义注解的时候同时传递数据，程序运行期间可以通过反射获取数据使用
5.大量代替了配置文件

使用：

@注解名（参数）

位置：

任意位置

分类

参数个数分

1.标记注解：0个
2.单值注解：1个
3.完整注解：多个

jdk内置注解

简单的内置注解：
    @Override：强制检测是否为重写方法
    @FunctionalInterface : 强制检测是否为函数式接口
    @Deprecated：标记已过时
    @SuppressWarnings：抑制警告
元注解 : 注解的注解
    @Target用于描述注解的使用范围
    @Retention表示需要在什么级别保存该注释信息，用于描述注解的生命周期
    @Documented表示使用该注解的元素应被javadoc或类似工具文档化
    @Inherited 表示一个注解类型会被自动继承

自定义注解

   1.通过@interface定义注解类型
   2.自定义的注解默认隐式的实现java.lang.annotation.Annotation接口
   3.并不能显示实现 其他接口,继承其他父类
   4.注解类中可以自定义定义属性|字段
   5.注解类属性的定义 : 数据类型 属性名();
   6.字段|属性类型只能为 : 基本数据类型 String enum annotation 或者以上类型的数组
   7.注解类型 中字段|属性只有一个,名字建议定义value,赋值的时候可以省略value=
   8.字段可以定义默认值 通过default关键字
注意: 如果通过反射操作注解,需要声明周期为@Retention(RetentionPolicy.RUNTIME)

注意 : 面向对象设计原则之一: 开闭原则
代码：

  public class Class003_FruitList {
public static void main(String[] args) throws IllegalAccessException {
    FruitList list=new FruitList();
    list.pair=0;
    System.out.println(list);
    System.out.println(testFruitList(list,FruitList.class));
}
//注解解析器
static  FruitList testFruitList(FruitList fruitList,Class<FruitList> cls) throws IllegalAccessException {
    //获取FruitList类所有属性
    Field[] arr= cls.getDeclaredFields();
    //遍历,拿到每一个属性判断,是否已经为属性赋值,已赋值略过,
    for (Field field:arr){
        //没有赋值,判断会是否属性存在默认值,如果不存在略过,存在获取默认值为当属性赋值
      if (field.get(fruitList)==null){
          System.out.println("------------");
          if (field.isAnnotationPresent(Num.class)){
              Num num=  field.getAnnotation(Num.class);
              field.set(fruitList,num.value());
          }
      }
  }
    return fruitList;
}
}

class FruitList{
    @Num(20)
    Integer apple;
    @Num(15)
    Integer pair;
    @Num(4)
    Integer banana;
    Integer strawberry;

public FruitList() {
}

public FruitList(Integer apple, Integer pair, Integer banana, Integer strawberry) {
    this.apple = apple;
    this.pair = pair;
    this.banana = banana;
    this.strawberry = strawberry;
}

@Override
public String toString() {
    return "FruitList{" +
            "apple=" + apple +
            ", pair=" + pair +
            ", banana=" + banana +
            ", strawberry=" + strawberry +
            '}';
}
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface  Num{
    int value() default 1;
}