今日内容

  • JUnit单元测试
  • 反射
  • 注解
  • 动态代理
  • JDK8新特性

学习目标

  • 能够使用Junit进行单元测试
  • 能够通过反射技术获取Class字节码对象
  • 能够通过反射技术获取构造方法对象，并创建对象。
  • 能够通过反射获取成员方法对象，并且调用方法。
  • 能够通过反射获取属性对象，并且能够给对象的属性赋值和取值。
  • 能够说出注解的作用
  • 能够自定义注解和使用注解
  • 能够说出常用的元注解及其作用
  • 能够解析注解并获取注解中的数据
  • 能够完成注解的MyTest案例
  • 能够说出动态代理模式的作用
  • 能够使用Proxy的方法生成代理对象
  • 能够使用四种方法的引用
  • 能够使用Base64对基本数据、URL和MIME类型进行编解码

第一章 Junit单元测试

知识点—Junit单元测试

目标

  • 掌握Junit的使用

路径

  • Junit的概念
  • Junit的使用步骤
  • 执行测试方法

讲解

Junit的概念

  • 概述 : Junit是Java语言编写的第三方单元测试框架(工具类)
  • 作用 : 用来做“单元测试”——针对某个普通方法，可以像main()方法一样独立运行，它专门用于测试某个方法。

Junit的使用步骤

  • 1.在模块下创建lib文件夹,把Junit的jar包复制到lib文件夹中

  • 2.选中Junit的jar包,右键选中 add as Library,把JUnit4的jar包添加到classPath中

  • 3.在测试方法上面写上@Test注解

  • 4.执行测试方法 ```java public class Person {

    @Test public void test1(){

    1.   System.out.println("Person test1 方法执行了....");

    }

    @Test public void test2(){

    1.   System.out.println("Person test2 方法执行了....");

    }

}

  4. <a name="43db8fcf"></a>
  5. #### 执行测试方法
  7. - 
  8. 1.选中方法名--->右键--->选中执行             只执行选中的测试方法
  10. - 
  11. 2.选中类名----->右键--->选中执行             执行该类中所有的测试方法
  13. - 
  14. 3.选中模块---- ->右键--->选中all tests 执行   执行该模块中所有的测试方法
  16. - 
  17. 如何查看测试结果
  19.    - 绿色：表示测试通过
  20.    - 红色：表示测试失败，有问题
  22. <a name="5db9fd7c"></a>
  23. ### 小结
  25. 略
  27. <a name="9ab62e95"></a>
  28. ## 知识点--Junit单元测试的注意实现
  30. <a name="73e82552-1"></a>
  31. ### 目标
  33. - 测试方法注意事项:
  35. <a name="4f35e80d-1"></a>
  36. ### 路径
  38. - 测试方法注意事项:
  40. <a name="ab2acfc6-1"></a>
  41. ### 讲解
  43. - 1.测试方法的权限修饰符一定是public
  44. - 2.测试方法的返回值类型一定是void
  45. - 3.测试方法一定没有参数
  46. - 4.测试方法 的声明之上一定要使用@Test注解
  48. <a name="5db9fd7c-1"></a>
  49. ### 小结
  51. - 测试方法一定是一个公共的无参数无返回值的方法
  53. <a name="d4fbd8f4"></a>
  54. ## 知识点--Junit其他注解
  56. <a name="73e82552-2"></a>
  57. ### 目标
  59. - Junit其他注解的使用
  61. <a name="4f35e80d-2"></a>
  62. ### 路径
  64. - Junit其他注解
  66. <a name="ab2acfc6-2"></a>
  67. ### 讲解
  69. - @Before：用来修饰方法，该方法会在每一个测试方法执行之前执行一次。
  70. - @After：用来修饰方法，该方法会在每一个测试方法执行之后执行一次。
  71. - @BeforeClass：用来静态修饰方法，该方法会在所有测试方法之前执行一次，而且只执行一次。
  72. - @AfterClass：用来静态修饰方法，该方法会在所有测试方法之后执行一次，而且只执行一次。
  74. ```java
  75. public class Student {
  77.     @BeforeClass
  78.     public static void beforeClass1(){
  79.         System.out.println("Student beforeClass1静态方法执行了...");
  80.     }
  82.     @BeforeClass
  83.     public static void beforeClass2(){
  84.         System.out.println("Student beforeClass2静态方法执行了...");
  85.     }
  88.     @Before
  89.     public void b1(){
  90.         System.out.println("Student b1方法执行了...");
  91.     }
  93.     @Before
  94.     public void b2(){
  95.         System.out.println("Student b2方法执行了...");
  96.     }
  98.     @Before
  99.     public void b3(){
  100.         System.out.println("Student b3方法执行了...");
  101.     }
  104.     @Test
  105.     public void test1(){
  106.         System.out.println("Student test1 方法执行了....");
  107.     }
  109.     @Test
  110.     public void test2(){
  111.         System.out.println("Student test2 方法执行了....");
  112.     }
  114.     @After
  115.     public void a1(){
  116.         System.out.println("Student a1方法执行了...");
  117.     }
  119.     @After
  120.     public void a2(){
  121.         System.out.println("Student a2方法执行了...");
  122.     }
  124.     @After
  125.     public void a3(){
  126.         System.out.println("Student a3方法执行了...");
  127.     }
  129.     @AfterClass
  130.     public static void afterClass1(){
  131.         System.out.println("Student afterClass1方法执行了...");
  132.     }
  134.     @AfterClass
  135.     public static void afterClass2(){
  136.         System.out.println("Student afterClass2方法执行了...");
  137.     }
  139. }

小结

略

知识点—Junit断言

目标

  • Junit断言

路径

  • Junit断言

讲解

  • 断言：预先判断某个条件是否成立，如果条件不成立，则直接报错。 使用Assert类中的assertEquals()方法
  • 案例:
  1. public class Demo02 {
  2.     @Test
  3.     public void addTest(){
  4.         //测试
  5.         int add = add(3, 6);
  7.         //断言判断结果
  8.         //第一个参数表示期望值
  9.         //第二个参数表示实际值
  10.         //如果结果正确的就测试通过,如果结果错误的,就会报错
  11.         Assert.assertEquals(9,add);
  12.     }
  14.     //加法
  15.     //这个代码的语法没问题，也没有异常。他是逻辑错误，系统不知道你要算的是加法
  16.     public int add(int a, int b){
  17.         int sum = a * b;
  18.         return sum;
  19.     }
  21. }

小结

略

第二章 反射

知识点—类加载器

目标

  • 理解类在什么时候加载,以及如何获取类加载器

路径

  • 类的加载
  • 类的加载时机
  • 类加载器

讲解

类的加载

  • 当我们的程序在运行后，第一次使用某个类的时候，会将此类的class文件读取到内存，并将此类的所有信息存储到一个Class对象中

day15【JUnit单元测试、反射、注解、动态代理、JDK8新特性】 - 图1

类的加载时机

  1. 创建类的实例。

  2. 类的静态变量，或者为静态变量赋值。

  3. 类的静态方法。

  4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。

  5. 初始化某个类的子类。

  6. 直接使用java.exe命令来运行某个主类。
    以上六种情况的任何一种，都可以导致JVM将一个类加载到方法区。

  1. public class Test {
  2.     public static void main(String[] args) throws Exception{
  3.         // 类的加载时机
  4.         //  1. 创建类的实例。
  5.         //  Student stu = new Student();
  7.         // 2. 类的静态变量，或者为静态变量赋值。
  8.         // Person.country = "中国";
  10.         // 3. 类的静态方法。
  11.         // Person.method();
  13.         // 4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
  14.         // Class<?> c = Class.forName("com.itheima.demo1_类的加载.Student");
  16.         //  5. 初始化某个类的子类。
  17.         // Zi zi = new Zi();
  19.         // 6. 直接使用java.exe命令来运行某个主类。
  20.     }
  21. }

类加载器

  1. **类加载器：是负责将磁盘上的某个class文件读取到内存并生成Class的对象。**

  • Java中有三种类加载器，它们分别用于加载不同种类的class：

    • 启动类加载器(Bootstrap ClassLoader)：用于加载系统类库\bin目录下的class，例如：rt.jar。
    • 扩展类加载器(Extension ClassLoader)：用于加载扩展类库\lib\ext目录下的class。
    • 应用程序类加载器(Application ClassLoader)：用于加载我们自定义类的加载器。
  1. public class Test{
  2.     public static void main(String[] args){
  3.           // 获取类加载器:
  4.         // 获取Student类的类加载器
  5.         System.out.println(Student.class.getClassLoader());// AppClassLoader
  6.         // 获取String类的类加载器
  7.         System.out.println(String.class.getClassLoader());// null
  8.         // API中说明：一些实现可能使用null来表示引导类加载器。 如果此类由引导类加载器加载，则此方法将在此类实现中返回null
  10.     }
  11. }

