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);
}
}
-当出现绿色条，表示测试通过；红棕色表示测试不通过。
[email protected]：表示该方法不进行单元测试
[email protected]：在每个方法之前运行
[email protected]：在每个方法之后运行
-断言（了解）：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
原文地址：https://www.cnblogs.com/ERFishing/p/11325414.html