1，junit的使用
单元测试
测试的对象是类中的一个方法
Junit不是javase的一部分，想要使用导入jar包
但是，在MyEclipse中自带了Junit的jar包
单元测试方法时候，方法命名规则 public void 方法名（）{ }
@test
public void testAdd1(){
TestJunit test01 = new TestJunit();
test01.testAdd(2, 3);
}
@Ignore:表示这个方法不进行单元测试；
@Before:在每个方法之前运行；
@After:在每个方法之后运行；
JDK新特性
泛型，枚举，静态导入，自动拆装箱，for语句，可变参数
5,泛型的简介（****）
在集合上如何使用泛型
常用集合list set map
泛型语句 集合<String>,比如List<String>
在泛型里面写是一个对象，String不能写基本的数据类型，比如int
写基本的数据类型对应的包装类
byte--Byte
short--Short
int--Integer
long--Long
float--Float
double--Double
char--Character
boolean--Boolean
泛型的擦出：泛型只出现源代码阶段，当编译之后就不存在；
遍历集合list有三种
普通for循环，使用增强for，使用迭代器遍历
@Test
public void testList(){
List<String> list = new ArrayList();
list.add("aaaa");
list.add("bbbb");
list.add("ccccc");
//普通for循环
for(int i=0;i<list.size();i++){
String s = list.get(i);
System.out.println(s);
}
System.out.println("========");
//使用增强for
for (String s1: list) {
System.out.println(s1);
}
System.out.println("========");
//使用迭代器遍历
Iterator<String> it= list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
在set集合上使用泛型
@Test
public void testSet(){
Set<String> set = new HashSet<String>();
set.add("www");
set.add("qqq");
set.add("mmm");
//使用增强for循环
for(String s2:set){
System.out.println(s2);
}
System.out.println("========");
//使用迭代器遍历
Iterator<String> it1 = set.iterator();
while(it1.hasNext()){
System.out.println(it1.next());
}
在map上使用泛型
@Test
public void testMap(){
Map<String,String> map = new HashMap();
map.put("aaa","111");
map.put("bbb","2222");
map.put("ccccc","333");
//获取所有的key，通过key得value,使用get方法
Set<String> sets = map.keySet();
for(String key : sets){
String value = map.get(key);
System.out.println(key+":"+value);
}
System.out.println("========");
//得到key和value的关系 Set<Entry<String,String>> sets1 = map.entrySet();
for(Entry<String,String> entry:sets1){
//entry得到key和value的关系
String keyv = entry.getKey();
String valuev = entry.getValue();
System.out.println(keyv+":"+valuev);
}
}
6，泛型使用在方法上
使用泛型方法，需要定义一个类型，使用大写字母T，这个T表示任意的类型
写在返回值之前，void之前<T>
public static <T>void swap1(T[ ] arr,int a,int b){
T temp = arr [a];
arr [a] = arr [b];
arr [b] = temp;
7,泛型在类上的使用
在类里面可以直接使用T的类型
写一个静态方法，在类上面定义的泛型，不能再静态方法里面使用，需自己定义
8，枚举的简介
现实场景：交通信号灯
使用一个关键字enum;
枚举的构造方法也是私有的
创建枚举的格式;
enum 枚举类型名称{
枚举对象1名称；
枚举对象2名称；
枚举对象3名称；
枚举对象n名称；
}
enum Color3{
RED,GRENN,YELLOW;
}
特殊枚举的操作
在枚举里面有构造方法
构造方法里面有参数，需要在每个实例上面都写参数
在美剧里面有抽象方法
在枚举的每个实例里面都重写这个抽象方法
9.枚举的api的操作
name():返回枚举的名称；
ordinal（）：返回枚举的下标；
valueOf(Class<T> enumType, String name):得到枚举对象
知道枚举的对象，得到枚举的对象和下标
@Test
public void test1(){
//得到枚举对象
Color100 c100 = Color100.red;
//枚举名称
String name = c100.name();
//枚举下标
int idx = c100.ordinal();
System.out.println(name+""+idx);
}
知道枚举的名称，得到枚举的对象和下标
@Test
public void test2(){
String name1 = "GRENN";
//得到对象
Color100 c1 = Color100.valueOf(name1);
//枚举下标
int idx1 = c1.ordinal();
System.out.println(idx1);
}
知道枚举的下标，得到枚举的对象和名称
@Test
public void test3(){
int idx2 = 2;
//得到枚举的对象
Color100[] cs = Color100.values();
//根据下标得到对象
Color100 c12 = cs[idx2];
//得到枚举的名称
String name = c12.name();
System.out.println(name);
}
10,静态导入
import static XX.XX.xxx;
import static java.lang.System.out;
11.自动拆装箱（****）
装箱：把基本的数据类型转换成包装类
拆箱：把包装类转换成基本的数据类型
自动装箱：
Integer i = 10;
自动拆箱：
int m = i;
int--Integer
char = Character
jdk向下兼容·
12,增强for循环（*****）
目的：替代迭代器
语句：
for（遍历出来的值：要遍历的集合）{}
在集合上实现增强for循环遍历
使用场景：数组 ，list set 实现了Integer接口，所以可使用增强for循环
for(String s : list){
System.out.println(s);
}
// TODO Auto-generated method stub
Integer [] arr1 = {10,23,4,5,67};
reverses(arr1);
System.out.println(Arrays.toString(arr1));
System.out.println("=============");
String [] arr2 = {"aa","cc","dd","gg"};
reverses(arr2);
System.out.println(Arrays.toString(arr2));
}
private static <T> void reverses(T[] arr1) {
// TODO Auto-generated method stub
//遍历数组
for(int i=0;i<arr1.length/2;i++){
T temp = arr1[i];
arr1[i] = arr1[arr1.length-i-1];
arr1[arr1.length-i-1] = temp;
}
}
14，可变数组
实现两个数，三个数，四个数，的相加
可变参数的定义方法
数据类型...数组的名称
理解为一个数组，这个数组传递过来的参数
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);
}
注意：
可变参数需写在方法的参数列表中，不能单独定义
在方法的参数列表中只能定义一个可变参数
方法的参数列表中的可变参数，必须放在参数最后
add(int a, int...nums)
15，反射的原理（*****）
应用在一些通用性比较高的代码中
框架大多数都是使用反射来实现的
类中的所有内容：属性，有参数的构造方法，无参的构造方法，普通方法；
当使用反射时候，首先需获取到class类，得到这个类之后，就可以得到class文件里面的所有内容
包含：属性，构造方法，普通方法
16，使用反射操作类里面的属性
//得到class类
Class clazz1 = Person.calss;
Class clazz2 = new Person().getclass();
Class clazz3 = Class.forName("cn.itcast.test01.Person");
//操作无参的构造方法
@Test
public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
//得到class
Class c3 = Class.forName("cn.itcast.test01.Person");
//得到person的实例
Person p = (Person) c3.newInstance();
//设置值
p.setName("zhanagsan");
System.out.println(p.getName());
}