小结

略

知识点—反射的概述

目标

  • 理解反射的概念

路径

  • 反射的引入
  • 反射的概念
  • 使用反射操作类成员的前提
  • 射在实际开发中的应用

讲解

反射的引入

  • 问题：IDEA中的对象是怎么知道类有哪些属性，哪些方法的呢？
  1.  通过反射技术对象类进行了解剖得到了类的所有成员。

反射的概念

  1.  反射是一种机制，利用该机制可以在程序运行过程中对类进行解剖并操作类中的所有成员(成员变量，成员方法，构造方法)

使用反射操作类成员的前提

  1. 要获得该类字节码文件对象，就是Class对象

反射在实际开发中的应用

  1. * 开发IDE(集成开发环境)，比如IDEA,Eclipse
  2. * 各种框架的设计和学习 比如Spring，Hibernate，Struct，Mybaits....

小结

  • 通过反射技术去获取一个类的成员变量,成员方法,构造方法…,并可以访问

知识点—Class对象的获取方式

目标

  • 能够获取一个类的Class对象

路径

  • 通过类名.class获得
  • 通过对象名.getClass()方法获得
  • 通过Class类的静态方法获得： static Class forName(“类全名”)

讲解

  1. * 方式1: 通过类名.class获得
  2. * 方式2：通过对象名.getClass()方法获得
  3. * 方式3：通过Class类的静态方法获得： static Class forName("类全名")
  4.     * 每一个类的Class对象都只有一个。
  • 示例代码
  1. package com.itheima.demo2_Class对象的获取;
  3. /**
  4.  * @Author：pengzhilin
  5.  * @Date: 2020/5/14 9:35
  6.  */
  7. public class Student {
  8.     private String name;
  10.     public void method1(){
  12.     }
  13. }
  1. public class Test {
  2.     public static void main(String[] args) throws Exception{
  3.           /*
  4.             Class对象的获取:
  5.                 通过类名.class获得
  6.                 通过对象名.getClass()方法获得
  7.                 通过Class类的静态方法获得： static Class forName("类全名")
  8.            */
  9.         // 1.方式一:通过类名.class获得
  10.         Class<Student> c1 = Student.class;
  11.         System.out.println(c1);
  13.         // 2.方式二:通过对象名.getClass()方法获得
  14.         Student stu = new Student();
  15.         Class<? extends Student> c2 = stu.getClass();
  16.         System.out.println(c2);
  18.         // 3.方式三:通过Class类的静态方法获得： static Class forName("类全名")
  19.         Class<?> c3 = Class.forName("com.itheima.demo2_Class对象的获取.Student");
  20.         System.out.println(c3);
  22.         // 问题:一个类只有一个字节码对象(Class对象)
  23.         System.out.println(c1 == c2);// true
  24.         System.out.println(c1 == c3);// true
  25.     }
  26. }

小结

略

知识点—Class类常用方法

目标

  • Class类的常用方法

路径

  • Class类的常用方法

讲解

  1. String getSimpleName(); 获得类名字符串：类名
  2. String getName();  获得类全名：包名+类名
  3. T newInstance() ;  创建Class对象关联类的对象
  • 示例代码
  1. public class ReflectDemo02 {
  2.     public static void main(String[] args) throws Exception {
  3.         // 获得Class对象
  4.         Class c = Student.class;
  5.         // 获得类名字符串：类名
  6.         System.out.println(c.getSimpleName());
  7.         // 获得类全名：包名+类名
  8.         System.out.println(c.getName());
  9.         // 创建对象
  10.         Student stu = (Student) c.newInstance();
  11.         System.out.println(stu);
  12.     }
  13. }

小结

略

知识点—反射之操作构造方法

目标

  • 通过反射获取类的构造方法,并执行构造方法

路径

  • Constructor类概述
  • 通过反射获取类的构造方法
  • 通过反射执行构造方法

讲解

Constructor类概述

  1. 反射之操作构造方法的目的
  2.     * 获得Constructor对象来创建类的对象。
  4. Constructor类概述
  5.     * 类中的每一个构造方法都是一个Constructor类的对象

通过反射获取类的构造方法

  1. Class类中与Constructor相关的方法 
  2. 1. Constructor getConstructor(Class... parameterTypes)
  3.         * 根据参数类型获得对应的Constructor对象。
  4.         * 只能获得public修饰的构造方法
  5.  2. Constructor getDeclaredConstructor(Class... parameterTypes)
  6.         * 根据参数类型获得对应的Constructor对象
  7.         * 可以是public、protected、(默认)、private修饰符的构造方法。
  8.  3. Constructor[] getConstructors()
  9.         获得类中的所有构造方法对象，只能获得public的
  10.  4. Constructor[] getDeclaredConstructors()
  11.         获得类中的所有构造方法对象
  12.         可以是public、protected、(默认)、private修饰符的构造方法。

通过反射执行构造方法

  1. Constructor对象常用方法
  2. 1. T newInstance(Object... initargs)
  3.      根据指定的参数创建对象
  4. 2. void setAccessible(true)
  5.    设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消

示例代码

  1. package com.itheima.demo4_反射之构造方法;
  3. /**
  4.  * @Author：pengzhilin
  5.  * @Date: 2020/5/14 10:13
  6.  */
  7. public class Student {
  8.     // 属性
  9.     public String name;// 姓名
  10.     public String sex;// 性别
  11.     public int age;// 年龄
  13.     // 构造方法
  14.     public Student() {
  15.     }
  17.     public Student(String name, String sex, int age) {
  18.         this.name = name;
  19.         this.sex = sex;
  20.         this.age = age;
  21.     }
  23.     private Student(String name, int age) {
  24.         this.name = name;
  25.         this.age = age;
  26.     }
  28.     // 成员方法
  30.     @Override
  31.     public String toString() {
  32.         return "Student{" +
  33.                 "name='" + name + '\'' +
  34.                 ", sex='" + sex + '\'' +
  35.                 ", age=" + age +
  36.                 '}';
  37.     }
  38. }
  1. public class Test1 {
  2.     public static void main(String[] args) throws Exception{
  3.         /*
  4.             - 通过反射获取类的构造方法,并执行构造方法创建该类的对象
  5.                 - Constructor类概述
  6.                     概述:类中的每一个构造方法都是一个Constructor类的对象
  7.                     通过反射获取类的构造方法,其实就是获取该构造方法对于的Constructor对象
  9.                 - 通过反射获取类的构造方法: 使用Class类中的方法
  10.                    我们每一个类都会有一个对于的Class对象,所以该类中的构造方法就在我们的Class对象中,
  11.                    所以可以使用Class对象获取构造方法
  12.                    Class类中与Constructor相关的方法
  13.                         1. Constructor getConstructor(Class... parameterTypes)  获取单个public修饰的构造方法
  14.                                 * 根据参数类型获得对应的Constructor对象。
  15.                                 * 只能获得public修饰的构造方法
  16.                          2. Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
  17.                                 * 根据参数类型获得对应的Constructor对象
  18.                                 * 可以是public、protected、(默认)、private修饰符的构造方法。
  19.                          3. Constructor[] getConstructors() 获取所有public修饰的构造方法
  20.                                 获得类中的所有构造方法对象，只能获得public的
  21.                          4. Constructor[] getDeclaredConstructors() 获取所有构造方法
  22.                                 获得类中的所有构造方法对象
  23.                                 可以是public、protected、(默认)、private修饰符的构造方法。
  24.                     记忆方法:
  25.                         1. 加了s的就是获取多个,不加s的就是获取单个
  26.                         2. 加了Declared的就是获取任意修饰符修饰的构造方法,不加就只能获取public修饰的构造方法
  28.                  小结:
  29.                      Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
  30.                      Constructor[] getDeclaredConstructors() 获取所有构造方法
  32.                 - 通过反射执行构造方法:使用Constructor对象中的方法,来执行该对象表示的构造方法
  33.                     Constructor对象常用方法
  34.                         1. T newInstance(Object... initargs)
  35.                             根据指定的参数创建对象
  36.                         2. void setAccessible(true)
  37.                            设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消
  39.          */
  40.         // 0.获取Student类的Class对象
  41.         Class<?> c = Class.forName("com.itheima.demo4_反射之构造方法.Student");
  43.         // 1.获取单个public修饰的构造方法
  44.         // Constructor getConstructor(Class... parameterTypes)  获取单个public修饰的构造方法
  45.         //    参数:传入你要获取的构造方法的参数类型的Class对象
  47.         // 获取Student类的空参构造方法
  48.         Constructor<?> cons1 = c.getConstructor();
  49.         System.out.println(cons1);
  51.         // 获取Student类的带有三个参数的构造方法,并且参数的类型顺序为:String,String,int
  52.         Constructor<?> cons2 = c.getConstructor(String.class,String.class, int.class);
  54.         // public Student(String name,String sex,int.class);
  55.         // public Student(String name,int.class,String sex);
  57.         System.out.println(cons2);
  59.         // 2.获取单个非public修饰的构造方法
  60.         // Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
  61.         //    参数:传入你要获取的构造方法的参数类型的Class对象
  63.         // 获取Student类的带有2个参数的构造方法,并且参数的类型顺序为:String,int
  64.         Constructor<?> cons3 = c.getDeclaredConstructor(String.class, int.class);
  65.         System.out.println(cons3);
  67.         System.out.println("============================================");
  68.         // 3.获取多个public修饰的方法
  69.         // Constructor[] getConstructors() 获取所有public修饰的构造方法
  70.         Constructor<?>[] conArr1 = c.getConstructors();
  71.         for (Constructor<?> con : conArr1) {
  72.             System.out.println(con);
  73.         }
  75.         System.out.println("============================================");
  76.         // 4.获取所有修饰的方法
  77.         // Constructor[] getDeclaredConstructors() 获取所有构造方法
  78.         Constructor<?>[] conArr2 = c.getDeclaredConstructors();
  79.         for (Constructor<?> con : conArr2) {
  80.             System.out.println(con);
  81.         }
  83.     }
  84. }
  88. public class Test2 {
  89.     public static void main(String[] args) throws Exception{
  90.         /*
  91.             - 获取类的构造方法:
  92.                     Constructor getDeclaredConstructor(Class... parameterTypes) 获取单个构造方法
  93.                      Constructor[] getDeclaredConstructors() 获取所有构造方法
  95.             - 通过反射执行构造方法:使用Constructor对象中的方法,来执行该对象表示的构造方法
  96.                 Constructor对象常用方法
  97.                     1. T newInstance(Object... initargs)
  98.                         根据指定的参数创建对象
  99.                         参数: 传入执行该构造方法需要的实际参数
  101.                     2. void setAccessible(boolean b)
  102.                        设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消
  103.          */
  104.         // 获取Student类的Class对象
  105.         Class<?> c = Class.forName("com.itheima.demo4_反射之构造方法.Student");
  107.         // 1.获取public修饰的构造方法对象,并执行该对象表示的构造方法来创建对象
  108.         // 1.1 获取public修饰的构造方法对象  public Student(String name, String sex, int age)
  109.         Constructor<?> cons1 = c.getDeclaredConstructor(String.class, String.class, int.class);
  111.         // 1.2 执行该对象表示的构造方法来创建对象
  112.         Object obj = cons1.newInstance("张三", "女", 18);// 真正返回的是Student对象
  113.         System.out.println(obj);// Student{name='张三', sex='女', age=18}
  115.         System.out.println("==========================================");
  116.         // 2.获取private修饰的构造方法对象,并执行该对象表示的构造方法来创建对象
  117.         // 2.1 获取private修饰的构造方法对象
  118.         Constructor<?> cons2 = c.getDeclaredConstructor(String.class, int.class);
  120.         // 2.2 执行该对象表示的构造方法来创建对象
  121.         // 设置"暴力反射"
  122.         cons2.setAccessible(true);
  124.         Object obj2 = cons2.newInstance("李四", 19);
  125.         System.out.println(obj2);
  126.     }
  127. }

