devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

注解、泛型、枚举、Lambda表达式、JUnit单元测试

作者：你好赵伟 | 2024-05-02 09:46:55

赞

踩

泛型、注解、lambda、反射 试题

注解

1、JDK 1.5之后新特性
2、对元素进行说明（包、类、字段、方法、局部变量，方法参数）
  • 注解与注释的区别
  1. 注解：用特定格式名称说明程序，给计算机看的
  2.  
  3. 注释: 用文字说明程序，给程序员看的
  • 作用分类
  1. 1、编写文档的注解：生成Apidoc文档（写在注释中）
  2. 2、代码分析的注解：对代码进行分析(反射)
  3. 3、编译检查的注解：进行编译检查（@override）
  • 注解使用格式
  1. @注解名称
  2.  
  3. 编写文档：@since、@author、@version、@param、@return 一般都是JDK内置的，无法自定义
  4. 编译检查：@override 一般都是JDK内置的，无法自定义
  • JDK内置注解
  1. @override 检查标注的方法是否是父类（接口）的方法
  2. @Deprecated 标注过时
  3. @SuppressWarnings 抑制警告提示，一般用法@SuppressWarnings("all")
  • 自定义注解 —— 格式
  1. 元注解
  2. public @interface 注解名称{
  3.     属性列表;
  4. }
  • 自定义注解 —— 本质
自定义注解 本质上就是一个 接口，默认继承Annotation接口，所谓 属性列表就是 抽象方法
  • 自定义注解 —— 属性返回值的数据类型
  1. 基本数据类型
  2. String
  3. 注解
  4. 枚举
  5. 以上类型的数组
  6.  
  7. @MyAnno(value=12,per=Sex.MAN,anno=@person,name="wt")
  • 自定义注解 —— 在使用时属性赋值
  1. 1、定义属性默认值，使用关键字default，使用注解时，可以不用属性赋值
  2. 2、如果注解中只定义到一个属性，而且属性名为value，则value可以省略
  3. 3、属性的数据类型为数组时，值使用{}包裹，如果数组中只有一个值，则{}可以省略
  • 自定义注解 —— 元注解
  1. 元注解：用于描述注解的注解，JDK内置
  2.     @Target：描述注解作用的位置
  3.     @Retention: 描述注解被保留到哪个阶段
  4.     @Documented：描述注解是否被提取到api文档中
  5.     @Inherited：描述注解是否被子类继承
  • @Target
  1. ElementType取值：
  2. TYPE：可以作用于类上
  3. METHOD：可以作用于方法上
  4. FIELD：可以作用于成员属性上
  • @Retention
  1. SOURCE：编译检测
  2. CLASS：注解会保留到class字节码中，不被JVM读取
  3. RUNTIME：注解会保留到class字节码中，被JVM读取
  • 自定义注解 —— 解析
  1. //不使用注解
  2. //1、加载配置文件
  3. //创建Properties对象
  4. Properties pro = new Properties();
  5. //加载配置文件，转化为一个流
  6. //获取classes目录下的配置文件
  7. ClassLoader classLoader = Person.class.getClassLoader();
  8. InputStream is = classLoader.getResourceAsStream("pro.properties");
  9. pro.load(is);
  10.  
  11. //2、获取配置文件中数据
  12. String className = pro.getProperty("className");
  13. String methodName = pro.getProperty("methodName");
  1. //1、获取字节码文件对象
  2. Class<Person> p = Person.class;
  3. Pro an = p.getAnnotation(Pro.class);
  4. //2、获取配置文件中数据
  5. String className = an.className();
  6. String methodName = an.methodName();
  1. //使用注解
  2. Person p = new Person();
  3. //1、获取字节码文件对象
  4. Class cls = p.getClass();
  5. //2、获取所有方法
  6. Method[] methods = cls.getMethods();
  7. //3、判断方法上是否有注解
  8. for(Method method : methods){
  9.     if(method.isAnnotationPresent(Check.class)){
  10.         try{
  11.             mothed.invoke(p)
  12.         } catch(Exception e) {
  13.         
  14.         }
  15.     }
  16. }

泛型

