第二十章 反射

1. 反射机制概述

1.1 反射机制有什么用？

通过java语言中的反射机制可以操作字节码文件，优点类似于黑客；（可以读和修改字节码文件。）通过反射机制可以操作代码片段。（class文件。）

1.2 反射机制的相关类在哪个包下？

java.lang.reflect.*;

1.3 反射机制相关的重要的类有哪些？

java.lang.Class：代表整个字节码，代表一个类型，代表整个类
java.lang.reflect.Method：代表字节码中的方法字节码，代表类中的方法
java.lang.reflect.Constructor：代表字节码中的构造方法字节码，代表类中的构造方法
java.lang.reflect.Field：代表字节码中的属性字节码，代表类中的成员变量（静态变量+实例变量）

2. 获取class的三种方式

  1. import java.util.Date;
  3. /*
  4. 要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取java.lang.Class实例？
  5.     三种方式
  6.         第一种：Class c = Class.forName("完整类名带包名");
  7.         第二种：Class c = 对象.getClass();
  8.         第三种：Class c = 任何类型.class;
  9.  */
  10. public class ReflectTest01 {
  11.     public static void main(String[] args) {
  12.         /*
  13.         Class.forName()
  14.             1、静态方法
  15.             2、方法的参数是一个字符串。
  16.             3、字符串需要的是一个完整类名。
  17.             4、完整类名必须带有包名。java.lang包也不能省略。
  18.             该方法适用于只想让一个类的静态代码块执行，对该方法的返回值不感兴趣，主要是为了使用‘类加载’这个动作
  19.          */
  20.         Class c1 = null;
  21.         Class c2 = null;
  22.         try {
  23.             c1 = Class.forName("java.lang.String"); // c1代表String.class文件，或者说c1代表String类型。
  24.             c2 = Class.forName("java.util.Date"); // c2代表Date类型
  25.             Class c3 = Class.forName("java.lang.Integer"); // c3代表Integer类型
  26.             Class c4 = Class.forName("java.lang.System"); // c4代表System类型
  27.         } catch (ClassNotFoundException e) {
  28.             e.printStackTrace();
  29.         }
  31.         // java中任何一个对象都有一个方法：getClass()
  32.         String s = "abc";
  33.         Class x = s.getClass(); // x代表String.class字节码文件，x代表String类型。
  34.         System.out.println(c1 == x); // true（==判断的是对象的内存地址。）
  36.         Date time = new Date();
  37.         Class y = time.getClass();
  38.         System.out.println(c2 == y); // true (c2和y两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件。)
  40.         // 第三种方式，java语言中任何一种类型，包括基本数据类型，它都有.class属性。
  41.         Class z = String.class; // z代表String类型
  42.         Class k = Date.class; // k代表Date类型
  43.         Class f = int.class; // f代表int类型
  44.         Class e = double.class; // e代表double类型
  46.         System.out.println(x == z); // true
  48.     }
  49. }

复制类的路径（含包名，类名右键“Copy reference”）

jdk1.8 可以找到jdk的class文件：在jre下面的lib里有一个rt.jar的文件 jdk\jre\lib