小结

略

知识点—反射之操作成员方法

目标

  • 通过反射获取类的成员方法,并执行成员方法

路径

  • Method类概述
  • 通过反射获取类的成员方法
  • 通过反射执行成员方法

讲解

Method类概述

  1. 反射之操作成员方法的目的
  2.     * 操作Method对象来调用成员方法
  3. Method类概述
  4.     * 每一个成员方法都是一个Method类的对象。

通过反射获取类的成员方法

  1. * Method getMethod(String name,Class...args);
  2.       * 根据方法名和参数类型获得对应的成员方法对象，只能获得public的
  3. * Method getDeclaredMethod(String name,Class...args);     掌握
  4.        * 根据方法名和参数类型获得对应的成员方法对象，包括public、protected、(默认)、private的
  5. * Method[] getMethods();
  6.         * 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
  7. * Method[] getDeclaredMethods();    掌握
  8.          * 获得类中的所有成员方法对象，返回数组,只获得本类的，包括public、protected、(默认)、private的

通过反射执行成员方法

  1. Method对象常用方法
  2. *  Object invoke(Object obj, Object... args)
  3.     * 调用指定对象obj的该方法
  4.     * args：调用方法时传递的参数
  5. *  void setAccessible(true)
  6.     设置"暴力访问"——是否取消权限检查，true取消权限检查，false表示不取消

示例代码

  1. ackage com.itheima.demo5_反射之操作成员方法;
  3. /**
  4.  * @Author：pengzhilin
  5.  * @Date: 2020/5/14 10:13
  6.  */
  7. public class Student {
  8.     public void show1(){
  9.         System.out.println("public 修饰的show1方法,无参数...");
  10.     }
  12.     public void show1(String str,int num){
  13.         System.out.println("public 修饰的show1方法,2个参数...");
  14.         System.out.println("str:"+str+",num:"+num);
  15.     }
  17.     public void show2(){
  18.         System.out.println("public 修饰的show2方法...");
  19.     }
  21.     private void show3(){
  22.         System.out.println("private 修饰的show3方法...");
  23.     }
  24. }
  1. package com.itheima.demo5_反射之操作成员方法;
  3. import java.lang.reflect.Method;
  5. /**
  6.  * @Author：pengzhilin
  7.  * @Date: 2020/5/14 11:03
  8.  */
  9. public class Test1 {
  10.     public static void main(String[] args) throws Exception {
  11.         /*
  12.             反射之操作成员方法:
  13.                 - 通过反射获取类的成员方法,并通过反射技术执行成员方法
  14.                     - Method类概述
  15.                             每一个成员方法都是一个Method类的对象。
  17.                     - 通过反射获取类的成员方法
  18.                             Class类中与Method相关的方法
  19.                                 * Method getMethod(String name,Class...args); 获取单个public修饰的成员方法
  20.                                     * 根据方法名和参数类型获得对应的构造方法对象，只能获得public的
  22.                                 * Method getDeclaredMethod(String name,Class...args); 获取任意修饰符修饰的单个成员方法
  23.                                     * 根据方法名和参数类型获得对应的构造方法对象，包括public、protected、(默认)、private的
  25.                                 * Method[] getMethods();  获取所有public修饰的成员方法
  26.                                     * 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
  28.                                 * Method[] getDeclaredMethods(); 获取所有成员方法
  29.                                     * 获得类中的所有成员方法对象，返回数组,只获得本类的，包括public、protected、(默认)、private的
  31.                         记忆:
  32.                             Method getDeclaredMethod(String name,Class...args); 获取任意修饰符修饰的单个成员方法\
  33.                             Method[] getDeclaredMethods(); 获取所有成员方法
  35.                     - 通过反射执行成员方法
  36.          */
  37.         // 1.获取Student类的Class对象
  38.         Class<?> c = Class.forName("com.itheima.demo5_反射之操作成员方法.Student");
  40.         // 2.获取单个成员方法
  41.         // 2.1 获取单个public修饰的方法
  42.         // Method getMethod(String name,Class...args);
  43.         // 第一个参数: 方法名
  44.         // 第二个参数: 该方法的参数类型的Class对象,如果没有参数就不传入
  45.         Method show1M1 = c.getMethod("show1");// 第一个show1方法
  46.         System.out.println(show1M1);
  48.         Method show1M2 = c.getMethod("show1", String.class, int.class);
  49.         System.out.println(show1M2);
  51.         // 2.2 获取单个private修饰的成员方法
  52.         // Method getDeclaredMethod(String name,Class...args);
  53.         // 第一个参数: 方法名
  54.         // 第二个参数: 该方法的参数类型的Class对象,如果没有参数就不传入
  55.         Method show3M = c.getDeclaredMethod("show3");
  56.         System.out.println(show3M);
  58.         System.out.println("=======================");
  60.         // 3.获取多个public修饰的成员方法
  61.         // 3.1 获取所有public修饰的成员方法
  62.         // Method[] getMethods();
  63.         Method[] mArr1 = c.getMethods();
  64.         for (Method method : mArr1) {
  65.             System.out.println(method);
  66.         }
  68.         System.out.println("=======================");
  70.         // 3.2 获取所有的成员方法
  71.         // Method[] getDeclaredMethods();
  72.         Method[] mArr2 = c.getDeclaredMethods();
  73.         for (Method method : mArr2) {
  74.             System.out.println(method);
  75.         }
  77.     }
  78. }
  79. package com.itheima.demo5_反射之操作成员方法;
  81. import java.lang.reflect.Method;
  83. /**
  84.  * @Author：pengzhilin
  85.  * @Date: 2020/5/14 11:33
  86.  */
  87. public class Test2 {
  88.     public static void main(String[] args) throws Exception {
  89.         /*
  90.              Method getDeclaredMethod(String name,Class...args); 获取任意修饰符修饰的单个成员方法\
  91.              Method[] getDeclaredMethods(); 获取所有成员方法
  93.             通过反射技术执行成员方法:
  94.                 Method对象常用方法
  95.                     *  Object invoke(Object obj, Object... args)
  96.                         * 参数1: 调用该方法的对象
  97.                         * 参数2：调用方法时传递的实际参数,如果方法没有参数,就不传
  98.                     *  void setAccessible(true)
  99.                         设置"暴力访问"——是否取消权限检查，true取消权限检查，false表示不取消
  100.          */
  101.         // 0.获取Student类的Class对象
  102.         Class<?> c = Class.forName("com.itheima.demo5_反射之操作成员方法.Student");
  104.         // 1.通过反射获取public修饰的成员方法对象,并通过反射执行该方法
  105.         // 1.1 通过反射获取public修饰的成员方法对象
  106.         Method show1M = c.getDeclaredMethod("show1", String.class, int.class);
  108.         // 1.2 通过反射执行该方法
  109.         Student stu = new Student();// 使用反射创建对象:通过反射获取构造方法对象,执行该构造方法
  110.         show1M.invoke(stu,"itheima",14);
  112.         System.out.println("=======================");
  113.         // 2.通过反射获取private修饰的成员方法对象,并通过反射执行该方法
  114.         // 2.1 通过反射获取private修饰的成员方法对象
  115.         Method show3M = c.getDeclaredMethod("show3");
  117.         // 2.2 通过反射执行该方法
  118.         // 设置暴力反射
  119.         show3M.setAccessible(true);
  120.         show3M.invoke(stu);
  121.     }
  122. }