是一种未知的数据类型，当我们定义时不知使用什么数据类型，就可以使用泛型
E e:Element 元素 (这只是语义化定义，你随便定义字母都可以，A/B/C/D...，除问号)
T t:Type 类型 (这只是语义化定义，你随便定义字母都可以，A/B/C/D...，除问号)
集合大量使用泛型
  • 作用
  1. 灵活地将数据类型应用到不同的类、方法、接口中去，将数据类型作为参数进行传递
  2.  
  3. 对于集合来说
  4. 1、无需再转数据类型
  5. 2、运行期的异常提前到编译期
  6. 3、集合存储数据类型受到限制
  • 定义
  1. // 定义一个含有泛型的类
  2. public class GenericClass<E> {
  3.     private E name;
  4.     
  5.     public E getName(){
  6.         return this.name;
  7.     }
  8.     
  9.     public void setName(E name){
  10.         this.name = name;
  11.     }
  12. }
  13.  
  14. // 定义一个含有泛型的方法
  15. public static <E> E test(E e){
  16.     return e;
  17. }
  18.  
  19. public <E> E test(E e){
  20.     return e;
  21. }
  22.  
  23. // 定义一个带有泛型的接口
  24. public interface GenericClass<E>{
  25.     public abstract void test(E e);
  26. }
  • 使用
使用时才确定数据类型，如果不指定，默认就是Object类型 
  1. // 含有泛型的类使用
  2. GenericClass<String> gc = new GenericClass<String>();
  3. String name = gc.getName();
  4.  
  5. // 含有泛型的方法使用（调用方法的时候才确定数据类型）
  6. GenericClass.test("123");
  7.  
  8. // 含有泛型的接口使用（有2种方法）
  9. 1、继承时确定类型
  10. public class GernericClassImpl implements GenericClass<String>{
  11.     public String test(String e){
  12.         return e;
  13.     }
  14. }
  15.  
  16. 2、创建对象时确定类型
  17. public class GernericClassImpl<E> implements GenericClass<E>{
  18.     public E test(E e){
  19.         return e;
  20.     }
  21. }
  22.  
  23. GernericClassImpl<String> gc = new GernericClassImpl<String>();
  • 通配符
通配符<?> (与<E>、<T>要区分) 
  1. 用途：
  2. 1、不能用于定义类、接口，不能用于创建对象
  3. 2、只能用于方法传参和方法返回值
  4. List<String> list1 = new ArrayList<String>();
  5. List<Boolean> list2 = new ArrayList<Boolean>();
  6.  
  7. public void test(List<?> list){
  8.      Iterator<?> it = list.iterator();
  9.      while(it.hasNext()){
  10.           Object ob = it.next();  // 由于传入的类型要调用方法才能确定所以获取的都是Object类型
  11.           System.out.println(ob);
  12.      }
  13. }
  14.  
  15. public List<?> test(){}
  1. 高级使用：
  2. 泛型的上限限定（子类及本身） ： <? extends Class>
  3. 泛型的下限限定（父类及本身） :  <? super String>

JUnit单元测试

测试分为 黑盒测试 和 白盒测试， JUnit 属于 白盒测试
  • 以前测试做法
  1. 创建2个类文件：
  2. 一个是业务类UserService
  3. 另一个是业务类对应的测试类UserServiceTest
  4.  
  5. 测试类UserServiceTest主要使用main方法进行测试，由于一个类中只存在一个main方法，所以如果你要测试多个方法，测试很繁琐
  • JUnit单元测试做法
  1. 步骤：
  2. 1、定义一个测试类（测试用例）
  3. 建议：
  4. 测试类包名（类的包名.test）
  5. 测试类名（类名+Test）
  6.  
  7. 2、定义一个测试方法
  8. 测试方法名（test+被测试的方法名，例如：testAdd）
  9. 测试方法返回值（void）
  10. 测试方法传参（空）
  11.  
  12. 3、给方法增加@Test
  13. 4、添加预言（建议不要使用打印控制台system.out.println）
  • 补充
  1. @Before : 修饰的方法会在测试方法之前会被自动执行，一般用于资源的申请
  2. @After : 修饰的方法会在测试方法之后会被自动执行，一般用于资源的释放

枚举

枚举 和 类、接口 同级，其实枚举也是一个类，只是该类的对象给限定了（定义在第一行）
枚举是 JDK1.5带来的新特性
  • 作用
让一个类的对象是有限且固定，例如性别:不是男就是女
  • 定义枚举
  1. public enum Sex{
  2.     MALE,FEMALE;
  3. }
  4.  
  5. public enum Sex {
  6.     MALE("男"),FEMALE("女");
  7.  
  8.     private final String name;
  9.     
  10.     private Sex(String name){
  11.         this.name = name;
  12.     }
  13.  
  14.     public String getName() {
  15.         return name;
  16.     }
  17. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/523412
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号