3. 通过反射实例化对象

  1. import com.bjpowernode.java.bean.User;
  3. /*
  4. 获取到Class，能干什么？
  5.     通过Class的newInstance()方法来实例化对象。
  6.     注意：newInstance()方法内部实际上调用了无参数构造方法，必须保证无参构造存在才可以。
  7.  */
  8. public class ReflectTest02 {
  9.     public static void main(String[] args) {
  11.         // 这是不使用反射机制，创建对象
  12.         User user = new User();
  13.         System.out.println(user);
  15.         // 下面这段代码是以反射机制的方式创建对象。
  16.         try {
  17.             // 通过反射机制，获取Class，通过Class来实例化对象
  18.             Class c = Class.forName("com.bjpowernode.java.bean.User"); // c代表User类型。
  20.             // newInstance() 这个方法会调用User这个类的无参数构造方法，完成对象的创建。
  21.             // 重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的！
  22.             Object obj = c.newInstance();
  24.             System.out.println(obj); // com.bjpowernode.java.bean.User@10f87f48
  25.         } catch (ClassNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IllegalAccessException e) {
  28.             e.printStackTrace();
  29.         } catch (InstantiationException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

4. 通过配置文件实例化对象

  1. import java.io.FileReader;
  2. import java.util.Properties;
  4. /*
  5. 验证反射机制的灵活性。
  6.     java代码写一遍，再不改变java源代码的基础之上，可以做到不同对象的实例化。
  7.     非常之灵活。（符合OCP开闭原则：对扩展开放，对修改关闭。）
  9. 后期你们要学习的是高级框架，而工作过程中，也都是使用高级框架，
  10. 包括： ssh ssm
  11.     Spring SpringMVC MyBatis
  12.     Spring Struts Hibernate
  13.     ...
  14.     这些高级框架底层实现原理：都采用了反射机制。所以反射机制还是重要的。
  15.     学会了反射机制有利于你理解剖析框架底层的源代码。
  16.  */
  17. public class ReflectTest03 {
  18.     public static void main(String[] args) throws Exception{
  20.         // 这种方式代码就写死了。只能创建一个User类型的对象
  21.         //User user = new User();
  23.         // 以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，
  24.         //可以创建出不同的实例对象。
  25.         // 通过IO流读取classinfo.properties文件
  26.         FileReader reader = new FileReader("chapter25/classinfo2.properties");
  27.         // 创建属性类对象Map
  28.         Properties pro = new Properties(); // key value都是String
  29.         // 加载
  30.         pro.load(reader);
  31.         // 关闭流
  32.         reader.close();
  34.         // 通过key获取value
  35.         String className = pro.getProperty("className");
  36.         //System.out.println(className);
  38.         // 通过反射机制实例化对象
  39.         Class c = Class.forName(className);
  40.         Object obj = c.newInstance();
  41.         System.out.println(obj);
  42.     }
  43. }

4.1 只让静态代码块执行

  1. /*
  2. 研究一下：Class.forName()发生了什么？
  3.     记住，重点：
  4.         如果你只是希望一个类的静态代码块执行，其它代码一律不执行，
  5.         你可以使用：
  6.             Class.forName("完整类名");
  7.         这个方法的执行会导致类加载，类加载时，静态代码块执行。
  9. 提示：
  10.     后面JDBC技术的时候我们还需要。
  11.  */
  12. public class ReflectTest04 {
  13.     public static void main(String[] args) {
  14.         try {
  15.             // Class.forName()这个方法的执行会导致：类加载。
  16.             Class.forName("com.bjpowernode.java.reflect.MyClass");
  17.         } catch (ClassNotFoundException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }

5. 获取一个文件的绝对路径

  1. import java.io.FileReader;
  3. /*
  4. 研究一下文件路径的问题。
  5. 怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的。
  6. 但前提是：文件需要在类路径下。才能用这种方式。
  7.  */
  8. public class AboutPath {
  9.     public static void main(String[] args) throws Exception{
  10.         // 这种方式的路径缺点是：移植性差，在IDEA中默认的当前路径是project的根。
  11.         // 这个代码假设离开了IDEA，换到了其它位置，可能当前路径就不是project的根了，这时这个路径就无效了。
  12.         //FileReader reader = new FileReader("chapter25/classinfo2.properties");
  14.         // 接下来说一种比较通用的一种路径。即使代码换位置了，这样编写仍然是通用的。
  15.         // 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
  16.         // 什么类路径下？凡是在src下的都是类路径下。【记住它】
  17.         // src是类的根路径。
  18.         /*
  19.         解释：
  20.             Thread.currentThread() 当前线程对象
  21.             getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
  22.             getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
  23.          */
  24.         String path = Thread.currentThread().getContextClassLoader()
  25.                 .getResource("classinfo2.properties").getPath(); // 这种方式获取文件绝对路径是通用的。
  27.         // 采用以上的代码可以拿到一个文件的绝对路径。
  28.         // /C:/Users/Administrator/IdeaProjects/javase/out/production/chapter25/classinfo2.properties
  29.         System.out.println(path);
  30.     }
  31. }

5.1 以流的形式直接返回

  1. import java.io.FileReader;
  2. import java.io.InputStream;
  3. import java.util.Properties;
  5. public class IoPropertiesTest {
  6.     public static void main(String[] args) throws Exception{
  8.         // 获取一个文件的绝对路径了！！！！！
  9.         /*
  10.         String path = Thread.currentThread().getContextClassLoader()
  11.                 .getResource("classinfo2.properties").getPath();
  12.         FileReader reader = new FileReader(path);
  13.         */
  15.         // 直接以流的形式返回。
  16.         InputStream reader = Thread.currentThread().getContextClassLoader()
  17.                 .getResourceAsStream("classinfo2.properties");
  19.         Properties pro = new Properties();
  20.         pro.load(reader);
  21.         reader.close();
  22.         // 通过key获取value
  23.         String className = pro.getProperty("className");
  24.         System.out.println(className);
  25.     }
  26. }

6. 资源绑定器

  1. import java.util.ResourceBundle;
  3. /*
  4. java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
  5. 使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。
  6.  */
  7. public class ResourceBundleTest {
  8.     public static void main(String[] args) {
  10.         // 资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
  11.         // 并且在写路径的时候，路径后面的扩展名不能写。
  12.         //ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
  14.         ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/java/bean/db");
  16.         String className = bundle.getString("className");
  17.         System.out.println(className);
  19.     }
  20. }

7. JDK中自带的类加载器

7.1 什么是类加载器？

专门负责加载类的命令/工具（ ClassLoader）

7.2 JDK中自带了3个类加载器

启动类加载器:rt.jar
扩展类加载器:ext/*.jar
应用类加载器:classpath

7.3 类加载分析：

String s = “abc”;
代码在开始执行之前，会将所需要类全部加载到JVM当中，通过类加载器加载，看到以上代码类加载器会找String.class文件，找到就加载，没找到则报异常

那么是怎么进行加载的呢？ 首先通过“启动类加载器”加载，启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar；（rt.jar中都是JDK最核心的类库）如果通过“启动类加载器”加载不到的时候，会通过”扩展类加载器”加载，扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext*.jar；如果“扩展类加载器”没有加载到，那么会通过“应用类加载器”加载，应用类加载器专门加载：classpath中的类

7.4 双亲委派机制

java中为了保证类加载的安全，使用了双亲委派机制。优先从启动类加载器中加载，这个称为“父”，“父”无法加载到，再从扩展类加载器中加载，这个称为“母”，双亲委派；如果都加载不到，才会考虑从应用类加载器中加载，直到加载到为止

8. 获取Field

  1. import java.lang.reflect.Field;
  2. import java.lang.reflect.Modifier;
  4. /*
  5. 反射Student类当中所有的Field（了解一下）
  6.  */
  7. public class ReflectTest05 {
  8.     public static void main(String[] args) throws Exception{
  10.         // 获取整个类
  11.         Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
  13.         //com.bjpowernode.java.bean.Student
  14.         String className = studentClass.getName();
  15.         System.out.println("完整类名：" + className);
  17.         String simpleName = studentClass.getSimpleName();
  18.         System.out.println("简类名：" + simpleName);
  20.         // 获取类中所有的public修饰的Field
  21.         Field[] fields = studentClass.getFields();
  22.         System.out.println(fields.length); // 测试数组中只有1个元素
  23.         // 取出这个Field
  24.         Field f = fields[0];
  25.         // 取出这个Field它的名字
  26.         String fieldName = f.getName();
  27.         System.out.println(fieldName);
  29.         // 获取所有的Field
  30.         Field[] fs = studentClass.getDeclaredFields();
  31.         System.out.println(fs.length); // 4
  33.         System.out.println("==================================");
  34.         // 遍历
  35.         for(Field field : fs){
  36.             // 获取属性的修饰符列表
  37.             int i = field.getModifiers(); // 返回的修饰符是一个数字，每个数字是修饰符的代号！！！
  38.             System.out.println(i);
  39.             // 可以将这个“代号”数字转换成“字符串”吗？
  40.             String modifierString = Modifier.toString(i);
  41.             System.out.println(modifierString);
  42.             // 获取属性的类型
  43.             Class fieldType = field.getType();
  44.             //String fName = fieldType.getName();
  45.             String fName = fieldType.getSimpleName();
  46.             System.out.println(fName);
  47.             // 获取属性的名字
  48.             System.out.println(field.getName());
  49.         }
  50.     }
  51. }

8.1 反编译filed

  1. //通过反射机制，反编译一个类的属性Field（了解一下）
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Modifier;
  6. public class ReflectTest06 {
  7.     public static void main(String[] args) throws Exception{
  9.         // 创建这个是为了拼接字符串。
  10.         StringBuilder s = new StringBuilder();
  12.         //Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
  13.         Class studentClass = Class.forName("java.lang.Thread");
  15.         s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + " {\n");
  17.         Field[] fields = studentClass.getDeclaredFields();
  18.         for(Field field : fields){
  19.             s.append("\t");
  20.             s.append(Modifier.toString(field.getModifiers()));
  21.             s.append(" ");
  22.             s.append(field.getType().getSimpleName());
  23.             s.append(" ");
  24.             s.append(field.getName());
  25.             s.append(";\n");
  26.         }
  28.         s.append("}");
  29.         System.out.println(s);
  31.     }
  32. }

8.2 通过反射机制访问一个java对象的属性

  1. import com.bjpowernode.java.bean.Student;
  3. import java.lang.reflect.Field;
  5. /*
  6. 必须掌握：
  7.     怎么通过反射机制访问一个java对象的属性？
  8.         给属性赋值set
  9.         获取属性的值get
  10.  */
  11. public class ReflectTest07 {
  12.     public static void main(String[] args) throws Exception{
  14.         // 我们不使用反射机制，怎么去访问一个对象的属性呢？
  15.         Student s = new Student();
  17.         // 给属性赋值
  18.         s.no = 1111; //三要素：给s对象的no属性赋值1111
  19.                     //要素1：对象s
  20.                     //要素2：no属性
  21.                     //要素3：1111
  23.         // 读属性值
  24.         // 两个要素：获取s对象的no属性的值。
  25.         System.out.println(s.no);
  27.         // 使用反射机制，怎么去访问一个对象的属性。（set get）
  28.         Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
  29.         Object obj = studentClass.newInstance(); // obj就是Student对象。（底层调用无参数构造方法）
  31.         // 获取no属性（根据属性的名称来获取Field）
  32.         Field noFiled = studentClass.getDeclaredField("no");
  34.         // 给obj对象(Student对象)的no属性赋值
  35.         /*
  36.         虽然使用了反射机制，但是三要素还是缺一不可：
  37.             要素1：obj对象
  38.             要素2：no属性
  39.             要素3：2222值
  40.         注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。
  41.          */
  42.         noFiled.set(obj, 22222); // 给obj对象的no属性赋值2222
  44.         // 读取属性的值
  45.         // 两个要素：获取obj对象的no属性的值。
  46.         System.out.println(noFiled.get(obj));
  48.         // 可以访问私有的属性吗？
  49.         Field nameField = studentClass.getDeclaredField("name");
  51.         // 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会！！！）
  52.         // 这样设置完之后，在外部也是可以访问private的。
  53.         nameField.setAccessible(true);
  55.         // 给name属性赋值
  56.         nameField.set(obj, "jackson");
  57.         // 获取name属性的值
  58.         System.out.println(nameField.get(obj));
  59.     }
  60. }

9. 反射method

  1. /*
  2. 作为了解内容（不需要掌握）：
  3.     反射Method
  4.  */
  5. public class ReflectTest08 {
  6.     public static void main(String[] args) throws Exception{
  8.         // 获取类了
  9.         Class userServiceClass = Class.forName("com.bjpowernode.java.service.UserService");
  11.         // 获取所有的Method（包括私有的！）
  12.         Method[] methods = userServiceClass.getDeclaredMethods();
  13.         //System.out.println(methods.length); // 2
  15.         // 遍历Method
  16.         for(Method method : methods){
  17.             // 获取修饰符列表
  18.             System.out.println(Modifier.toString(method.getModifiers()));
  19.             // 获取方法的返回值类型
  20.             System.out.println(method.getReturnType().getSimpleName());
  21.             // 获取方法名
  22.             System.out.println(method.getName());
  23.             // 方法的修饰符列表（一个方法的参数可能会有多个。）
  24.             Class[] parameterTypes = method.getParameterTypes();
  25.             for(Class parameterType : parameterTypes){
  26.                 System.out.println(parameterType.getSimpleName());
  27.             }
  28.         }
  29.     }
  30. }

9.1 反编译一个类的方法

  1. import java.lang.reflect.Method;
  2. import java.lang.reflect.Modifier;
  4. /*
  5. 了解一下，不需要掌握（反编译一个类的方法。）
  6.  */
  7. public class ReflectTest09 {
  8.     public static void main(String[] args) throws Exception{
  9.         StringBuilder s = new StringBuilder();
  10.         //Class userServiceClass = Class.forName("com.bjpowernode.java.service.UserService");
  11.         Class userServiceClass = Class.forName("java.lang.String");
  12.         s.append(Modifier.toString(userServiceClass.getModifiers()) + " class "+userServiceClass.getSimpleName()+" {\n");
  14.         Method[] methods = userServiceClass.getDeclaredMethods();
  15.         for(Method method : methods){
  16.             //public boolean login(String name,String password){}
  17.             s.append("\t");
  18.             s.append(Modifier.toString(method.getModifiers()));
  19.             s.append(" ");
  20.             s.append(method.getReturnType().getSimpleName());
  21.             s.append(" ");
  22.             s.append(method.getName());
  23.             s.append("(");
  24.             // 参数列表
  25.             Class[] parameterTypes = method.getParameterTypes();
  26.             for(Class parameterType : parameterTypes){
  27.                 s.append(parameterType.getSimpleName());
  28.                 s.append(",");
  29.             }
  30.             // 删除指定下标位置上的字符
  31.             s.deleteCharAt(s.length() - 1);
  32.             s.append("){}\n");
  33.         }
  35.         s.append("}");
  36.         System.out.println(s);
  37.     }
  38. }

9.2 通过反射调用一个对象的方法

  1. import com.bjpowernode.java.service.UserService;
  3. import java.lang.reflect.Method;
  5. /*
  6. 重点：必须掌握，通过反射机制怎么调用一个对象的方法？
  7.     五颗星*****
  9.     反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，
  10.     将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，
  11.     但是java代码不需要做任何改动。这就是反射机制的魅力。
  12.  */
  13. public class ReflectTest10 {
  14.     public static void main(String[] args) throws Exception{
  15.         // 不使用反射机制，怎么调用方法
  16.         // 创建对象
  17.         UserService userService = new UserService();
  18.         // 调用方法
  19.         /*
  20.         要素分析：
  21.             要素1：对象userService
  22.             要素2：login方法名
  23.             要素3：实参列表
  24.             要素4：返回值
  25.          */
  26.         boolean loginSuccess = userService.login("admin","123");
  27.         //System.out.println(loginSuccess);
  28.         System.out.println(loginSuccess ? "登录成功" : "登录失败");
  30.         // 使用反射机制来调用一个对象的方法该怎么做？
  31.         Class userServiceClass = Class.forName("com.bjpowernode.java.service.UserService");
  32.         // 创建对象
  33.         Object obj = userServiceClass.newInstance();
  34.         // 获取Method
  35.         Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
  36.         //Method loginMethod = userServiceClass.getDeclaredMethod("login", int.class);
  37.         // 调用方法
  38.         // 调用方法有几个要素？ 也需要4要素。
  39.         // 反射机制中最最最最最重要的一个方法，必须记住。
  40.         /*
  41.         四要素：
  42.         loginMethod方法
  43.         obj对象
  44.         "admin","123" 实参
  45.         retValue 返回值
  46.          */
  47.         Object retValue = loginMethod.invoke(obj, "admin","123123");
  48.         System.out.println(retValue);
  49.     }
  50. }

10. 反射constructor

  1. import java.lang.reflect.Constructor;
  2. import java.lang.reflect.Modifier;
  4. /*
  5. 反编译一个类的Constructor构造方法。
  6.  */
  7. public class ReflectTest11 {
  8.     public static void main(String[] args) throws Exception{
  9.         StringBuilder s = new StringBuilder();
  10.         Class vipClass = Class.forName("java.lang.String");
  11.         s.append(Modifier.toString(vipClass.getModifiers()));
  12.         s.append(" class ");
  13.         s.append(vipClass.getSimpleName());
  14.         s.append("{\n");
  16.         // 拼接构造方法
  17.         Constructor[] constructors = vipClass.getDeclaredConstructors();
  18.         for(Constructor constructor : constructors){
  19.             //public Vip(int no, String name, String birth, boolean sex) {
  20.             s.append("\t");
  21.             s.append(Modifier.toString(constructor.getModifiers()));
  22.             s.append(" ");
  23.             s.append(vipClass.getSimpleName());
  24.             s.append("(");
  25.             // 拼接参数
  26.             Class[] parameterTypes = constructor.getParameterTypes();
  27.             for(Class parameterType : parameterTypes){
  28.                 s.append(parameterType.getSimpleName());
  29.                 s.append(",");
  30.             }
  31.             // 删除最后下标位置上的字符
  32.             if(parameterTypes.length > 0){
  33.                 s.deleteCharAt(s.length() - 1);
  34.             }
  35.             s.append("){}\n");
  36.         }
  38.         s.append("}");
  39.         System.out.println(s);
  40.     }
  41. }

10.1 通过反射调用构造方法实例化对象

  1. import com.bjpowernode.java.bean.Vip;
  3. import java.lang.reflect.Constructor;
  5. /*
  6. 比上一个例子(ReflectTest11)重要一些！！！
  8. 通过反射机制调用构造方法实例化java对象。（这个不是重点）
  9.  */
  10. public class ReflectTest12 {
  11.     public static void main(String[] args) throws Exception{
  12.         // 不使用反射机制怎么创建对象
  13.         Vip v1 = new Vip();
  14.         Vip v2 = new Vip(110, "zhangsan", "2001-10-11", true);
  16.         // 使用反射机制怎么创建对象呢？
  17.         Class c = Class.forName("com.bjpowernode.java.bean.Vip");
  18.         // 调用无参数构造方法
  19.         Object obj = c.newInstance();
  20.         System.out.println(obj);
  22.         // 调用有参数的构造方法怎么办？
  23.         // 第一步：先获取到这个有参数的构造方法
  24.         Constructor con = c.getDeclaredConstructor(int.class, String.class, String.class,boolean.class);
  25.         // 第二步：调用构造方法new对象
  26.         Object newObj = con.newInstance(110, "jackson", "1990-10-11", true);
  27.         System.out.println(newObj);
  29.         // 获取无参数构造方法
  30.         Constructor con2 = c.getDeclaredConstructor();
  31.         Object newObj2 = con2.newInstance();
  32.         System.out.println(newObj2);
  33.     }
  34. }

11. 获取一个类的父类、接口

  1. /*
  2. 重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口？
  3.  */
  4. public class ReflectTest13 {
  5.     public static void main(String[] args) throws Exception{
  7.         // String举例
  8.         Class stringClass = Class.forName("java.lang.String");
  10.         // 获取String的父类
  11.         Class superClass = stringClass.getSuperclass();
  12.         System.out.println(superClass.getName());
  14.         // 获取String类实现的所有接口（一个类可以实现多个接口。）
  15.         Class[] interfaces = stringClass.getInterfaces();
  16.         for(Class in : interfaces){
  17.             System.out.println(in.getName());
  18.         }
  19.     }
  20. }

第二十一章 注解

1. 注解基本概述

  • 注解，或者叫做注释类型，英文单词是：Annotation

  • 注解Annotation是一种引用数据类型。编译之后也是生成xxx.class文件。

  • 怎么自定义注解呢？语法格式？

[修饰符列表] @interface 注解类型名{}

  • 注解怎么使用，用在什么地方？

第一：注解使用时的语法格式是：
@注解类型名
第二：注解可以出现在类上、属性上、方法上、变量上、注解类型上……

  • JDK内置了哪些注解呢？

java.lang包下的注释类型：
掌握：
Deprecated
用 @Deprecated 注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择
掌握：
Override
表示一个方法声明打算重写超类中的另一个方法声明
不用掌握：
SuppressWarnings
指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告

1.1 关于JDK lang包下的Override注解

  1. /*
  2. 关于JDK lang包下的Override注解
  3. 源代码：
  4. public @interface Override {
  5. }
  7. 标识性注解，给编译器做参考的。
  8. 编译器看到方法上有这个注解的时候，编译器会自动检查该方法是否重写了父类的方法。
  9. 如果没有重写，报错。
  11. 这个注解只是在编译阶段起作用，和运行期无关！
  13.  */
  15. // @Override这个注解只能注解方法。
  16. // @Override这个注解是给编译器参考的，和运行阶段没有关系。
  17. // 凡是java中的方法带有这个注解的，编译器都会进行编译检查，如果这个方法不是重写父类的方法，编译器报错。
  19. //@Override
  20. public class AnnotationTest02 {
  22.     //@Override
  23.     private int no;
  25.     @Override
  26.     public String toString() {
  27.         return "toString";
  28.     }
  30. }

1.2 Deprecated

  1. // 表示这个类已过时。
  2. @Deprecated
  3. public class AnnotationTest03 {
  5.     @Deprecated
  6.     private String s;
  8.     public static void main(String[] args) {
  9.         AnnotationTest03 at = new AnnotationTest03();
  10.         at.doSome();
  11.     }
  13.     @Deprecated
  14.     public void doSome(){
  15.         System.out.println("do something!");
  16.     }
  18.     // Deprecated这个注解标注的元素已过时。
  19.     // 这个注解主要是向其它程序员传达一个信息，告知已过时，有更好的解决方案存在。
  20.     @Deprecated
  21.     public static void doOther(){
  22.         System.out.println("do other...");
  23.     }
  24. }
  26. class T {
  27.     public static void main(String[] args) {
  28.         AnnotationTest03 at = new AnnotationTest03();
  29.         at.doSome();
  31.         AnnotationTest03.doOther();
  33.         try {
  34.             Class c = Class.forName("java.util.Date");
  35.             Object obj = c.newInstance();
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         }
  39.     }
  40. }

1.3 注解的属性

  1. public @interface MyAnnotation {
  3.     /**
  4.      * 我们通常在注解当中可以定义属性，以下这个是MyAnnotation的name属性。
  5.      * 看着像1个方法，但实际上我们称之为属性name。
  6.      * @return
  7.      */
  8.     String name();
  10.     /*
  11.     颜色属性
  12.      */
  13.     String color();
  15.     /*
  16.     年龄属性
  17.      */
  18.     int age() default 25; //属性指定默认值
  20. }
  22. public class MyAnnotationTest {
  24.     // 报错的原因：如果一个注解当中有属性，那么必须给属性赋值。（除非该属性使用default指定了默认值。）
  25.     /*@MyAnnotation
  26.     public void doSome(){
  28.     }*/
  30.     //@MyAnnotation(属性名=属性值,属性名=属性值,属性名=属性值)
  31.     //指定name属性的值就好了。
  32.     @MyAnnotation(name = "zhangsan", color = "红色")
  33.     public void doSome(){
  35.     }
  37. }

1.4 属性为value的省略问题

  1. public @interface MyAnnotation {
  3.     /*
  4.     指定一个value属性。
  5.      */
  6.     String value();
  8.     //String email();
  9. }
  11. /*
  12. 如果一个注解的属性的名字是value，并且只有一个属性的话（或者其他属性都有默认值），
  13. 在使用的时候，该属性名可以省略。
  14.  */
  15. public class MyAnnotationTest {
  17.     // 报错原因：没有指定属性的值。
  18.     /*@MyAnnotation
  19.     public void doSome(){
  21.     }*/
  23.     @MyAnnotation(value = "hehe")
  24.     public void doSome(){
  26.     }
  28.     @MyAnnotation("haha")
  29.     public void doOther(){
  31.     }
  32. }

仅限属性名为value才存在省略问题

1.5 注解当中的属性可以是哪一种类型

  1. public @interface MyAnnotation {
  2.     /*
  3.     注解当中的属性可以是哪一种类型？
  4.         属性的类型可以是：
  5.             byte short int long float double boolean char String Class 枚举类型
  6.             以及以上每一种的数组形式。
  7.      */
  8.     int value1();
  10.     String value2();
  12.     int[] value3();
  14.     String[] value4();
  16.     Season value5();
  18.     Season[] value6();
  20.     Class parameterType();
  22.     Class[] parameterTypes();
  23. }
  25. public enum Season {
  26.     SPRING,SUMMER,AUTUMN,WINTER
  27. }

1.7 属性为数组

  1. public @interface OtherAnnotation {
  2.     /*
  3.     年龄属性
  4.      */
  5.     int age();
  7.     /*
  8.     邮箱地址属性，支持多个
  9.      */
  10.     String[] email();
  12.     /**
  13.      * 季节数组，Season是枚举类型
  14.      * @return
  15.      */
  16.     Season[] seasonArray();
  17. }
  19. public class OtherAnnotationTest {
  21.     // 数组是大括号
  22.     @OtherAnnotation(age = 25, email = {"zhangsan@123.com", "zhangsan@sohu.com"},
  23.                      seasonArray = Season.WINTER)
  24.     public void doSome(){
  26.     }
  28.     // 如果数组中只有1个元素：大括号可以省略。
  29.     @OtherAnnotation(age = 25, email = "zhangsan@123.com", seasonArray = {Season.SPRING,
  30.                      Season.SUMMER})
  31.     public void doOther(){
  33.     }
  35. }

2. 元注解

  • 什么是元注解？

用来标注“注解类型”的“注解”，称为元注解。
常见的元注解有哪些？
Target
Retention

2.1 关于Target注解：

这是一个元注解，用来标注“注解类型”的“注解”，这个Target注解用来标注“被标注的注解”可以出现在哪些位置上
@Target(ElementType.METHOD)：表示“被标注的注解”只能出现在方法上；@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER,TYPE})表示该注解可以出现在：构造方法上、字段上、局部变量上、方法上….. 类上…..

2.2 关于Retention注解

这是一个元注解，用来标注“注解类型”的“注解”，这个Retention注解用来标注“被标注的注解”最终保存在哪里
@Retention(RetentionPolicy.SOURCE)：表示该注解只被保留在java源文件中
@Retention(RetentionPolicy.CLASS)：表示该注解被保存在class文件中
@Retention(RetentionPolicy.RUNTIME)：表示该注解被保存在class文件中，并且可以被反射机制所读取

2.2.1 Retention的源代码

  1. //RetentionPolicy的源代码：
  2. //元注解    
  3. public @interface Retention {
  4.     //属性
  5.     RetentionPolicy value();
  6. }
  8. public enum RetentionPolicy {
  9.     SOURCE,
  10.     CLASS,
  11.     RUNTIME
  12. }
  14. //@Retention(value=RetentionPolicy.RUNTIME)
  15. @Retention(RetentionPolicy.RUNTIME)
  16. public @interface MyAnnotation{}

3. 反射注解

  1. import java.lang.annotation.ElementType;
  2. import java.lang.annotation.Retention;
  3. import java.lang.annotation.RetentionPolicy;
  4. import java.lang.annotation.Target;
  6. @Retention(RetentionPolicy.RUNTIME)
  7. @Target(ElementType.METHOD)
  8. public @interface MyAnnotation {
  10.     /*
  11.     username属性
  12.      */
  13.     String username();
  15.     /*
  16.     password属性
  17.      */
  18.     String password();
  19. }
  21. import java.lang.reflect.Method;
  23. public class MyAnnotationTest {
  25.     @MyAnnotation(username = "admin", password = "456456")
  26.     public void doSome(){
  28.     }
  30.     public static void main(String[] args) throws Exception{
  31.         // 获取MyAnnotationTest的doSome()方法上面的注解信息。
  32.         Class c = Class.forName("com.bjpowernode.java.annotation6.MyAnnotationTest");
  33.         // 获取doSome()方法
  34.         Method doSomeMethod = c.getDeclaredMethod("doSome");
  35.         // 判断该方法上是否存在这个注解
  36.         if(doSomeMethod.isAnnotationPresent(MyAnnotation.class)) {
  37.             MyAnnotation myAnnotation = doSomeMethod.getAnnotation(MyAnnotation.class);
  38.             System.out.println(myAnnotation.username());
  39.             System.out.println(myAnnotation.password());
  40.         }
  41.     }
  43. }
  1. import java.lang.annotation.ElementType;
  2. import java.lang.annotation.Retention;
  3. import java.lang.annotation.RetentionPolicy;
  4. import java.lang.annotation.Target;
  6. //只允许该注解可以标注类、方法
  7. @Target({ElementType.TYPE, ElementType.METHOD})
  8. // 希望这个注解可以被反射
  9. @Retention(RetentionPolicy.RUNTIME)
  10. public @interface MyAnnotation {
  12.     /*
  13.     value属性。
  14.      */
  15.     String value() default "北京大兴区";
  16. }
  18. @MyAnnotation("上海浦东区")
  19. public class MyAnnotationTest {
  21.     //@MyAnnotation
  22.     int i;
  24.     //@MyAnnotation
  25.     public MyAnnotationTest(){
  27.     }
  29.     @MyAnnotation
  30.     public void doSome(){
  32.         //@MyAnnotation
  33.         int i;
  34.     }
  36. }
  38. public class ReflectAnnotationTest {
  39.     public static void main(String[] args) throws Exception{
  40.         // 获取这个类
  41.         Class c = Class.forName("com.bjpowernode.java.annotation5.MyAnnotationTest");
  42.         // 判断类上面是否有@MyAnnotation
  43.         //System.out.println(c.isAnnotationPresent(MyAnnotation.class)); // true
  44.         if(c.isAnnotationPresent(MyAnnotation.class)){
  45.             // 获取该注解对象
  46.             MyAnnotation myAnnotation = (MyAnnotation)c.getAnnotation(MyAnnotation.class);
  47.             //System.out.println("类上面的注解对象" + myAnnotation); // @com.bjpowernode.java.annotation5.MyAnnotation()
  48.             // 获取注解对象的属性怎么办？和调接口没区别。
  49.             String value = myAnnotation.value();
  50.             System.out.println(value);
  51.         }
  53.         // 判断String类上面是否存在这个注解
  54.         Class stringClass = Class.forName("java.lang.String");
  55.         System.out.println(stringClass.isAnnotationPresent(MyAnnotation.class)); // false
  56.     }
  57. }

4. 注解在开发中有什么用

  • java 注解，从名字上看是注释，解释。但功能却不仅仅是注释那么简单。注解（Annotation） 为我们在代码中添加信息提供了一种形式化的方法，是我们可以在稍后 某个时刻方便地使用这些数据（通过解析注解 来使用这些数据），常见的作用有以下几种：

1.生成文档。这是最常见的，也是java 最早提供的注解；常用的有@see @param @return 等

2.跟踪代码依赖性，实现替代配置文件功能；比较常见的是spring 2.5 开始的基于注解配置，作用就是减少配置，现在的框架基本都使用了这种配置来减少配置文件的数量

3.在编译时进行格式检查；如@Override放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出