小结

略

知识点—反射之操作成员变量【自学】

目标

  • 通过反射获取类的成员变量,并访问成员变量

路径

  • Field类概述
  • 通过反射获取类的成员变量
  • 通过反射访问成员变量

讲解

Field类概述

  1. 反射之操作成员变量的目的
  2.     * 通过Field对象给对应的成员变量赋值和取值
  4. Field类概述
  5.     * 每一个成员变量都是一个Field类的对象。

通过反射获取类的成员变量

  1. Class类中与Field相关的方法
  2. * Field getField(String name);
  3.     *  根据成员变量名获得对应Field对象，只能获得public修饰
  4. * Field getDeclaredField(String name);
  5.     *  根据成员变量名获得对应Field对象，包括public、protected、(默认)、private的
  6. * Field[] getFields();
  7.     * 获得所有的成员变量对应的Field对象，只能获得public的
  8. * Field[] getDeclaredFields();
  9.     * 获得所有的成员变量对应的Field对象，包括public、protected、(默认)、private的

通过反射访问成员变量

  1. Field对象常用方法
  2. void  set(Object obj, Object value) 
  3. void setInt(Object obj, int i)     
  4. void setLong(Object obj, long l)
  5. void setBoolean(Object obj, boolean z) 
  6. void setDouble(Object obj, double d) 
  8. Object get(Object obj)  
  9. int    getInt(Object obj) 
  10. long getLong(Object obj) 
  11. boolean getBoolean(Object ob)
  12. double getDouble(Object obj) 
  14. void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
  15. Class getType(); 获取属性的类型，返回Class对象。

setXxx方法都是给对象obj的属性设置使用，针对不同的类型选取不同的方法。

getXxx方法是获取对象obj对应的属性值的，针对不同的类型选取不同的方法。

示例代码

  1. package com.itheima.demo6_反射之操作成员变量;
  3. /**
  4.  * @Author：pengzhilin
  5.  * @Date: 2020/5/14 10:13
  6.  */
  7. public class Student {
  8.     public String name;// 姓名
  9.     public int age;// 年龄
  10.     private String sex;// 性别
  12.     @Override
  13.     public String toString() {
  14.         return "Student{" +
  15.                 "name='" + name + '\'' +
  16.                 ", age=" + age +
  17.                 ", sex='" + sex + '\'' +
  18.                 '}';
  19.     }
  20. }
  1. public class Test1 {
  2.     public static void main(String[] args) throws Exception{
  3.         /*
  4.             反射之操作成员变量:
  5.                 - Field类概述 : 每一个成员变量都是一个Field类的对象。
  6.                 - 通过反射获取类的成员变量
  7.                         Class类中与Field相关的方法
  8.                             * Field getField(String name);获取单个public修饰的成员变量
  9.                                 *  根据成员变量名获得对应Field对象，只能获得public修饰
  10.                             * Field getDeclaredField(String name);获取单个任意修饰符修饰的成员变量
  11.                                 *  根据成员变量名获得对应Field对象，包括public、protected、(默认)、private的
  12.                             * Field[] getFields();获取所有的public修饰的成员变量
  13.                                 * 获得所有的成员变量对应的Field对象，只能获得public的
  14.                             * Field[] getDeclaredFields();获取所有的成员变量
  15.                                 * 获得所有的成员变量对应的Field对象，包括public、protected、(默认)、private的
  16.                      结论:
  17.                         Field getDeclaredField(String name);获取单个任意修饰符修饰的成员变量
  18.                             参数:成员变量名  字符串类型
  19.                         Field[] getDeclaredFields();获取所有的成员变量
  21.                 - 通过反射访问成员变量
  22.          */
  23.         // 通过反射获取类的成员变量
  24.         // 1.获取Student类的Class对象
  25.         Class<?> c = Class.forName("com.itheima.demo6_反射之操作成员变量.Student");
  27.         // 2. 获取单个成员变量的Field对象
  28.         // 2.1 获取单个public修饰的成员变量
  29.         Field nameF = c.getDeclaredField("name");
  30.         System.out.println(nameF);
  32.         // 2.2 获取单个private修饰的成员变量
  33.         Field sexF = c.getDeclaredField("sex");
  34.         System.out.println(sexF);
  36.         System.out.println("==============================================");
  38.         // 3.获取所有的成员变量的Field对象
  39.         Field[] fieldArr = c.getDeclaredFields();
  40.         for (Field field : fieldArr) {
  41.             System.out.println(field);
  42.         }
  45.     }
  46. }
  48. public class Test2 {
  49.     public static void main(String[] args) throws Exception {
  50.         /*
  51.                通过反射获取类的成员变量
  52.                         Field getDeclaredField(String name);获取单个任意修饰符修饰的成员变量
  53.                             参数:成员变量名  字符串类型
  54.                         Field[] getDeclaredFields();获取所有的成员变量
  56.                通过反射访问成员变量:
  57.                 Field对象常用方法
  58.                     为成员变量设置值的方法
  59.                         void  set(Object obj, Object value)    记住
  60.                         参数1: 要赋值属性的对象
  61.                         参数2: 属性具体的值
  63.                     获取成员变量值的方法
  64.                         Object get(Object obj)      记住
  65.                         参数: 要获取属性值的对象
  66.                         返回值: 属性具体的值
  68.                     void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。  记住
  70.                     Class getType(); 获取属性的类型，返回Class对象。
  71.          */
  72.         // 通过反射获取类的成员变量
  73.         // 1.获取Student类的Class对象
  74.         Class<?> c = Class.forName("com.itheima.demo6_反射之操作成员变量.Student");
  76.         // 2. 获取单个成员变量的Field对象
  77.         // 2.1 获取单个public修饰的成员变量
  78.         Field nameF = c.getDeclaredField("name");
  79.         // 2.2 通过反射为name属性赋值
  80.         Student stu = new Student();
  81.         nameF.set(stu,"张三");
  83.         Field ageF = c.getDeclaredField("age");
  84.         // ageF.set(stu,18);
  85.         ageF.setInt(stu,19);
  87.         System.out.println(stu);// Student{name='张三', age=18, sex='null'}
  89.         // 2.3 获取某个属性的值
  90.         System.out.println(nameF.get(stu));// 张三
  91.         System.out.println(ageF.get(stu));// 19
  93.         // 2.2 获取单个private修饰的成员变量
  94.         Field sexF = c.getDeclaredField("sex");
  95.         // 暴力反射
  96.         sexF.setAccessible(true);
  97.         sexF.set(stu,"李四");
  99.         // 获取
  100.         System.out.println(sexF.get(stu));// 李四
  103.         // 获取nameF属性的类型
  104.         Class<?> c1 = nameF.getType();
  105.         System.out.println(c1);// class java.lang.String
  108.     }
  109. }

小结

略

第三章 注解

知识点-注解概述

目标

  • 掌握什么是注解, 注解的作用

路径

  • 注解概述
  • 注解的作用

讲解

