junit单元测试的基本使用:
 1.在要执行的方法上添加一个注解@test
 2.注解会报错 解决方式ctrl+1 add junit
 3.选中要执行的方法 右键 run as --> junit test
一次执行多个方法:选中类 右键run as --> junit test
junit单元测试的注意事项:
 1.没有添加@test注解的方法不能使用junit运行
 2.junit只能运行修饰符为public 返回值类型为void 的空参数方法
和单元测试有关的注解
@test:单元测试,可以单独的执行某个方法
 @before:在单元测试@test之前执行 可以用来获取一些资源
 @after:在单元测试@test之后执行 可以用来使用一些资源
 注意:@before和@after不能单独执行 运行@test他们会自动执行
jdk1.5之后提供的注解
 @deprecated:表示已经过时的
 @deprecated:可以用来修饰类 表示已经过时的类,也可以用来修饰方法 表示已经过时的方法
 已经过时的类和方法 可以使用 但是不建议 因为可能存在缺陷 或者被更好的方法取代了
jdk1.5之后提供的注解
 @override:用来测试方法是否为重写的方法
 jdk1.5时 @override只能检测类继承类重写的方法
 jdk1.6及以上,@override即能检测类继承类重写的方法 又能检测类实现接口重写的方法
jdk1.5之后提供的注解
 @suppresswarnings:表示抑制警告(不让警告显示出来)
 @suppresswarnings:使用时必须明确要抑制的是哪个警告
 @suppresswarnings(参数):参数是一个字符串数组
 如果只写一个参数 可以忽略{} 如果有多个参数必须使用{}多个参数之间使用逗号隔开
 string[]  a = {ac,ds}
 可以抑制的警告有:
 rawtypes, 忽略类型安全
 unchecked 忽略安全检查
 unused 忽略不使用
 deprecation 忽略过时
 null 忽略空指针
 serial 忽略序列号
 all 忽略所有
 注解 的作用域:可以定义在类上 方法上 代码上
 同一个位置只能使用一次同一个注解
