19_反射与标注

于 2019-08-18 18:11:06 发布
阅读量126 收藏 1
点赞数 1
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45044194/article/details/99707536
版权

百知教育 - 孙帅 - 19_反射与标注

01_类对象的概念

  • 类的对象：
    基于某个类new出来的对象，也称为实例对象。
  • 类对象：
    类加载的产物，封装了一个类的所有信息（类名、父类、接口、属性、方法、构造方法）。
  • 获取类对象的方法：
    1. 类名.class: 如：int.class、double.class
      Class c1 = ArrayList.class;
    2. 类的对象.getClass()
      ArrayList l1 = new ArrayList();
ArrayList l2 = new ArrayList();
Class c2 = l1.getClass();
Class c3 = l2.getClass();
    3. Class.forName(“类的全名”): 通过类名获得类对象
      Class c4 = Class.forName("java.util.ArrayList");

02_利用反射获取类的信息

  • java.lang.reflect中的类：
    1. Field： 属性
      • 获取此类对象的方法：
        • getFields(): 获得 公开属性 （ 包括父类 ）
        • getDeclaredFields()： 获得 所有属性（只包括本类）
    2. Method： 方法
      • 获取此类对象的方法：
        • getMethods()： 获取公开方法（包括父类）
        • getDeclaredMethods()： 获取所有方法（只包括本类）
    3. Constructor： 构造方法
      • 获取此类对象的方法：
        • getConstructors()： 获取公开构造方法（包括父类）
        • getDeclaredConstructors()： 获取所有构造方法（只包括本类）
  • 代码：
    package day25;
import java.util.ArrayList;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
public class TestClass{
 public static void main(String[] args){  
  Class c1 = ArrayList.class;
  
  /*
  ArrayList l1 = new ArrayList();
  ArrayList l2 = new ArrayList();
  Class c2 = l1.getClass();
  Class c3 = l2.getClass();
  
  try{
   Class c4 = Class.forName("java.util.ArrayList");
  }catch(ClassNotFoundException e){
   e.printStackTrace();
  }
  
  System.out.println(c1.getName());
  System.out.println(c1.getPackage().getName());
  System.out.println(c2.getSuperclass().getName());
  
  Class[] cs = c1.getInterfaces();
  for(Class c : cs){
   System.out.println(c.getName());
  }
  */
  
  /*
  Field[] fs = c1.getDeclaredFields();
  for(Field f : fs){
   System.out.println(f);
  }
  */
  
  /*
  Method[] ms = c1.getDeclaredMethods();
  for(Method m : ms){
   System.out.println(m);
  }
  */
  
  Constructor[] cs = c1.getDeclaredConstructors();
  for(Constructor c : cs){
   System.out.println(c);
  }
 }
}
  • 运行结果：
    在这里插入图片描述

03_利用反射实现常规操作

  • 代码：
    package day25;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class TestReflection{
 public static void main(String[] args) throws Exception{
  //Object o = new Student();
  Class c = Class.forName("day25.Student");
  Object o = c.newInstance();
  
  //Object o2 = new Student("YKY" , 20);
  Constructor con = c.getConstructor(String.class , int.class);
  Object o2 = con.newInstance("YKY" , 20);
  
  //o2.study();
  Method m = c.getMethod("study");
  m.invoke(o2);
  m.invoke(o);  //o.study();
  
  //int result = o2.study("CoreJava");
  Method m2 = c.getMethod("study" , String.class);
  Object result = m2.invoke(o2 , "CoreJava");
  System.out.println(result);
 }
}
class Student{
 private String name;
 private int age;
 
 
 public Student(){
  super();
  System.out.println("Student()");
 }
 public Student(String name , int age){
  super();
  this.name = name;
  this.age = age;
  System.out.println("Student(String , int)");
 }
 
 public void study(){
  System.out.println("Student "+name+" study");
 }
 public int study(String course){
  System.out.println("Student "+name+" study "+course);
  return 100;
 }
}
  • 运行结果：
    在这里插入图片描述

04_利用反射访问私有成员

  • 代码：
    package day25;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Field;
public class TestReflection{
 public static void main(String[] args) throws Exception{
  //Object o = new Student();
  Class c = Class.forName("day25.Student");
  Object o = c.newInstance();
  
  //Object o2 = new Student("YKY" , 20);
  Constructor con = c.getConstructor(String.class , int.class);
  Object o2 = con.newInstance("YKY" , 20);
  
  //o2.study();
  Method m = c.getDeclaredMethod("study");
  m.setAccessible(true);
  m.invoke(o2);
  m.invoke(o);  //o.study();
  
  //int result = o2.study("CoreJava");
  Method m2 = c.getMethod("study" , String.class);
  Object result = m2.invoke(o2 , "CoreJava");
  System.out.println(result);
  
  Field f = c.getDeclaredField("name");
  f.setAccessible(true);
  System.out.println(f.get(o));
  f.set(o , "YKY");
  System.out.println(f.get(o));
 }
}
class Student{
 private String name;
 private int age;
 
 
 public Student(){
  super();
  System.out.println("Student()");
 }
 public Student(String name , int age){
  super();
  this.name = name;
  this.age = age;
  System.out.println("Student(String , int)");
 }
 