注解概述

  • 注解(annotation),是一种代码级别的说明,和类 接口平级关系.

    • 注解（Annotation）相当于一种标记，在程序中加入注解就等于为程序打上某种标记，以后，javac编译器、开发工具和其他程序可以通过反射来了解你的类及各种元素上有无标记，看你的程序有什么标记，就去干相应的事

    • 我们之前使用过的注解：
      1).@Override：子类重写方法时——编译时起作用
      2).@FunctionalInterface：函数式接口——编译时起作用
      3).@Test：JUnit的测试注解——运行时起作用

注解的作用

  • 生成帮助文档：@author和@version

  • 执行编译期的检查 例如:@Override

  • 框架的配置(框架=代码+配置)

    • 具体使用请关注框架课程的内容的学习。

小结

  1. 注解用在“源码中”，作为一个“标记”。给“注解解析器”看的，告诉“注解解析器”怎样编译、运行下面的代码。
  2. 开发中,我们一般都是使用注解

知识点-JDK提供的三个基本的注解

目标

  • 掌握JDK中提供的三个基本的注解

路径

  • 三个基本的注解

讲解

  1. @Override:描述方法的重写.
  3. @SuppressWarnings:压制\忽略警告.
  5. @Deprecated:标记过时

小结

  1. @Override: 重写父类的方法
  2. @SuppressWarnings: 压制警告
  3. @Deprecated: 标记方法的过时

知识点-自定义注解

目标

  • 掌握自定义注解和定义注解属性

路径

  • 自定义注解格式
  • 定义注解属性

讲解

自定义注解语法

  1. public @interface 注解名{
  2.      属性
  3. }
  • 示例代码
  1. /**
  2.  * 定义了注解
  3.  *
  4.  */
  5. public @interface Annotation01 {
  7. }

注解属性

格式
  • 数据类型 属性名();

属性类型
  1. 1.基本类型
  3. 2.String
  5. 3.Class类型
  7. 4.注解类型
  9. 5. 枚举类型
  11. 6.以上类型的一维数组类型
  • 示例代码
  1. public @interface Annotation01 {
  2.     // 1.基本数据类型(4类8种)
  3.     int a();
  4.     double b();
  6.     // 2.String类型
  7.     String c();
  9.     // 3.Class类型
  10.     Class d();
  12.     // 4.注解类型
  13.     Annotation02 f();
  15.     // 5.枚举类型
  16.     Sex e();
  17.     // 6.以上类型的一维数组类型
  18.     int[] g();
  19.     double[] h();
  20.     String[] i();
  21.     Sex[] j();
  22.     Annotation02[] k();
  23. }

小结

略

知识点— 使用注解并给注解属性赋值

目标

  • 能够使用注解并给注解属性赋值

路径

  • 使用注解并给注解属性赋值

讲解

  1.  使用注解:
  2.         如果一个注解中有属性,那么使用注解的时候一定要给注解属性赋值
  3.         如果一个注解没用属性,那么就不需要给注解属性赋值,直接使用即可
  4. 如何给注解属性赋值:
  5.         @注解名(属性名=值,属性名2=值2)

案例演示
  1. public @interface MyAnnotation1 {
  2.     // 不定义注解属性
  3. }
  4. public @interface MyAnnotation2 {
  5.     int a();
  7.     String[] b();
  8. }
  10. @MyAnnotation1()
  11. public class Test1 {
  12.     @MyAnnotation1
  13.     public static void main(String[] args) {
  14.         /*
  15.             使用注解:
  16.                 不带属性的注解: 注解中没有定义属性,或者里面的属性已经给了默认值
  17.                      在需要使用该注解的地方,写上 @注解名 即可 或者 @注解名()
  20.          */
  21.     }
  22. }
  24. @MyAnnotation2(a=18,b={"itheima","itcast"})
  25. public class Test2 {
  27.     @MyAnnotation2(a=18,b={"itheima","itcast"})
  28.     public static void main(String[] args) {
  29.         /*
  30.              使用注解:
  31.                 带有属性的注解: 注解中定义了属性,并这些属性没有给默认值
  32.                     标准格式: @注解名(属性名=属性值,属性名=属性值,....)
  33.          */
  35.     }
  36. }

小结

略

知识点—给注解属性赋值的注意事项

目标

  • 理解给注解属性赋值的注意事项

路径

讲解

  • 一旦注解有属性了,使用注解的时候,属性必须有值
  • 若属性类型是一维数组的时候,当数组的值只有一个的时候可以省略{}
  • 如果注解中只有一个属性,并且属性名为value,那么使用注解给注解属性赋值的时候,注解属性名value可以省略
  • 注解属性可以有默认值 格式:属性类型 属性名() defaul t 默认值;
  1. public @interface MyAnnotation1 {
  2.     int a();
  3. }
  5. public @interface MyAnnotation2 {
  6.     int[] arr();
  7. }
  9. public @interface MyAnnotation3 {
  10.     int value();
  11. }
  13. public @interface MyAnnotation33 {
  14.     String[] value();
  15. }
  17. public @interface MyAnnotation4 {
  18.     int a() default 10;
  19. }
  21. public class Test {
  22.     public static void main(String[] args) {
  23.         /*
  24.             给注解属性赋值的注意事项:
  25.                 - 一旦注解有属性了,使用注解的时候,属性必须有值
  26.                 - 若属性类型是一维数组的时候,当数组的值只有一个的时候可以省略{}
  27.                 - 如果注解中只有一个属性,并且属性名为value,那么使用注解给注解属性赋值的时候,注解属性名value可以省略
  28.                 - 注解属性可以有默认值  格式:属性类型 属性名() defaul t 默认值;
  30.          */
  31.     }
  33.     //  注解属性可以有默认值  格式:属性类型 属性名() defaul t 默认值;
  34.     //@MyAnnotation4
  35.     //@MyAnnotation4()
  36.     @MyAnnotation4(a = 100)
  37.     public static void method4(){
  39.     }
  41.     // 若属性类型是一维数组的时候,当数组的值只有一个的时候可以省略{}
  42.     //如果注解中只有一个属性,并且属性名为value,那么使用注解给注解属性赋值的时候,注解属性名value可以省略
  43.     //@MyAnnotation33(value={"itheima","itcast"})
  44.     //@MyAnnotation33(value={"itheima"})
  45.     //@MyAnnotation33(value="itheima")
  46.     @MyAnnotation33("itheima")
  47.     public static void method33(){
  49.     }
  51.     // 如果注解中只有一个属性,并且属性名为value,那么使用注解给注解属性赋值的时候,注解属性名value可以省略
  52.     //@MyAnnotation3(value=10)
  53.     @MyAnnotation3(10)
  54.     public static void method3(){
  56.     }
  58.     // 若属性类型是一维数组的时候,当数组的值只有一个的时候可以省略{}
  59.     // @MyAnnotation2(arr={10,20,30})
  60.     // @MyAnnotation2(arr={10})
  61.     @MyAnnotation2(arr=10)
  62.     public static void method2(){
  64.     }
  66.     // 一旦注解有属性了,使用注解的时候,属性必须有值
  67.     @MyAnnotation1(a = 10)
  68.     public static void method1(){
  70.     }
  72. }

小结

略

知识点-元注解

目标

  • 能够说出常用的元注解及其作用

路径

  • 什么是元注解
  • 常见的元注解

讲解

什么是元注解

  1. 定义在注解上的注解

常见的元注解

  1. @Target:表示该注解作用在什么上面(位置),默认注解可以在任何位置. 值为:ElementType的枚举值
  3.     METHOD:方法
  5.     TYPE:类 接口
  7.     FIELD:字段
  9.     CONSTRUCTOR:构造方法声明
  11. @Retention:定义该注解保留到那个代码阶段, 值为:RetentionPolicy类型,默认只在源码阶段保留
  13.     SOURCE:只在源码上保留(默认)
  15.     CLASS:在源码和字节码上保留
  17.     RUNTIME:在所有的阶段都保留

.java (源码阶段) ——编译—-> .class(字节码阶段) ——加载内存—> 运行(RUNTIME)

案例:

  1. // 标准格式:
  2. //@Target(value={ElementType.TYPE,ElementType.FIELD,ElementType.METHOD,ElementType.LOCAL_VARIABLE})
  3. //@Retention(value= RetentionPolicy.RUNTIME)
  4.     // 省略格式
  5. @Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD,ElementType.LOCAL_VARIABLE})
  6. @Retention(RetentionPolicy.RUNTIME)
  7. public @interface MyAnnotation1 {// 默认该注解可以在任何位置使用
  9. }
  11. @MyAnnotation1
  12. public class Test1 {
  14.     @MyAnnotation1
  15.     int age = 18;
  17.     @MyAnnotation1
  18.     public static void main(String[] args) {
  20.         @MyAnnotation1
  21.         int num1 = 10;// 局部变量
  23.         // jdk中的@Override
  24.         // @Override // 编译报错
  25.         int num2 = 10;// 局部变量
  27.     }
  29.     @Override
  30.     public String toString() {
  31.         return super.toString();
  32.     }
  33. }