自定义注解:使用关键字@interface
 定义类:class
 定义接口:interface
 定义枚举:enum(淘汰)
 定义注解:@interface
 定义注解的格式:
 修饰符 @interface 注解名{
   注解的属性;(可以有 可以没有)
 定义含有属性的注解:
 属性相当于类中的成员变量 成员方法
 属性的定义格式:
 修饰符 返回值类型(数据类型) 属性名()[default 属性值]
  修饰符:固定的格式(类似接口) public abstract  写不写都是 建议写出 增强阅读行
  返回值类型:基本数据类型(4类8种)string 类型 class类型 枚举 注解 以上类型的一维数组
  [default 属性值]:[]可选的 属性可以给出默认值 也可以不给默认值
   int a; int a = 10;
 1 public @interface myannotation02 { 2     //基本数据类型(4类8种) 3     public abstract int a() default 10; 4     //string类型 5     public abstract string s(); 6     //class类型 7     public abstract class clazz(); 8     //枚举 9     public abstract color c();10     //注解11     public abstract myannotation01 myanno01();12     //以上类型的一维数组13     public abstract string[] arr();14 }15 16 enum color{17     green,18     red19     /*20      * public static final color green = new color();21      * public static final color red = new color();22      */23 }
定义一个含有属性的注解
 这个注解只有一个属性 属性的名字叫value
元注解:用来修饰自定义注解的jdk提供的注解
 @retention  用于确定被修饰的自定义注解声明周期
 retention 注解的属性是一个枚举retentionpolicy(枚举有3个属性source,class,runtime)
 作用:指示注释类型的注释要保留多久
   如果注释类型声明中不存在retention注释 则保留策略默认为retentionpolicy.class
   retentionpolicy.source 被修饰的注解只能存在源码中，字节码class没有。用途：提供给编译器使用。
retentionpolicy.class 被修饰的注解只能存在源码和字节码中，运行时内存中没有。用途：jvm java虚拟机使用
retentionpolicy.runtime 被修饰的注解存在源码、字节码、内存（运行时）。用途：取代xml配置
@target 用于确定被修饰的自定义注解使用位置
target注解的属性是一个枚举elementtype(常用的属性type,constructor....)
作用:指示注释类型所适用的程序元素的种类。
如果注释类型声明中不存在 target 元注释，则声明的类型可以用在任一程序元素上。
elementtype.type 修饰类、接口
elementtype.constructor  修饰构造
elementtype.method 修饰方法
elementtype.field 修饰字段
1 @retention(retentionpolicy.runtime)2 @target({elementtype.constructor,elementtype.field,elementtype.method,elementtype.type})3 public @interface myannotation03 {4     public abstract int value();5 }
使用自定义注解:
 格式:@自定义注解的名字(属性名= 属性值 ,属性名=属性值)
 注意:
 1.自定义注解没有属性,可以直接使用-->@自定义注解的名字
 2.自定义注解有属性 使用的时候 必须使用键值对的方式 给所有属性赋值 才能使用 有默认值的属性可以不用赋值
 3.如果注释的属性是一个数组 赋值的时候只有一个值可以省略{} 赋值多个必须写出{}
 4.注解的使用范围  可以用来修饰类 方法 构造方法 变量
 5.使用自定义注解 如果只有一个属性 名字叫value 赋值的时候value可以省略不写
 6.一个对象上(修饰类, 方法,构造方法,变量)注解只能使用一次 不能重复使用
自定义注解的解析:使用自定义注解 获取自定义注解的属性值
 和解析有关的接口:
 java.lang.reflect.annotatedelement接口
 所有已知实现类:accessibleobject class constructor field method package
 接口中的方法:
  boolean isannotationpresent(class annotationclass)
  如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。
  判断(constructor, field, method...)有没有指定的注解
  参数:注解的class文件对象,可以传递myannotation03.class(string.class,int.class)
  t getannotation(class<t> annotationclass)
  如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
  获取(constructor, field, method...)上的注解,参数传递的是哪个注解的class文件对象,就获取哪个注解
  参数:注解的class文件对象,可以传递myannotation03.class
使用步骤:
  1.定义一个方法,使用自定义注解
  2.使用反射技术获取本类的class文件对象
  3.使用反射技术获取类中所有的方法
  4.遍历包含所有方法的数组,获取每一个方法
  5.使用isannotationpresent判断该方法上是否包含传递参数的注解
  6.如果方法上包含注解,使用getannotation获取方法上的注解
  7.使用属性的名字,获取属性值
 1 public class usemyannotation02 { 2     //1.定义一个方法,使用自定义注解 3     @myannotation03(value=10) 4     public void method(){ 5          6     } 7      8     @test 9     public void test(){10         //2.使用反射技术获取本类的class文件对象11         class clazz = usemyannotation02.class;12         //3.使用反射技术获取类中所有的方法13         method[] methods = clazz.getmethods();14         //4.遍历包含所有方法的数组,获取每一个方法15         for (method method : methods) {16             string methodname = method.getname();17             //5.使用isannotationpresent判断该方法上是否包含传递参数的注解18             boolean b = method.isannotationpresent(myannotation03.class);19             if(b){20                 system.out.println(methodname+:+b);21                 //6.如果方法上包含注解,使用getannotation获取方法上的注解22                 myannotation03 myanno = method.getannotation(myannotation03.class);23                 //7.使用属性的名字,获取属性值24                 int v = myanno.value();25                 system.out.println(v);26             }27         }28     }29 }
类加载器:把class文件加载到内存中 并生成一个class文件对象
加载器的组成:
bootstrap classloader 引导(根)类加载器
 也被称为引导类加载器 负责java核心类的加载
 extension classloader 扩展类加载器
 负责人jre的扩展目录中的jar包的加载
 在jdk中jre的lib目录下井ext目录
 appclassloader 应用类加载器
  负责在jvm启动时加载来自java命令的class文件 以及classpath环境变量
  所指定的jar包和类路径
  自定义的类型person; commons-io-2.4.jar
类加载器的继承关系:
appclassloader extends extclassloader extends bootstrap classloader extends classloader
和类加载器有关的方法:
class类中的方法:
classloader getclassloader() 返回该类的类加载器。
classloader类中的方法:
classloader getparent() 返回委托的父类加载器。
 1 public class democlassloader { 2     @test 3     public void show01(){ 4         //获取应用类加载器 5         classloader loader = democlassloader.class.getclassloader(); 6         system.out.println(loader);//sun.misc.launcher$appclassloader@5fcf29 7          8         loader = loader.getparent(); 9         system.out.println(loader);//sun.misc.launcher$extclassloader@5fcf2910         11         loader = loader.getparent();12         system.out.println(loader);//根类加载器由c/c++编写,没有相关的类描述,返回null13     }14     15     @test16     public void app(){17         //获取应用类加载器18         classloader loader = democlassloader.class.getclassloader();19         system.out.println(loader);//sun.misc.launcher$appclassloader@5fcf2920     }21     22     @test23     public void ext(){24         //获取扩展类加载器25         /*26          * 扩展包中的类,不支持使用27          * 想使用必须设置访问权限28          * sun/**29          */30         classloader loader = sunec.class.getclassloader();31         system.out.println(loader);//sun.misc.launcher$extclassloader@19b1de32     }33     34     @test35     public void boot(){36         classloader loader = string.class.getclassloader();37         system.out.println(loader);//null38     }39 }
jdk动态代理:只能代理接口
 java.util.collections集合的工具类
 collections集合的工具类的静态方法
 static <t> list<t> unmodifiablelist(list<? extends t> list)
 返回指定列表的不可修改视图
 传递一个list集合返回一个被代理的list集合
 unmodifiablelist方法就是一个代理方法,代理list集合
 如果调用size get方法 没有对集合进行修改 则允许执行
 如果调用add remove set 对集合进行了修改,则抛出异常不让方法执行
  会抛出unsupportedoperationexception:不支持操作异常
 1 public class demo01proxy { 2     @test 3     public void show(){ 4         list<string> list = new arraylist<string>(); 5         list.add(a); 6         list.add(b); 7          8         //调用collections中的方法unmodifiablelist 9         list = collections.unmodifiablelist(list);10         string s = list.get(0);11         system.out.println(s);12         13         system.out.println(list.size());14         15         //list.add(c);16         //list.remove(0);17     }18 }
创建接口invocationhandler的实现类
 重写接口中的方法invoke 对集合的方法进行判断
 如果调用size get方法 没有对集合进行修改 则允许执行
 如果调用add remove set 对集合进行了修改 则抛出异常不让方法执行
 object invoke(object proxy,method method,object[] args)在代理实例上处理方法调用并返回结果
 参数:
  object proxy:内部会使用反射创建一个代理人对象,和我们无关
method method:内部会使用反射获取到执行list集合的方法(size,get,....)
  object[] args:内部会使用反射获取到调用集合方法的参数
  返回值:
  object:调用list集合的方法的返回值
注意事项:
  代理的是list集合,必须把被代理的集合传递到实现类中,为了保证代理的始终是同一个list集合
  在成员位置创建一个list集合
  使用带参数构造给集合赋值
 1 public class invocationhandlerimpl implements invocationhandler{ 2     private list<string> list;     public invocationhandlerimpl(list<string> list) { 5           this.list = list; 6     } 7  8     @override 9       public object invoke(object proxy, method method, object[] args) throws throwable {10           //获取方法的名字11         string mehtodname = method.getname();12           //对方法的名字进行判断,如果是add,remove,set就抛出异常13           if(add.equals(mehtodname)){14             throw new unsupportedoperationexception(add no run);15         }     if(remove.equals(mehtodname)){18             throw new unsupportedoperationexception(remove no run);19         }       if(set.equals(mehtodname)){22             throw new unsupportedoperationexception(set no run);23         }          //如果是size,get执行方法25         object obj = method.invoke(list, args);26         return obj;27     }  }
1 /* 2  * 动态代理综合案例: 3  * 需求: 4  *     模拟collections.unmodifiablelist(list); 5  *         传递list,返回list 6  *         调用list方法的时候,通过我的代理类中的方法 invoke, 7  *         如果调用size,get方法,没有对集合进行修改,则允许执行 8  *         如果调用add,remove,set,对集合进行了修改,则抛出异常不让方法执行 9  *             会抛出unsupportedoperationexception:不支持操作异常10  * 实现步骤:11  *     1.模拟unmodifiablelist方法,定义一个代理的方法proxylist,参数传递list集合,返回被代理后的list集合12  *     2.在proxylist方法内部实现动态代理13  *         java.lang.reflect.proxy:提供了和动态代理有关的方法14  *         static object newproxyinstance(classloader loader, class<?>[] interfaces, invocationhandler h)  15  *             返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。  16  *         参数:17  *             classloader loader:传递类加载器,加载类到内存中,创建class文件对象;可以传递本类的类加载器18  *             class<?>[] interfaces:传递arraylist实现的接口list/collection的class文件对象19  *             invocationhandler h:创建一个invocationhandler的实现类,重写接口中的方法invoke,对集合的方法进行判断20  *                 如果调用size,get方法,没有对集合进行修改,则允许执行21  *                 如果调用add,remove,set,对集合进行了修改,则抛出异常不让方法执行22  *         返回值类型:23  *             object:返回被代理后的list集合24   */25 @suppresswarnings(all)26 public class demo02proxy {27     /*28      * 1.模拟unmodifiablelist方法,定义一个代理的方法proxylist,参数传递list集合,返回被代理后的list集合29      */30     public static list<string> proxylist(list<string> list){31         //2.在proxylist方法内部实现动态代理,调用proxy类中的方法newproxyinstance32         list<string> proxylist = (list<string>) proxy.newproxyinstance(demo02proxy.class.getclassloader(),33                 list.getclass().getinterfaces(), new invocationhandlerimpl(list));34         return proxylist;35     }    /*      * 1.模拟unmodifiablelist方法,定义一个代理的方法proxylist,参数传递list集合,返回被代理后的list集合39      */40     public static list<string> proxylist02(final list<string> list){41         //2.在proxylist方法内部实现动态代理,调用proxy类中的方法newproxyinstance42         list<string> proxylist = (list<string>) proxy.newproxyinstance(demo02proxy.class.getclassloader(),43                 list.getclass().getinterfaces(), new invocationhandler() {44                     @override45                     public object invoke(object proxy, method method, object[] args) throws throwable {46                          //获取方法的名字47                          string mehtodname = method.getname();48                         //对方法的名字进行判断,如果是add,remove,set就抛出异常49                         if(add.equals(mehtodname)){50                             throw new unsupportedoperationexception(add no run);51                         }52                         53                         if(remove.equals(mehtodname)){54                             throw new unsupportedoperationexception(remove no run);55                          }    if(set.equals(mehtodname)){58                             throw new unsupportedoperationexception(set no run);59                         }60                         //如果是size,get执行方法61                         object obj = method.invoke(list, args);62                         return obj;63                     }64                 });65         return proxylist;66     }67     68     @test69     public void test(){70         list<string> list = new arraylist<string>();71         list.add(a);72         list.add(b);73         //调用代理方法proxylist传递list集合74          //list = collections.unmodifiablelist(list);75          list = demo02proxy.proxylist(list);76         system.out.println(list.size());77         system.out.println(list.get(0));78         //list.add(c);//unsupportedoperationexception:add no run79         //list.remove(0);//unsupportedoperationexception:remove no run80         list.set(0, c);//unsupportedoperationexception:set no run81     }82 }
以上就是junit单元测试的基本使用与注意事项的详细内容。