• JavaSE高级

    目录

    一、单元测试

     1、Junit单元测试框架

     2、单元测试步骤​编辑

    3、Junit常用注解

    二、反射

     1、反射获取Class对象

     2、反射获取构造器

     3、反射获取成员变量

     4、反射获取成员方法

     5、反射的作用1 --绕过编译阶段为集合添加数据

     6、反射的作用2 --通用框架的底层原理

    三、注解

    1、注解概述

    2、自定义注解

    3、元注解

    4、注解解析

    四、动态代理

    1、动态代理概述

    2、动态代理模拟开发

    五、XML

    1、XML概述

    2、XML的创建、语法规则

    3、XML文档约束

    4、XML解析

    一、单元测试

     1、Junit单元测试框架

     2、单元测试步骤

    1. public class JunitDemo1 {
    2.     public String login(String userName,String password){
    3.         if ("admin".equals(userName) && "12345".equals(password)){
    4.             return "登陆成功";
    5.         }else {
    6.             return "您的账户或密码有问题";
    7.         }
    8.     }
    9.  
    10.     public void selectName(){
    11.         System.out.println((10 / 0));
    12.     }
    13. }
    14.  
    15. //测试类
    16. public class TestJunitDEmo1 {
    17.     @Test
    18.     public void testLogin(){
    19.         JunitDemo1 j = new JunitDemo1();
    20.         String rs = j.login("admin","12345");
    21.  
    22.         //进行预期结果的正确性测试，断言
    23.         //参数一：错误备注
    24.         //参数二：预期输出结果
    25.         //参数三：实际输出结果
    26.         Assert.assertEquals("这里是错误备注","登陆成功",rs);
    27.     }
    28.     @Test
    29.     public void testName(){
    30.         JunitDemo1 j = new JunitDemo1();
    31.         //没有返回值可以直接调用
    32.         j.selectName();
    33.     }
    34. }

    3、Junit常用注解

    二、反射

     1、反射获取Class对象

    1. public class Test {
    2.     //反射第一步：获取Class对象
    3.     public static void main(String[] args) throws ClassNotFoundException {
    4.         //1、Class类中的一个静态方法：forName(全限名：包名 + 类名)
    5.         Class c = Class.forName("com.itheima.reflect.Student");
    6.         System.out.println(c);
    7.  
    8.         //2、类名.class
    9.         Class c1 = Student.class;
    10.         System.out.println(c1);
    11.         
    12.         //3、对象.getClass() 获取对象对应类的Class对象
    13.         Student s = new Student();
    14.         Class c2 = s.getClass();
    15.         System.out.println(c2);
    16.     }
    17. }

    2、反射获取构造器

     

    1. public class TestStudent {
    2.     //1、getConstructors
    3.     //获取全部的构造器并返回一个构造器集合：只能获取public修饰的构造器
    4.     //Constructor[] getConstructors()
    5.     @Test
    6.     public void getConstructors() {
    7.         //第一步获取类对象
    8.         Class c = Student.class;
    9.         //提取类中全部的构造器对象
    10.         Constructor[] constructors = c.getConstructors();
    11.         //遍历构造器
    12.         for (Constructor constructor : constructors) {
    13.             System.out.println(constructor.getName() + "====>" + constructor.getParameterCount());
    14.         }
    15.     }
    16.  
    17.     //2、getDeclaredConstructor
    18.     //获取全部构造器并返回一个集合，包括privat修饰的所有权限构造器
    19.     @Test
    20.     public void getDeclaredConstructors() {
    21.         //第一步获取类对象
    22.         Class c = Student.class;
    23.         //提取类中全部的构造器对象
    24.         Constructor[] constructors = c.getDeclaredConstructors();
    25.         //遍历构造器
    26.         for (Constructor constructor : constructors) {
    27.             System.out.println(constructor.getName() + "====>" + constructor.getParameterCount());
    28.         }
    29.     }
    30.  
    31.     //3、getConstructor 获取单个构造器，只能是public修饰
    32.     @Test
    33.     public void getConstructor() {
    34.         //第一步获取类对象
    35.         Class c = Student.class;
    36.  
    37.         try {
    38.             //提取类中的一个构造器对象(按照参数定位无参构造器)
    39.             Constructor con = c.getConstructor();
    40.             System.out.println(con.getName() + "====>" + con.getParameterCount());
    41.  
    42.         } catch (Exception e) {
    43.             e.printStackTrace();
    44.         }
    45.     }
    46.  
    47.     //4、getDeclaredConstructor 获取单个构造器 所有权限
    48.     @Test
    49.     public void getDeclaredConstructor() throws NoSuchMethodException {
    50.         //第一步获取类对象
    51.         Class c = Student.class;
    52.  
    53.         //提取类中的一个构造器对象(按照参数定位无参构造器)
    54.         Constructor con = c.getDeclaredConstructor();
    55.         System.out.println(con.getName() + "====>" + con.getParameterCount());
    56.  
    57.         //获取有参构造器
    58.         //构造器为 字符串类和int类
    59.         Constructor con1 = c.getDeclaredConstructor(String.class, int.class);
    60.         System.out.println(con.getName() + "====>" + con1.getParameterCount());
    61.     }
    62.  
    63. }

    1. public class TestStudent2 {
    2.         //1、调用构造器得到一个类的对象返回
    3.         @Test
    4.         public void getDeclaredConstructor() throws Exception {
    5.             //第一步获取类对象
    6.             Class c = Student.class;
    7.  
    8.             //提取类中的一个构造器对象(按照参数定位无参构造器)
    9.             Constructor con = c.getDeclaredConstructor();
    10.             System.out.println(con.getName() + "====>" + con.getParameterCount());
    11.  
    12.             //如果构造器是私有的，可以暴力反射
    13.             //将私有权限打开
    14.             con.setAccessible(true);
    15.  
    16.            //2、根据构造器创建对象
    17.             Student student = (Student) con.newInstance();
    18.             System.out.println(student);
    19.         }
    20. }

    构造器来new自己

     3、反射获取成员变量

    1. public class TestFields {
    2.  
    3.     //1、获取全部成员变量 getDeclaredFields
    4.     @Test
    5.     public void getDeclaredFields(){
    6.         //1、获取Class类
    7.         Class c = Student.class;
    8.  
    9.         //获取全部成员变量
    10.         Field[] fields = c.getDeclaredFields();
    11.         for (Field field : fields) {
    12.             System.out.println(field.getName() + "===>" + field.getType());
    13.         }
    14.     }
    15.  
    16.     //2、获取某个成员变量 getDeclaredField
    17.     @Test
    18.     public void getDeclaredField() throws Exception {
    19.         //2、获取Class类
    20.         Class c = Student.class;
    21.  
    22.         //获取单个成员变量 根据成员名称获取
    23.         Field age = c.getDeclaredField("age");
    24.         //成员变量私有，反射暴力破解
    25.         age.setAccessible(true);
    26.  
    27.         //对获取到的成员变量进行赋值
    28.         Student s = new Student();
    29.         //年龄追着对象跑，年龄让对象将自己的值改为18 --反射
    30.         //正常是对象对自己说将年龄改成18
    31.         age.set(s,18);
    32.         System.out.println(s);
    33.  
    34.         //对成员变量取值
    35.         int a = (int)age.get(s);
    36.         System.out.println(a);
    37.     }
    38.  
    39. }

      4、反射获取成员方法

     

    1. public class Dog {
    2.     private String name;
    3.     .
    4.     .
    5.     .
    6.  
    7.     public void run(){
    8.         System.out.println("狗跑得快");
    9.     }
    10.  
    11.     public void eat(){
    12.         System.out.println("吃东西");
    13.     }
    14.  
    15.     private String eat(String name){
    16.         System.out.println("狗吃" + name);
    17.         return "吃得很开心";
    18.  
    19.     }
    20. }
    21.  
    22.  
    23.  
    24.  
    25. public class TestMethods {
    26.  
    27.     //1、获取所有成员方法 getDeclaredMethods
    28.     @Test
    29.     public void getDeclaredMethods(){
    30.         //1、获取Class类
    31.         Class c = Dog.class;
    32.  
    33.         //2、提取全部方法包括私有的
    34.         Method[] methods = c.getDeclaredMethods();
    35.  
    36.         //3、遍历全部方法
    37.         for (Method method : methods) {
    38.             System.out.println(method.getName() + "返回值类型：" + method.getReturnType() + "参数个数：" + method.getParameterCount());
    39.         }
    40.     }
    41.  
    42.     //2、获取单个成员方法 getDeclaredMethod
    43.     @Test
    44.     public void getDeclaredMethod() throws Exception {
    45.         //1、获取Class类
    46.         Class c = Dog.class;
    47.  
    48.         //2、提取单个方法
    49.         Method method = c.getDeclaredMethod("eat");
    50.         //参数一：方法名   参数二：参数类型
    51.         Method method2 = c.getDeclaredMethod("eat",String.class);
    52.  
    53.         //3、私有方法暴力反射
    54.         method.setAccessible(true);
    55.         method2.setAccessible(true);
    56.  
    57.         //4、创建对象触发方法执行
    58.         Dog d = new Dog();
    59.         //如果方法没有返回值会返回null
    60.         Object result = method.invoke(d);
    61.         //有参数的方法
    62.         Object result2 = method2.invoke(d,"骨头");
    63.         System.out.println(result);
    64.         System.out.println(result2);
    65.     }
    66. }

     5、反射的作用1 --绕过编译阶段为集合添加数据

    作用：可以绕过编译阶段向集合中添加元素，集合的泛型相当于厕所门口的标志，编译器相当于守厕所的大爷，男生如果要进入女厕所就会被大爷(编译器)拦下报错，但是通过反射可以绕过大爷，翻墙进入。使字符串类型加入到了整型列表中。

    1. public class ReflectFunction {
    2.     public static void main(String[] args) throws Exception {
    3.  
    4.         //这两个集合的底层都是Arraylist集合不会再区分泛型类型，对泛型进行擦除
    5.         ArrayList arrayList1 = new ArrayList<>();
    6.         ArrayList arrayList2 = new ArrayList<>();
    7.  
    8.         arrayList2.add(23);
    9.         arrayList2.add(34);
    10.         // 直接编译时报错 arrayList2.add("ewe");
    11.         //泛型相当于厕所的男女标志，编译器相当于守厕所的人
    12.         //加入你不是整型却要往整型列表中进，编译器就会编译时报错
    13.         //反射的作用就能够绕过这个编译器进入这个集合中
    14.  
    15.         //获取类对象
    16.         Class c = arrayList2.getClass();
    17.         //获取集合添加元素的方法  add(E e) 参数是任意类型 ->Object
    18.         Method add = c.getDeclaredMethod("add",Object.class);
    19.         //使用获取的方法向整型集合中添加字符串
    20.         Boolean aBoolean = (Boolean) add.invoke(arrayList2, "edd");
    21.         System.out.println(arrayList2);
    22.         //arrayList-> [23,34,edd]
    23.     }
    24. }

     6、反射的作用2 --通用框架的底层原理

    1. public class MyBatisUtil {
    2.  
    3.     //保存任意类型的对象
    4.     public static void save(Object object) {
    5.         try (
    6.                 PrintStream ps = new PrintStream(new FileOutputStream("javasehigh/src/datd.txt", true));
    7.         ) {
    8.             //1、获取对象的Class对象
    9.             Class c = object.getClass();
    10.  
    11.             //getSimpleName获取类名  getName获取全域名（包名+类名）
    12.             ps.println("============" + c.getSimpleName() + "==============");
    13.  
    14.             //2、获取全部成员变量
    15.             Field[] f = c.getDeclaredFields();
    16.  
    17.             //3、获取成员变量的信息
    18.             for (Field field : f) {
    19.                 //获取成员变量的名称
    20.                 String name = field.getName();
    21.                 //暴力反射解开私有构造器
    22.                 field.setAccessible(true);
    23.                 //获取成员变量的值，转化成字符串
    24.                 //成员变量追着对象调用它的值  object.getField
    25.                 // 例如学生对象的年龄，年龄告诉学生对象，把你的年龄输出。student.getName
    26.                 String value = field.get(object) + "";
    27.  
    28.                 ps.println(name + "=" + value);
    29.             }
    30.         } catch (Exception e) {
    31.             e.printStackTrace();
    32.         }
    33.     }
    34. }
    35.  
    36.  
    37. public class ReflectDemo {
    38.     public static void main(String[] args) {
    39.         Student student = new Student("张三",'男',"红星小学",13);
    40.         MyBatisUtil.save(student);
    41.         Teacher teacher = new Teacher("李四",34);
    42.         MyBatisUtil.save(teacher);
    43.  
    44.     }
    45. }

    三、注解

    1、注解概述

    对Java中类、方法、成员变量做标记，然后进行特殊处理。

    注解就相当于便签，可以在便签上随便声明，然后贴在任何地方

    2、自定义注解

     

    1. public @interface MyBook {
    2.     String name();
    3.     String[] authors();
    4.     double price();
    5. }
    6.  
    7. public @interface Book {
    8.     //1、只有一个特殊属性，调用注解可以不写变量值
    9.     String value();
    10.     //2、如果其他值设置了默认值使用注解时也可以不写
    11.     double price() default 9.9;
    12. }
    13.  
    14. @MyBook(name = "《测似乎》",authors = {"黑啊吗","csdc"},price = 13)
    15. public class AnnotationDemo {
    16.  
    17.     //注解中只有一个value特殊属性值可以不写值
    18.     @Book("/asc")
    19.     public static void main(String[] args) {
    20.  
    21.     }
    22. }

    3、元注解

    约束注解的一种注解

    1. //元注解：约束注解的对象，允许注解方法、成员变量和类
    2. @Target({ElementType.METHOD,ElementType.FIELD,ElementType.TYPE})
    3. //约束自定义注解的存活时间
    4. @Retention(RetentionPolicy.RUNTIME)
    5.  
    6. public @interface MyBook {
    7.     String name();
    8.     String[] authors();
    9.     double price();
    10. }

    4、注解解析

    1. //Book注解
    2. @Target({ElementType.METHOD,ElementType.TYPE})
    3. @Retention(RetentionPolicy.RUNTIME)
    4. public @interface Book {
    5.     String value();
    6.     double price() default 100;
    7.     String[] author();
    8. }
    9.  
    10.  
    11. @Book(value = "《三少爷的剑》",price = 99.9,author = {"古龙","测试"})
    12. public class BookStore {
    13.  
    14.     @Book(value = "《倚天屠龙记》",price = 399.9,author = {"金庸","测试"})
    15.     public static void test(){
    16.  
    17.     }
    18.  
    19.  
    20. public class BookStoreDemo {
    21.  
    22.     //解析BookStore的注解
    23.     @Test
    24.     public  void parseBook() throws Exception {
    25.         //1、获取Class对象
    26.         Class c = BookStore.class;
    27.         //2、获取成员方法
    28.         Method method = c.getDeclaredMethod("test");
    29.         //判断这个方法上是否有这个注解类型 ,用方法去调用
    30.         //method.isAnnotationPresent(Book.class)
    31.         //method.getDeclaredAnnotation(Book.class)
    32.         //3、判断这个类上是否有这个注解类型
    33.         if (c.isAnnotationPresent(Book.class)){
    34.             //4、获取注解内容，对类型强转
    35.             Book book = (Book)c.getDeclaredAnnotation(Book.class);
    36.             System.out.println(book.value());
    37.             System.out.println(book.price());
    38.             System.out.println(Arrays.toString(book.author()));
    39.         }
    40.     }
    41. }

    四、动态代理

    1、动态代理概述

    一定要使用接口约束行为才能动态代理。

    1. //明星类
    2. public class Star implements Skill{
    3.     //创建一个明星类实现约束接口
    4.     private String name;
    5.     .
    6.     .
    7.     .
    8.  
    9.     @Override
    10.     public void dance() {
    11.         System.out.println(name + "开始跳舞");
    12.     }
    13.  
    14.     @Override
    15.     public void sing() {
    16.         System.out.println(name + "开始唱歌");
    17.     }
    18. }
    19.  
    20. public interface Skill {
    21.     //定义一个接口约束明星的行为
    22.     void dance();
    23.     void sing();
    24. }
    25.  
    26.  
    27. //创建经纪人
    28. public class StarAgentProxy {
    29.     /**
    30.      将创建经纪人封装成一个方法
    31.      设计一个方法返回一个明星对象的代理对象
    32.      */
    33.     //返回值为Skill，因为经纪人是约束明星的行为所以他同样要实现Skill接口
    34.     //所以返回Skill父类创建代理对象，属于多态
    35.     public static Skill getProxy(Star s){
    36.         //为明星对象生成代理对象
    37.         /**
    38.          public static Object newProxyInstance(
    40.          ClassLoader loader,创建一个类加载器
    41.          这个方法底层会产生一个代理类，通过代理类产生代理对象，它自己生成代理类需要类加载器加载到内存
    43.          Class[] interfaces, 对象实现的接口列表
    44.          将明星对象的接口交给该方法，因为代理是为明星对象行为做代理，而明星对象的行为封装在接口里，让该方法直到要为哪些行为做代理
    46.          InvocationHandler h 代理的核心处理逻辑对象
    48.          */
    49.         return (Skill) Proxy.newProxyInstance(s.getClass().getClassLoader(), s.getClass().getInterfaces(),
    50.                 new InvocationHandler() {
    51.                     @Override
    52.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    53.                         System.out.println("收首款");
    54.                         //真正的让杨超越唱歌和跳舞
    55.                         // method 正在调用的方法对象 args 代表这个方法的参数
    56.                         //有返回值就接没有就返回null
    57.                         Object rs = method.invoke(s, args);
    58.                         System.out.println("收尾款，接回" + s.getName());
    59.                         return null;
    60.                     }
    61.                 });
    62.     }
    63. }
    64.  
    65.  
    66. //测试类
    67. public class Test {
    68.     public static void main(String[] args) {
    69.         //创建动态代理对象
    70.         //1、创建一个明星对象
    71.         Star s = new Star("张三");
    72.  
    73.         //2、如果要找明星就得先找他的经纪人
    74.         //为明星对象创建一个经纪人
    75.         Skill s2 = StarAgentProxy.getProxy(s);
    76.         //让他跳舞
    77.         //s2.dance();
    78.         //让他唱歌
    79.         s2.sing();
    80.     }
    81. }

     

    2、动态代理模拟开发

    1. //测试类
    2. public class Test {
    3.     public static void main(String[] args) {
    4.         UserServer user = new UserServerImplement();
    5.         //创建一个用户的代理对象
    6.         UserServer userServer = UserProxy.createProxy(user);
    7.         userServer.delete();
    8.     }
    9. }
    10.  
    11. //接口约束
    12. public interface UserServer {
    13.     void logim(String username,String password);
    14.     void delete();
    15.     void quary();
    16. }
    17.  
    18. //用户对象
    19. public class UserServerImplement implements UserServer{
    20.  
    21.     @Override
    22.     public void logim(String username,String password) {
    23.         if ("admin".equals(username) && "12345".equals(password)){
    24.  
    25.             try {
    26.                 Thread.sleep(1200);
    27.             } catch (InterruptedException e) {
    28.                 e.printStackTrace();
    29.             }
    30.             System.out.println("登陆成功");
    31.         }else {
    32.             try {
    33.                 Thread.sleep(1200);
    34.             } catch (InterruptedException e) {
    35.                 e.printStackTrace();
    36.             }
    37.             System.out.println("用户名或密码错误");
    38.         }
    39.     }
    40.  
    41.     @Override
    42.     public void delete() {
    43.         System.out.println("正在删除账户");
    44.         try {
    45.             Thread.sleep(2000);
    46.         } catch (InterruptedException e) {
    47.             e.printStackTrace();
    48.         }
    49.         System.out.println("删除成功！");
    50.  
    51.     }
    52.  
    53.     @Override
    54.     public void quary() {
    55.         System.out.println("正在查询。。");
    56.         try {
    57.             Thread.sleep(1600);
    58.         } catch (InterruptedException e) {
    59.             e.printStackTrace();
    60.         }
    61.         System.out.println("查询成功");
    62.     }
    63. }
    64.  
    65. //用户代理对象
    66. public class UserProxy {
    67.  
    68.     //创建代理对象并返回，封装方法
    69.     public static UserServer createProxy(UserServer user){
    70.         return (UserServer) Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(),
    71.                 new InvocationHandler() {
    72.                     @Override
    73.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    74.                         long startTime = System.currentTimeMillis();
    75.                         //方法执行
    76.                         Object rs = method.invoke(user,args);
    77.                         long overTime = System.currentTimeMillis();
    78.                         System.out.println(method.getName() + "方法耗时：" + (overTime - startTime) / 1000.0 + "s");
    79.                         return rs;
    80.  
    81.                     }
    82.                 });
    83.     }
    84.  
    85. }

    五、XML

    1、XML概述

     

     

    2、XML的创建、语法规则

    2. <student>
    3.     <name>张三name>
    4.     <sex>女sex>
    5.  
    6.     <sql>
    7.         
    8.         
    9.         select * from user where age < 18;
    10.         
    11.              直接写在数据区内就可以避免冲突
    12.              select * from user where age < 18;
    13.         ]]>
    14.     sql>
    15. student>

    3、XML文档约束

    1. dtd约束文件
    5. #PCDATA)>
    6. #PCDATA)>
    7. #PCDATA)>
    8.  
    11. SYSTEM "data.dtd">
    12. <书架>
    13.     <书>
    14.         <书名>
    15.         <作者>
    16.         <售价>
    17.

     

     

     

    4、XML解析

     

  • 相关阅读:
    黑胶歌曲没权限，还好我会Python，一分钟一个歌单，硬盘有点不够用了~
    强化学习学习笔记
    语音数据集2-VCTK多人音频
    电脑重装系统后DirectX12旗舰版禁用了怎么解决？
    OpenCV安装、QT、VS配置项目设置
    SQL按年月创建动态表
    chrome盗取用户身份
    新手学习c语言_第二部分
    【论文&模型讲解】多模态对话 Multimodal Dialogue Response Generation
    浅谈网络损伤仪HoloWAN的使用场景
  • 原文地址：https://blog.csdn.net/m0_56044262/article/details/125947242