小结

略

知识点-注解解析

目标

  • 理解常见注解解析方法

路径

  • 使用注解解析

讲解

java.lang.reflect.AnnotatedElement接口: Class、Method、Field、Constructor等实现了AnnotatedElement

  • T getAnnotation(ClassannotationType):得到指定类型的注解引用。没有返回null。

  • boolean isAnnotationPresent(Class<?extends Annotation> annotationType)：判断指定的注解有没有。

  1. @Target(ElementType.METHOD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface MyAnnotation1 {
  4.     String name();
  6.     int age();
  8. }
  11. public class Test {
  13.     @MyAnnotation1(name="张三",age=18)
  14.     public void show1(){
  15.         System.out.println("show1方法执行了....");
  16.     }
  18.     public void show2(){
  19.         System.out.println("show2方法执行了....");
  20.     }
  22.     public static void main(String[] args) throws Exception{
  23.         /*
  24.             java.lang.reflect.AnnotatedElement接口: Class、Method、Field、Constructor等实现了AnnotatedElement
  25.             - T getAnnotation(Class<T> annotationType):得到指定类型的注解引用。没有返回null。
  26.             - boolean isAnnotationPresent(Class<?extends Annotation> annotationType)：判断指定的注解有没有。
  28.          */
  29.         // 需求:1.获取show1方法上面的注解对象
  30.         // 1.1 得到Test类的Class对象
  31.         Class<?> c = Class.forName("com.itheima.demo12_注解解析.Test");
  33.         // 1.2 获得show1方法的Method对象
  34.         Method show1M = c.getDeclaredMethod("show1");
  36.         // 1.3 根据Method对象调用getAnnotation()方法得到注解对象
  37.         MyAnnotation1 a1 = show1M.getAnnotation(MyAnnotation1.class);
  38.         System.out.println(a1.name());
  39.         System.out.println(a1.age());
  41.         System.out.println("======================");
  43.         // 2.需求: 判断某个方法上是否有MyAnnotation1注解
  44.         // 判断show1方法上是否有MyAnnotation1注解
  45.         boolean res1 = show1M.isAnnotationPresent(MyAnnotation1.class);
  46.         System.out.println(res1);// true
  48.         // 判断show2方法上是否有MyAnnotation1注解
  49.         Method show2M = c.getDeclaredMethod("show2");
  50.         boolean res2 = show2M.isAnnotationPresent(MyAnnotation1.class);
  51.         System.out.println(res2);// false
  53.     }
  54. }

小结

略

实操—完成注解的MyTest案例

需求

  1. 在一个类(测试类,TestDemo)中有三个方法,其中两个方法上有@MyTest,另一个没有.还有一个主测试类(MainTest)中有一个main方法.  在main方法中,让TestDemo类中含有@MyTest方法执行.   自定义@MyTest, 模拟单元测试.

思路分析

  1. 定义两个类和一个注解

  2. 在MainTest的main()方法里面:
    //1.获得TestDemo字节码对象
    //2.反射获得TestDemo里面的所有的方法
    //3.遍历方法对象的数组. 判断是否有@MyTest(isAnnotationPresent)
    //4.有就执行(method.invoke())

代码实现

  • MyTest.java
  1. @Target(ElementType.METHOD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface MyTest {
  5. }
  • TestDemo.java
  1. public class TestDemo {
  2.     @MyTest
  3.     public void show1(){
  4.         System.out.println("show1方法执行了...");
  5.     }
  7.     @MyTest
  8.     public void show2(){
  9.         System.out.println("show2方法执行了...");
  10.     }
  12.     public void show3(){
  13.         System.out.println("show3方法执行了...");
  14.     }
  16. }
  • MainTest.java
  1. public class MainTest {
  3.     public static void main(String[] args) throws Exception {
  4.         // 让第一个类中含有@MyTest注解的方法执行
  5.         // 1.获取TestDemo类的字节码对象
  6.         Class<TestDemo> clazz = TestDemo.class;
  8.         // 2.使用字节码对象获取该类中所有方法对象
  9.         Method[] methods = clazz.getDeclaredMethods();
  11.         // 3.循环遍历所有方法对象
  12.         for (Method method : methods) {
  13.             // 4.在循环中,判断遍历出来的方法对象是否含有@MyTest注解
  14.             boolean res = method.isAnnotationPresent(MyTest.class);
  15.             if (res) {
  16.                 // 5.如果有,就调用该方法执行
  17.                 method.invoke(clazz.newInstance());
  18.             }
  19.         }
  21.     }
  23. }

小结

略

第四章 动态代理

目标

  • 能够使用动态代理生成一个代理对象

路径

  • 代理模式概念
  • 动态代理
  • 动态代理相关api介绍
  • 案例演示

讲解

代理模式概述

为什么要有“代理”？生活中就有很多代理的例子，例如，我现在需要出国，但是我不愿意自己去办签证、预定机票和酒店（觉得麻烦 ，那么就可以找旅行社去帮我办，这时候旅行社就是代理，而我自己就是被代理了。

代理模式的定义：被代理者没有能力或者不愿意去完成某件事情，那么就需要找个人代替自己去完成这件事,这个人就是代理者, 所以代理模式包含了3个角色: 被代理角色 代理角色 抽象角色(协议)

静态代理:

  1. public interface Happy {// 协议,被代理者需要代理的方法,就定义在这里,然后让代理者和被代理者去实现
  2.     // 被代理者实现: 为了确保和代理者实现的方法一致
  3.     // 代理者实现: 为了增强被代理者的这些方法
  4.     public abstract void happy();
  5. }
  8. public class JinLian implements Happy {
  10.     public void happy(){
  11.         System.out.println("金莲在happy...");
  12.     }
  14. }
  17. public class WangPo implements Happy{
  18.     // 成员变量
  19.     JinLian jl;
  21.     // 构造方法
  22.     public WangPo(JinLian jl) {
  23.         this.jl = jl;
  24.     }
  26.     // 成员方法
  27.     @Override
  28.     public void happy() {
  29.         System.out.println("王婆以做衣服的名义开好房间,并把2人约到房间里...");
  30.         // 金莲happy
  31.         jl.happy();
  32.         System.out.println("王婆打扫战场...");
  33.     }
  34. }
  37. public class XiMen {
  38.     public static void main(String[] args) {
  39.         /*
  40.             案例: 金莲要找西门happy
  41.             代理模式的定义：被代理者没有能力或者不愿意去完成某件事情，那么就需要找个人代替自己去完成这件事,这个人就是代理者,
  42.             所以代理模式包含了3个角色: 被代理角色     代理角色    抽象角色(协议)
  44.          */
  45.         // 不请代理: 金莲直接找西门happy
  46.         // 创建金莲对象
  47.         JinLian jl = new JinLian();
  48.         // happy
  49.         // jl.happy();
  51.         // 请代理: 静态代理,代理类真实存在
  52.         Happy wp = new WangPo(jl);// wp:代理对象   WangPo类: 代理类   Happy接口: 协议  JinLian: 被代理类
  53.         wp.happy();
  54.     }
  55. }

动态代理介绍

  • 概述 : 动态代理就是直接通过反射生成一个代理对象,代理对象所属的类是不需要存在的

  • 动态代理的获取:
    jdk提供一个Proxy类可以直接给实现接口类的对象直接生成代理对象

动态代理相关api介绍

Java.lang.reflect.Proxy类可以直接生成一个代理对象

  • Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象

    • 参数1:ClassLoader loader 被代理对象的类加载器
    • 参数2:Class<?>[] interfaces 被代理对象的要实现的接口
    • 参数3:InvocationHandler h (接口)执行处理接口
    • 返回值: 代理对象
    • 前2个参数是为了帮助在jvm内部生成被代理对象的代理对象,第3个参数,用来监听代理对象调用方法,帮助我们调用方法

  • InvocationHandler中的Object invoke(Object proxy, Method method, Object[] args)方法：调用代理类的任何方法，此方法都会执行

    • 参数1:代理对象(慎用)
    • 参数2:当前执行的方法
    • 参数3:当前执行的方法运行时传递过来的参数
    • 返回值:当前方法执行的返回值

案例演示

案例1: 代理方法无参数
  1. public interface Happy {// 协议,被代理者需要代理的方法,就定义在这里,然后让代理者和被代理者去实现
  2.     // 被代理者实现: 为了确保和代理者实现的方法一致
  3.     // 代理者实现: 为了增强被代理者的这些方法
  4.     public abstract void happy();
  5. }
  8. public class JinLian implements Happy {
  10.     public void happy(){
  11.         System.out.println("金莲在happy...");
  12.     }
  14. }
  17. public class XiMen {
  18.     public static void main(String[] args) {
  19.         /*
  20.             案例: 金莲要找西门happy
  21.             代理模式的定义：被代理者没有能力或者不愿意去完成某件事情，那么就需要找个人代替自己去完成这件事,这个人就是代理者,
  22.             所以代理模式包含了3个角色: 被代理角色     代理角色    抽象角色(协议)
  24.          */
  25.         // 不请代理: 金莲直接找西门happy
  26.         // 创建金莲对象
  27.         JinLian jl = new JinLian();
  28.         // happy
  29.         // jl.happy();
  31.         // 请代理: 静态代理,代理类真实存在
  32.         Happy wp = new WangPo(jl);// wp:代理对象   WangPo类: 代理类   Happy接口: 协议  JinLian: 被代理类
  33.         wp.happy();
  35.         /*
  36.             问题:
  37.                 1.金莲不方便直接找西门happy
  38.                 2.金莲的happy方法需要增强一下,例如:happy之前需要开房,happy之后需要打扫战场
  40.             静态代理: 代理类是真实存在的,通过代理类产生代理对象
  41.             动态代理: 代理类是不真实存在的,在程序运行中,直接产生代理对象
  42.             前提: 被代理类需要实现接口
  43.             动态代理实现获取代理对象:
  44.                 jdk提供一个Proxy类可以直接给实现接口类的对象直接生成代理对象
  45.                 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象
  46.                     参数1loader:被代理类的类加载器
  47.                     参数2interfaces: 被代理类所有实现的接口的Class对象
  48.                     参数3InvocationHandler: 执行处理类
  49.                     前2个参数是为了帮助在jvm内部生成被代理类的代理对象,第3个参数用来监听代理对象调用的方法,帮助我们代理对象调用方法
  50.          */
  51.         System.out.println("=========================================");
  53.         // 使用动态代理直接产生金莲的代理对象
  54.         // 动态代理: 代理类是不真实存在的,但代理类是一定实现了被代理类的接口的
  55.         // p:动态代理产生的代理对象 代理类是不真实存在的
  56.         Happy p = (Happy) Proxy.newProxyInstance(JinLian.class.getClassLoader(), JinLian.class.getInterfaces(), new InvocationHandler() {
  57.             @Override
  58.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  59.                 // 回调方法: 当代理对象调用了方法,就会来执行该invoke方法, 在该方法中就可以增强被代理类的方法
  60.                 // 参数1: 生成的代理对象 这里就是p这个代理对象 (慎用)
  61.                 // 参数2: 当前代理对象执行的方法 这里method就是happy()方法对象
  62.                 // 参数3: 当前代理对象执行的方法,传入的实际参数
  63.                 // 返回值:当前代理对象执行的方法的返回值
  64.                 // System.out.println("invoke");
  65.                 // 王婆开房
  66.                 System.out.println("王婆以做衣服的名义开好房间,把2人约到房间...");
  68.                    // 金莲happy
  69.                 method.invoke(jl);
  72.                 // 王婆打扫
  73.                 System.out.println("王婆打印战场...");
  74.                 return null;
  75.             }
  76.         });
  78.         // 代理happy
  79.         p.happy();// 无参数
  80.     }
  81. }

案例2: 代理方法有参数和代理多个方法
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         /*
  4.             需求:
  5.                 对List接口进行代理，以前的remove(Object obj)方法是删除集合中第一次出现的元素
  6.                 (比如集合中有多个“abc”,调用remove(“abc”)后只会删除一个元素)。
  7.                 代理后，要求在调用remove(Object obj)方法后，能够删除集合中所有匹配的元素。【动态代理】
  8.             动态代理步骤:
  9.                 1.使用Proxy调用newProxyInstance()方法动态获取代理对象
  10.                 2.在InvocationHandler中的invoke方法进行增强代理的方法
  11.          */
  12.         // ArrayList看成被代理类
  13.         ArrayList<String> list = new ArrayList<>();// JinLian
  14.         list.add("abc");
  15.         list.add("bac");
  16.         list.add("cba");
  17.         list.add("abc");
  18.         list.add("abc");
  19.         list.add("abc");
  20.         list.add("abc");
  21.         System.out.println("删除前:"+list);// [abc, bac, cba, abc, abc, abc, abc]
  23.         // 获取代理对象
  24.         List<String> proxy = (List<String>)Proxy.newProxyInstance(list.getClass().getClassLoader(),ArrayList.class.getInterfaces(), new InvocationHandler() {
  25.             @Override
  26.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  27.                 // 代理对象调用方法就会来到这里
  28.                 Object res = method.invoke(list, args);
  30.                 if (method.getName().equals("remove")){
  31.                     // 迭代器循环删除
  32.                     Iterator<String> it = list.iterator();
  33.                     while (it.hasNext()) {
  34.                         String e = it.next();
  35.                         if (e.equals(args[0])){// false
  36.                             it.remove();
  37.                         }
  38.                     }
  39.                 }
  41.                 if (method.getName().equals("set")){
  42.                     System.out.println("hhhhhhhhh....");
  43.                 }
  44.                 return res;
  45.             }
  46.         });
  48.         // 代理对象.remover("abc"); //  [bac, cba]
  49.         boolean res = proxy.remove("abc");// 拆箱
  50.         System.out.println("res:"+res);// true
  51.         System.out.println("删除后:"+list);// [bac, cba]
  54.         // 调用proxy调用set方法设置值
  55.         String res2 = proxy.set(0, "acb");
  56.         System.out.println("res2:"+res2);// res2: bac
  57.         System.out.println("设置后:"+list);// [bac, cba]
  59.         // 未使用代理
  60.         // list.remove("abc");
  61.         // System.out.println("删除后:"+list);// [bac, cba, abc, abc, abc, abc]
  62.     }
  63. }