 private void study(){
  System.out.println("Student "+name+" study");
 }
 public int study(String course){
  System.out.println("Student "+name+" study "+course);
  return 100;
 }
}
  • 运行结果：
    在这里插入图片描述

05_枚举的概念

  • 概念：
    可看做一个类，拥有的对象 是 特定的几个值，默认无参构造方法为私有。
  • 语法：
    enum  枚举名{
	枚举值，
	枚举值，
	枚举值
}
  • 访问：
    枚举名.枚举值
  • 枚举值：
    是枚举类中的 公开静态常量，类型为枚举类型。
  • 代码(编译通过)：
    package day25;
public class TestEnum{
 public static void main(String[] args){
  Order o = new Order();
  o.status = State.PAYED;
 }
}
class Order{
 public State status = State.UNPAY;
}
enum State{  //等价于类State2
 UNPAY,
 PAYED,
 SENT,
 RECEIVED
}
class State2{
 public static final State2 UNPAY = new State2();
 public static final State2 PAYED = new State2();
 public static final State2 SENT = new State2();
 public static final State2 RECEIVED = new State2();
}

06_枚举的语法

  • Enum
    默认是所有枚举的父类
  • 代码：
    package day25;
import static day25.State.*;  //引入静态属性、方法
import static java.lang.System.*;
public class TestEnum{
 public static void main(String[] args){
  Order o = new Order();
  o.status = PAYED;
  
  State[] states = values();
  for(State state : states){
   out.println(state.name()+"   "+state.getComment()+"   "+state.ordinal());
  }
  
  out.println("nanoTime:  "+nanoTime());
 }
}
class Order{
 public State status = UNPAY;
}
enum State{  //具有有参构造方法的枚举，等价于类State2
 UNPAY("未支付"),
 PAYED("已支付"),
 SENT("已发货"),
 RECEIVED("已收货");
 
 private String comment;
 private State(String s){
  comment = s;
 }
 public String getComment(){
  return comment;
 }
}
class State2{  
 public static final State2 UNPAY = new State2("未支付");
 public static final State2 PAYED = new State2("已支付");
 public static final State2 SENT = new State2("已发货");
 public static final State2 RECEIVED = new State2("已收货");
 
 private String comment;
 private State2(String s){
  comment = s;
 }
 public String getComment(){
  return comment;
 }
}
enum EnumA{  //枚举中含有抽象方法时，枚举值定义时要实现抽象方法
 A1(){
  public void print(){}
 },
 A2(){
  public void print(){}
 };
 
 public abstract void print();
}
abstract class B{
 public static final B B1 = new B(){
  public void print(){}
 };
 public static final B B2 = new B(){
  public void print(){}
 };
 
 public abstract void print();
 private B(){}
}
  • 运行结果：
    在这里插入图片描述

07_自定义标注

  • 概念：
    表述代码的代码
  • 分类：
    1. 标记标注： 没有属性。写法： @标注名
    2. 单值标注： 一个属性。写法： @标注名（属性名 = 属性值） ，如果 属性名为value，可以简写为： @标注名（属性值）
    3. 多值标注： 多个属性。写法： @标注名（属性名1 = 属性值1 ， 属性名2 = 属性值2 …）
  • 标注属性类型：
    必须是具有字面值的类型（8中基本类型、String、Enum、Class以及它们的数组）
  • 元标注：
    1. Target： 描述可以为哪些程序组件添加此标注（程序组件：类、属性、构造方法、方法 …）
    2. Retention： 描述标注信息保留到什么时候（取值：SOURCE、CLASS、RUNTIME）
  • 代码：
    package day25;
import java.lang.annotation.Target;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.*;
import static java.lang.annotation.ElementType.*;
import java.lang.reflect.Method;
public class TestAnnotation{
 public static void main(String[] args){
  Class c = MyClass.class;
  
  Method[] ms = c.getMethods();
  for(Method m : ms){
   if(m.isAnnotationPresent(Test.class)){
    Test t = m.getAnnotation(Test.class);
    String v1 = t.value();
    int v2 = t.value2();
    System.out.println(m.getName()+" value = "+v1+" value2 = "+v2);
   } 
  }
 }
}
class MyClass{
 @Test
 public void method1(){
  
 }
 @Test("HHH")
 public void method2(){
  
 }
 @Test(value = "HHH" , value2 = 19)
 public void method3(){
  
 }
 public void method4(){
  
 }
}
@Target(METHOD)
@Retention(RUNTIME)
@interface Test{
 String value() default "YKY";
 int value2() default 20;
}
  • 运行结果：
    在这里插入图片描述

