W6-junit、泛型、枚举、增强for、可变参数、反射[JavaWeb]
1.单元测试Junit
1.1 测试对象是一个类中的方法
1.2 junit不是javase的部分，使用时需要导入jar包，myeclipse自带jar包
1.3 单元测试方法的时候，方法命名规则 public void 方法名(){}
1.4 使用注解方式运行，在方法的上面@Test
package cn.itcast.test02; import org.junit.Test; public class testDemo { //测试方法 @Test public void testAdd1(){ TestJunit test01=new TestJunit(); test01.testAdd(2, 3); } }
-当出现绿色条，表示测试通过；红棕色表示测试不通过。
-@Ignore：表示该方法不进行单元测试
-@Before：在每个方法之前运行
-@After：在每个方法之后运行
-断言（了解）：Assert.assertEquals("测试期望的值"，"方法运行的实际的值");
2.泛型
2.1 泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛型的java程序后，生成的class文件中将不再带有泛型信息。以此使程序运行效率不受到影响，这个过程称为“擦除”。
2.2 自定义泛型-泛型方法
方法逻辑相同，只是数据类型不同，使用泛型方法
package cn.itcast.test03; import java.util.Arrays; public class TestDemo03 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub //创建一个数组 实现11和13位置交换 Integer[] arr1={10,11,12,13,14}; swap1(arr1,1,3); System.out.println(Arrays.toString(arr1)); } /* * 使用泛型方法 需要定义一个类型 使用大写字母表示 T:这个T表示任意的类型 * 写在返回值之前 void 之前<T> * 表示定义了一个类型 这个类型是T */ public static <T> void swap1(T[]arr,int a,int b){ T temp=arr[a]; arr[a]=arr[b]; arr[b]=temp; } }
2.3 泛型在类上的使用：
package cn.itcast.test03; public class TestDemo04 <T>{ //在类里面可以直接使用T的类型 T aa; public void test11(T bb){ } //写一个静态方法 在类上面定义的泛型，不能在静态方法里面使用 public static <A> void test12(A cc){ } }
3.枚举
3.1 简介：需要在一定的范围内取值，这个值只能是这个范围内的任意一个
3.2 现实场景：交通信号灯，有三种颜色，每次只能亮三种颜色的任意一个
package cn.itcast.test04; public class TestEnum1 { private light color; public void test(){ this.color=light.GREEN; } } enum light{ RED,GREEN,YELLOW; }
3.3 枚举的构造方法是私有的
3.4 特殊枚举-在枚举的类里面有构造方法，抽象方法
package cn.itcast.test04; public class TestEnum2 { } enum Color11{ RED("red") { @Override public void print1() { // TODO Auto-generated method stub } }, GREEN("green") { @Override public void print1() { // TODO Auto-generated method stub } }, YELLOW("green") { @Override public void print1() { // TODO Auto-generated method stub } }; //带有参数的构造方法 private Color11(String name){} //在枚举里面写了抽象方法后，在每个实例里面都实现抽象方法 public abstract void print1(); }
3.5 枚举的api（查看api）
4. 增强for
4.1 for（遍历出来的值：要遍历的集合）{}
4.2 数组；实现Iterator接口（list和set），所以可以使用增强for循环
map不能使用增强for循环，因为它没有实现Iterator接口
4.3 出现的目的：为了替代迭代器
增强for的底层就是迭代器
5. 可变参数
5.1 可变参数的定义方法 数据类型...数组的名称
5.2 源代码
package cn.itcast.test04; public class TestDemo1 { public static void main(String[] args) { add1(11,22); } public static void add1(int...nums){ //nums理解为一个数组，这个数组存储传递过来的参数 // System.out.println(nums.length); int sum=0; //遍历数组 for(int i=0;i<nums.length;i++){ sum+=nums[i]; } System.out.println(sum); } }
5.3 注意
（1）可变参数需要写在方法的参数列表中，不能单独定义
（2）在方法的参数列表中只能有一个可变参数
（3）方法的参数裂变中的可变参数，必须放在最后
6 反射
6.1 应用在一些通用性比较高的代码中，后期所学的框架大多是使用反射来实现的
6.2 在框架开发中，都是基于配置文件开发。在配置文件中配置了类，可以通过反射得到类中的所有内容，可以让类中的某个方法执行
类中的所有内容：属性，所有参数的构造方法，有参数的构造方法，普通方法
package cn.itcast.test05; public class Person { //属性 private String name; private String id; //没有参数的构造方法 public Person(){} //有参数的构造方法 public Person(String name, String id) { super(); this.name = name; this.id = id; } //普通方法 public String getName() { return name; } public void setName(String name) { this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } }
6.3 第一步：保存Person.java;
第二步：编译 Person.class ;
第三步：JVM把class文件使用类加载器加载到内存中；
第四步：Class类，class字节码文件在内存中表示；
如果得到了Class类，可以得到这个类中的所有内容：属性，构造方法，普通方法；
-使用反射首先得到Class类：（1）类名.class （2）对象.getClass() （3）使用Class.forName（"路径"）
属性通过一个类 Field；构造方法通过一个类 Constructor；普通方法通过一个类 Method
6.4 使用反射来操作类里面的构造方法，属性，普通方法
package cn.itcast.test05; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import org.junit.Test; public class TestDemo1 { public static void main(String[] args)throws Exception { // TODO Auto-generated method stub //获取Class类 Class class1=Person.class; Class class2=new Person().getClass(); Class class3=Class.forName("cn.itcast.test05.Person"); } //使用泛型操作普通方法 @Test public void test4()throws Exception{ //得到Class Class c1=Class.forName("cn.itcast.test05.Person"); //得到普通方法 // c1.getDeclaredMethods();//得到所有的普通方法 Person p4=(Person) c1.newInstance(); Method m1=c1.getDeclaredMethod("setName", String.class); //如果操作的是私有方法，需要设置值是true // m1.setAccessible(true); //让setName方法执行，执行设置值 m1.invoke(p4, "youqi"); System.out.println(p4.getName()); } //操作属性 @Test public void test3(){ try{ //得到Class Class c2=Class.forName("cn.itcast.test05.Person"); //得到name属性 // c2.getDeclaredFields();//得到所有的属性 Person p11=(Person)c2.newInstance(); Field f1=c2.getDeclaredField("name"); //设置可以操作私有属性 f1.setAccessible(true); //设置name 的值 f1.set(p11, "wangwu");//相当于在 p.name="wangwu" System.out.println(f1.get(p11)); }catch(Exception e){ e.printStackTrace(); } } //需求：要对一个诶进行实例化，可以new，若不使用new应该怎么获取？ //操作有参数的构造方法 @Test public void test2()throws Exception{ //得到Class Class class3=Class.forName("cn.itcast.test05.Person"); //使用有参数的构造方法 // class3.getConstructors();//获取所有的构造方法 //传递的是有参数的构造方法里面的参数类型，类型使用class形式传递 Constructor cs=class3.getConstructor(String.class,String.class); //通过有参数的构造方法设置值 //通过有参数的构造方法设置Person实例 Person p1=(Person)cs.newInstance("lisi","100"); System.out.println(p1.getId()+"..."+p1.getName()); } //操作无参数的构造方法 @Test public void test1()throws Exception{ //得到Class Class class3=Class.forName("cn.itcast.test05.Person"); //得到Person类的实例 Person p=(Person)class3.newInstance(); //设置值 p.setName("Zhangsan"); System.out.println(p.getName()); } }
6.5 当操作的方法是静态方法时，因为静态方法的调用方式是 类名.方法名，不需要类的实例；使用反射操作静态方法时候，也不要写实例
m1.invoke(null, "youqi");//直接写null