小结

略

第五章JDK8新特性

知识点—方法引用

目标

  • 什么是方法引用,方法引用的使用场景

路径

  • 方法引用概述

讲解

方法引用概述

  • 方法引用使用一对冒号 :: , 方法引用就是用来在一定的情况下,替换Lambda表达式

方法引用基本使用

  • 使用场景:

    • 如果一个Lambda表达式大括号中的代码和另一个方法中的代码一模一样,那么就可以使用方法引用把该方法引过来,从而替换Lambda表达式
    • 如果一个Lambda表达式大括号中的代码就是调用另一方法,那么就可以使用方法引用把该方法引过来,从而替换Lambda表达式
  1. public class Demo {
  3.     public static void printStr(){
  4.         System.out.println("任务执行了...");
  5.     }
  7.     public static void main(String[] args) {
  8.         // 创建线程并启动线程
  9.         // 1.匿名内部类的方式
  10.         new Thread(new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 System.out.println("任务执行了...");
  14.             }
  15.         }).start();
  17.         // 2.Lambda表达式的方式
  18.         new Thread(()->{System.out.println("任务执行了...");}).start();// 这个Lambda表达式大括号中的代码和Demo类的printStr()方法一模一样,符合方法引用替换Lambda表达式的场景
  20.         new Thread(()->{Demo.printStr();}).start();// 这个Lambda表达的大括号中其实就是调用Demo类的printStr()方法,符合方法引用替换Lambda表达式的场景
  22.         // 3.方法引用的方式:
  23.         new Thread(Demo::printStr).start();
  24.     }
  25. }

小结

略

知识点—方法引用的分类

目标

  • 能够正确书写方法引用

路径

  • 构造方法引用
  • 静态方法引用
  • 对象成员方法引用
  • 类的成员方法引用

讲解

构造方法引用

  1. public class Test2 {
  2.     public static void main(String[] args) {
  3.         //创建集合
  4.         ArrayList<String> list = new ArrayList<>();
  5.         list.add("杨紫");
  6.         list.add("迪丽热巴");
  7.         list.add("陈钰琪");
  9.         // 需求: 把集合中的元素转换为Person对象,打印输出
  10.         list.stream().map(s-> new Person(s)).forEach(s-> System.out.println(s));
  12.         System.out.println("======================");
  14.         list.stream().map(Person::new).forEach(s-> System.out.println(s));
  16.     }
  17. }

静态方法引用

  1. public class Test2 {
  2.     public static void main(String[] args) {
  3.         //创建集合
  4.         ArrayList<String> list = new ArrayList<>();
  5.         list.add("110");
  6.         list.add("111");
  7.         list.add("112");
  9.         // 需求:把集合中的元素转换为int类型,打印输出
  10.         list.stream().map(s-> Integer.parseInt(s)).forEach(s-> System.out.println(s));
  12.         System.out.println("======================");
  14.         list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));
  16.     }
  17. }