08_自定义标注的案例

  • （对一个类自动测试）代码：
    package day26;
import java.lang.annotation.Target;
import java.lang.annotation.Retention;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.TreeMap;
import java.lang.reflect.Method;
import java.util.Collection;
public class TestAutoTestEngine{
 public static void main(String[] args){
  autoTest("day26.ClassA");
 }
 
 //根据className，自动创建对象，并按照Test标注，按顺序，用相应的参数，执行每个需要测试的方法
 public static void autoTest(String className){  //此函数功能相当于以下代码
  /*
  ClassA o = new ClassA();
  System.out.println(o.mb("YKY"));
  System.out.println(o.ma("HHH"));
  System.out.println(o.md("LYH"));
  System.out.println(o.mc("YXM"));
  */
  
  try{
   Class c = Class.forName(className);
   Object o = c.newInstance();
  
   TreeMap<Integer , Method> map = new TreeMap<>();
   //拿到c类中所有公开方法
   Method[] ms = c.getMethods();
   for(Method m : ms){
    //拿到添加了Test标注的方法中的Order
    if(m.isAnnotationPresent(Test.class)){
     Test t = m.getAnnotation(Test.class);
     int order = t.order();
     //利用TreeMap key:order  value:Method
     map.put(order , m);
    }
   }
   //遍历TreeMap的值，依次调用每个方法
   Collection<Method> values = map.values();
   for(Method m : values){
    Test t = m.getAnnotation(Test.class);
    String parameter = t.parameter();
    Object result = m.invoke(o , parameter);
    System.out.println(result);
   }
  }catch(Exception e){
   e.printStackTrace();
  }
 }
}
class ClassA{
 @Test(order = 2 , parameter = "HHH")
 public String ma(String s){
  return "ma "+s;
 }
 @Test(order = 1 , parameter = "YKY")
 public String mb(String s){
  return "mb "+s;
 }
 @Test(order = 4 , parameter = "YXM")
 public String mc(String s){
  return "mc "+s;
 }
 @Test(order = 3 , parameter = "LYH")
 public String md(String s){
  return "md "+s;
 }
}
@Target(METHOD)
@Retention(RUNTIME)
@interface Test{
 int order();
 String parameter();
}
  • 运行结果：
    在这里插入图片描述