对象成员方法引用

  • 成员方法有参数

    1. public class Test2 {
    2.   public static void main(String[] args) {
    3.       //创建集合
    4.       ArrayList<String> list = new ArrayList<>();
    5.       list.add("杨紫");
    6.       list.add("迪丽热巴");
    7.       list.add("陈钰琪");
    9.       // 需求:把集合中所有元素打印输出
    10.       list.stream().forEach(s-> System.out.println(s));
    12.       System.out.println("=================================");
    14.       list.stream().forEach(System.out::println);
    16.   }
    17. }

类的成员方法引用

  • 成员方法没有参数

    1. public class Test2 {
    2.   public static void main(String[] args) {
    3.       //创建集合
    4.       ArrayList<String> list = new ArrayList<>();
    5.       list.add("杨紫");
    6.       list.add("迪丽热巴");
    7.       list.add("陈钰琪");
    9.       // 需求: 把集合中的元素转换为该元素对应的字符长度,打印输出
    10.       list.stream().map(s->s.length()).forEach(System.out::println);
    12.       System.out.println("=================================");
    13.       //会默认的用参数s去调用String类中的length()方法
    14.       list.stream().map(String::length).forEach(System.out::println);
    16.   }
    17. }

小结

  1. 总结:使用方法引用的步骤
  2.     1.分析要写的Lambda表达式的大括号中是否就是调用另一个方法
  3.     2.如果是,就可以使用方法引用替换,如果不是,就不能使用方法引用
  4.     3.确定引用的方法类型(构造方法,成员方法,静态方法,类的成员方法)
  5.     4.按照对应的格式去引用:
  6.         构造方法: 类名::new
  7.         成员方法(有参数): 对象名::方法名
  8.         静态方法: 类名::方法名
  9.         类的成员方法\成员方法(无参数):  类名::方法名

知识点—Base64

目标

  • 会使用Base64对数据进行编码和解码

路径

  • Base64概述
  • Base64内嵌类和方法描述
  • Base64代码演示

讲解

Base64概述

  • Base64是jdk8提出的一个新特性,可以用来进行按照一定规则编码和解码

Base64编码和解码的相关方法

  • 编码的步骤:

    • 获取编码器
    • 调用方法进行编码

  • 解码步骤:

    • 获取解码器
    • 调用方法进行解码

  • Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

    • 基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。
    • URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。
    • MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。
  • 获取编码器和解码器的方法 ```java static Base64.Decoder getDecoder() 基本型 base64 解码器。 static Base64.Encoder getEncoder() 基本型 base64 编码器。

static Base64.Decoder getMimeDecoder() Mime型 base64 解码器。 static Base64.Encoder getMimeEncoder() Mime型 base64 编码器。

static Base64.Decoder getUrlDecoder() Url型 base64 解码器。 static Base64.Encoder getUrlEncoder() Url型 base64 编码器。

  3. - 
  4. 编码和解码的方法:
  5. ```java
  6. Encoder编码器:  encodeToString(byte[] bys)编码
  7. Decoder解码器:  decode(String str) 解码

案例演示

  • 基本
  1. public class Test1 {
  2.     public static void main(String[] args) {
  3.         // 使用基本型的编码器和解码器对数据进行编码和解码:
  4.         // 1.获取编码器
  5.         Base64.Encoder encoder = Base64.getEncoder();
  7.         // 2.对字符串进行编码
  8.         String str = "name=中国?password=123456";
  9.         String str1 = encoder.encodeToString(str.getBytes());
  11.         // 3.打印输出编码后的字符串
  12.         System.out.println("编码后的字符串:"+str1);
  14.         // 4.获取解码器
  15.         Base64.Decoder decoder = Base64.getDecoder();
  17.         // 5.对编码后的字符串进行解码
  18.         byte[] bys = decoder.decode(str1);
  19.         String str2 = new String(bys);
  21.         // 6.打印输出解码后的字符串
  22.         System.out.println("解码后的字符串:"+str2);
  23.     }
  24. }
  • URL
  1. public class Test2 {
  2.     public static void main(String[] args) {
  4.         // 使用URL型的编码器和解码器对数据进行编码和解码:
  5.         // 1.获取编码器
  6.         Base64.Encoder encoder = Base64.getUrlEncoder();
  8.         // 2.对字符串进行编码
  9.         String str = "name=中国?password=123456";
  10.         String str1 = encoder.encodeToString(str.getBytes());
  12.         // 3.打印输出编码后的字符串
  13.         System.out.println("编码后的字符串:"+str1);
  15.         // 4.获取解码器
  16.         Base64.Decoder decoder = Base64.getUrlDecoder();
  18.         // 5.对编码后的字符串进行解码
  19.         byte[] bys = decoder.decode(str1);
  20.         String str2 = new String(bys);
  22.         // 6.打印输出解码后的字符串
  23.         System.out.println("解码后的字符串:"+str2);
  24.     }
  25. }
  • MIME
  1. public class Test3 {
  2.     public static void main(String[] args) {
  3.         // 使用MIME型的编码器和解码器对数据进行编码和解码:
  4.         // 1.获取编码器
  5.         Base64.Encoder encoder = Base64.getMimeEncoder();
  7.         // 2.对字符串进行编码
  8.         String str = "";
  9.         for (int i = 0; i < 100; i++) {
  10.             str += i;
  11.         }
  12.         System.out.println("编码前的字符串:"+str);
  14.         String str1 = encoder.encodeToString(str.getBytes());
  16.         // 3.打印输出编码后的字符串
  17.         System.out.println("编码后的字符串:"+str1);
  19.         // 4.获取解码器
  20.         Base64.Decoder decoder = Base64.getMimeDecoder();
  22.         // 5.对编码后的字符串进行解码
  23.         byte[] bys = decoder.decode(str1);
  24.         String str2 = new String(bys);
  26.         // 6.打印输出解码后的字符串
  27.         System.out.println("解码后的字符串:"+str2);
  28.     }
  29. }

小结

略

总结

  1. - 能够使用Junit进行单元测试
  2.     拷贝Junit的jar包到模块的lib文件夹下
  3.     添加到classpath路径中
  4.     在测试方法上面使用@Test注解修饰
  5.     执行
  6. - 能够通过反射技术获取Class字节码对象
  7.    类名.class
  8.    对象名.getClass()
  9.    Class.forName(类的全路径)
  10. - 能够通过反射技术获取构造方法对象，并创建对象。
  11.      getDeclaredConstructor(Class... parameterType) 
  12.     getDeclaredConstructors() 
  13.      newInstance(Object... initargs)
  14.      void setAccessible(true)
  15. - 能够通过反射获取成员方法对象，并且调用方法。
  16.      getDeclaredMethod(String name,Class... parameterType) 
  17.      getDeclaredMethods() 
  18.      invoke(Object obj,Object... initargs)
  19.      void setAccessible(true)
  20. - 能够通过反射获取属性对象，并且能够给对象的属性赋值和取值。
  21.      getDeclaredField(String name) 
  22.      Field[] getDeclaredFields();
  23.      set(Object obj,Object value)
  24.      get(Object obj)
  25.      void setAccessible(true)
  26. - 能够说出注解的作用 
  27.      编译检查
  28.      生成文档
  29.      框架配置
  30. - 能够自定义注解和使用注解
  31.     public @interface 注解名{
  32.          数据类型 属性名();
  33.      }
  34.      没有属性: @注解名   @注解名()
  35.      有属性:  @注解名(属性名=属性值,属性名=属性值)
  36.      如果属性名为value,那么赋值的时候属性名可以省略
  37.      如果属性是数组类型,并且赋值的时候数组中只有一个值,那么大括号可以省略
  38. - 能够说出常用的元注解及其作用
  39.       @Target   用来限制注解可以使用的位置
  40.       @Retention  用来限制注解可以保留到哪个阶段
  41. - 能够解析注解并获取注解中的数据
  42.        T getAnnotation(Class<T> annotationType):
  43.        boolean isAnnotationPresent(Class<?extends Annotation> annotationType)
  44. - 能够完成注解的MyTest案例
  45.         获取类的字节码对象
  46.         获取所有的方法对象
  47.         遍历所有方法的对象
  48.         判断方法上是否有注解
  49.         如果有注解就执行该方法
  50. - 能够说出动态代理模式的作用
  51.       动态的生成一个代理对象,并且可以增强被代理里的方法
  52. - 能够使用Proxy的方法生成代理对象
  53.       Proxy.newProxyInstance(ClassLoader c, Class[] interfaces,InvocationHandler i)
  54. - 能够使用四种方法的引用
  55.       构造方法: 类名::new
  56.       静态方法: 类名::方法名
  57.       对象成员方法(有参数): 对象::方法名
  58.       类成员方法(无参数): 类名::方法名
  59. - 能够使用Base64对基本数据、URL和MIME类型进行编解码
  60.      获取编码器,对数据进行编码
  61.      获取解码器,对数据进行解码