cherishIntention
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
chapter 01习题
m0_45044194的博客
05-20 1719
百知教育学习 - 胡鑫喆 - chapter 01习题 1. （标识符命名）下面几个变量中，哪些是对的？哪些是错的？错的请说明理由 A.ILoveJava B.$20 C.learn@java D.antony.lee E.Hello_World F.2tigers 代码/* * A right * B right * C wrong --> @ 不能出...
chapter 03函数习题
m0_45044194的博客
05-20 426
百知教育学习 - 胡鑫喆 - chapter 03函数习题 题目链接 提取码：nxo0 1.代码 package chapter_03; import java.util.*; public class Practice_03_01{ public static void main(String[] args) { Scanner s = new Scanner(System.in); ...
chapter 02循环结构习题
m0_45044194的博客
05-20 412
百知教育学习 - 胡鑫喆 - chapter 02循环结构习题 题目链接 提取码：a53a 1.代码 package chapter_02; public class Practice_02_01{ public static void main(String[] args) { int sum = 0; for(int i = 1; i < 101; i++) { su...
chapter 04 数组
m0_45044194的博客
06-05 292
百知教育学习 - 胡鑫喆 - chapter 04 数组 题目链接 提取码：h008 1、代码 package chapter_04; public class Practice_04_01{ public static void main(String[] args) { /* A 正确 * B 正确 * C 错误 --> int[] a = {1,2,3,4,5};...
循环与分支结构
m0_45044194的博客
05-19 279
百知教育学习 - 胡鑫喆 - 循环与分支结构 一、if选择结构与分支结构 if 语法 if（布尔表达式） { 代码块 } 在java中if的条件中只能写布尔表达 式，不能写整数表达式。 代码package day3; import java.util.Scanner; public class TestIf{ public static void main(String[] args){ ...
16_多线程（续）
m0_45044194的博客
08-07 253
百知教育 - 孙帅 - 16_多线程（续） 14_深入比较ArrayList和Vector Collections工具类中提供了多个可以获得线程安全集合的方法(均以synchronized实现)： public static < T > Collection synchronizedCollection(Collection c) public static < T &g...
18_网络编程
m0_45044194的博客
08-16 236
百知教育 - 孙帅 - 18_网络编程 01_网络基础 网络： 若干主机(host) 形成的有机整体； 按提供的服务不同，可以分为客户端、服务器 IP地址 标识网络主机的逻辑地址（192.168.0.1 四分十进制） 端口号 用来标识主机中的进程。 进程会预先绑定唯一的端口号，用来对外部 监听。 端口号范围：0-65535，其中0-1024为 预留端口。 四层协议 应...
14_集合框架
m0_45044194的博客
08-01 230
百知教育 - 孙帅 - 14_集合框架 01_集合的概念 集合： 是一种工具类，是对象的容器，可以用于存储数量不等的多个对象的对象，代替数组 所有集合的接口和相关实现类都在java.util包中 底层结构： 数组 代码： package day15; import java.util.Arrays; public class TestMyList{ public static voi...
14_集合框架(续)
m0_45044194的博客
08-02 212
百知教育 - 孙帅 - 14_集合框架(续) 13_List的排序 代码： 在这里插入代码片
17_IO 编程
m0_45044194的博客
08-08 199
百知教育 - 孙帅 - 17_IO 编程 01_IO流的概念和分类 流 流就是内存与存储设备之间 传输数据 的通道、管道。 IO流的分类 按方向（以JVM虚拟机为参照物）【重点】 输入流： 将<存储设备>中的内容 读入 到<内存>中。 输出流： 将<内存>中的内容 写入 到<存储设备>中。 按单位 字节流： 以字节为单位，可以操作 所...
数组
m0_45044194的博客
06-05 194
百知教育学习 - 胡鑫喆 - 数组 一、数组的认识 概念： 一组连续的存储空间，存储多个相同数据类型的值。 数组的遍历 二、数组创建语法 先声明、再分配空间： 数组类型[] 数组名； 数组名 = new 数据类型[长度] 声明并分配空间： 数据类型[] 数组名 = new 数据类型[长度] 声明并赋值（繁） 数据类型[] 数组名 = new 数据类型[]{ value 1, valu...
16_多线程
m0_45044194的博客
08-06 194
百知教育 - 孙帅 - 16_多线程 01_线程的概念和实现线程的方式 什么是进程 程序是静止的，只有真正运行时的程序，才被称为进程。 单核CPU在任何时间点上，只能运行一个进程；宏观并行、微观串行。 什么是线程 线程，又称为 轻量级进程（Light Weight Process）。 是程序中的 一个顺序控制流程，同时也是 CPU的基本调度单位。进程由多个线程组成，彼此间完成不同的工...
10_接口
m0_45044194的博客
07-20 167
百知教育 - 孙帅 - 10_接口 01_接口的基础语法 接口（特殊的抽象类）语法： 属性都是 公开静态常量 public static final 方法都是 公开抽象方法 public abstract 没有构造方法 实现接口语法： class 类名 implements 接口名 一个类实现接口，如果这个类不希望称为抽象类，就必须实现接口中的所有抽象方法 02_接口和类的关系 ...
Java概述与环境搭建
m0_45044194的博客
05-18 165
百知教育学习 - 胡鑫喆 - Java概述与环境搭建 一、编程语言 分类： 自然语言（和人交流） 机器语言（和计算机交流） 编程语言 编程语言： c c++ --> 面向对象 Java -->纯面向对象 二、Java的历史 Java是由Sun公司开发的，Sun公司已被Oracle公司收购 基于跨平台的需求，Oak项目组开发的Java 1995.5.23 发布了J...
08_面向对象的三大特性
m0_45044194的博客
07-07 157
百知教育 - 孙帅 - 08_面向对象的三大特性 01_封装 概念： 尽可能 隐藏 对象内部实现细节，控制 对象的修改及访问的 权限。 访问修饰符： private（可将属性修饰为 私有 ，仅本类可见） 公共访问方法： 作用： 提供公共访问方法，以保证数据的 正常录入。 命名规范： 赋值：setXXX() //使用方法返回值实现赋值 取值：getXXX() //使用方法返回值实现取值...
基于NSGA-II的智能车辆换道轨迹规划与优化_查云飞.caj
最新发布
07-31
基于NSGA-II的智能车辆换道轨迹规划与优化_查云飞
chromedriver-mac-x64_122.0.6261.111.zip
07-31
chromedriver-mac-x64_122.0.6261.111.zip
chromedriver-mac-arm64_127.0.6485.0.zip
07-31
chromedriver-mac-arm64_127.0.6485.0.zip
Java本地接口开发手册.zip
07-31
Java本地接口开发手册
AutoCAD尺寸与文字标注教程
"CAD绘图教程(包括天正建筑)第九章尺寸标注与文字标注" 在计算机辅助设计(CAD)中，尺寸标注和文字标注是至关重要的组成部分，它们确保了图纸的准确性和清晰度，方便制造者理解和实现设计意图。本教程主要针对Auto...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值