day01-java重点复习

day01
MyEclipse介绍

1　debug断点调试
 设置断点；
 测试跳入（F5）；
 测试跳过（F6）；
 测试跳出（F7）；
 添加断点；
 测试进入下一断点；
 测试返回当前方法栈的头部（Drop To Frame）；
 清除断点；
 清除表达式；
注意，中止程序！

2　经常使用快捷键
　　必须的：
 Alt + /（内容助理）：补全；
 Ctrl + 1（快速定位）：出错时定位错误，与点击“红X”效果同样；
 Ctrl + Shift + O：导包；
 Ctrl + Shift + F：格式化代码块；

不是必须的（本身读，不讲）：
 Ctrl + Shift + T：查看源代码；
 Ctrl + 点击源代码：查看源代码；
 F3：查看选中类的源代码；
 Alt + 左键：查看源代码时的“原路返回”；
 Ctrl + Shift + X：把小写修改成大写；
 Ctrl + Shift + Y：把小写修改成小写；
 Ctrl + Alt + 下键：复制当前行；
 Ctrl + /：添加或撤销行注释；
 Ctrl + Shift + /：对选中代码添加段注释；
 Ctrl + Shift + ：撤销当前段注释；
 Alt + 上键：向上移动当前行；
 Alt + 下键：向上移动当前行；
 Ctrl + D：删除当前行；

JUnit
1　JUnit的概述
当咱们写完了一个类后，老是要执行一下类中的方法，查看是否符合咱们的意图，这就是单元测试了。而Junit就是单元测试工具。
 导包：导入Junit4或以上版本；
 编写一个类：Person，它就是要被测试的类；
 编写测试类：PersonTest，给出测试方法，在测试方法上使用@Test注解；
 执行测试方法。

Person
package cn.itcast;

public class Person {
public void run() {
System.out.println("run");
}
public void eat() {
System.out.println("eat");
}
}

包资源管理器选中Person类右键newJUnit TestCase修改包名为junit.test下一步选中要测试的方法。

PersonTest
package junit.test;

import org.junit.Test;
import cn.itcast.Person;

public class PersonTest {
@Test
public void testRun () {
Person person = new Person();
person.run();
}
@Test
public void testEat () {
Person person = new Person();
person.eat();
}
}

选中某个测试方法，鼠标右键Run asJunit Test，即执行测试方法。
@Test注解的做用是指定方法为测试方法，测试方法必须是public、void、无参的！！！

2　@Before和@After(了解)
若是你须要某个方法在每一个测试方法以前先执行，那么你须要写一个方法，而后使用@Before来标记这个方法。例如在testRun()和testEat()方法以前须要建立一个Person对象。
PersonTest
package junit.test;

import org.junit.Before;
import org.junit.Test;
import cn.itcast.Person;

public class PersonTest {
private Person person;
@Before
public void setUp () {
person = new Person();
}
@Test
public void testRun() {
person.run();
}
@Test
public void testEat() {
person.eat();
}
}

@After注解标记的方法会在每一个执行方法以后执行
@Before和@After标记的方法必须是public、void、无参。

JDK5.0新特性

1 自动拆装箱
自动拆装箱是JDK5.0的新特性之一，这一特性可使基本类型，与之对应的包装器类型之间直接转换，例如int的包装器类型是Integer！在JDK5.0以后，你甚至能够把int看成成Integer来使用，把Integer当成int来使用。固然，这不是100%的！
1.1　自动拆装箱概述
在JDK5.0以后，Java容许把基本类型与其对应的包装器类型之间自动相互转换。
 自动装箱：Integer i = 100，把int类型直接赋值给Integer类型；
 自动拆装：int a = new Integer(100)，把Integer类型直接赋值给int类型。

1.2　自动拆装箱原理
其实自动拆装箱是由编译器完成的！咱们写的代码，再由编译器“二次加工”，而后再编译成.class文件！那么编译器是怎么“二次加工”的呢？
 Integer i = 100：编译器加工为：Integer i = Integer.valueOf(100)；
 int a = i：编译器加载为：int a = i.intValue()；
这也说明一个道理：JVM并不知道什么是自动拆装箱，JVM仍是原来的JVM（JDK1.4以前），只是编译器在JDK5.0时“强大”了！

1.3　自动拆装箱演变
你们来看看下面代码：
Integer i = 100;//这是自动装箱
Object o = i;//这是身上转型

上面代码是没有问题的，咱们是否能够修改上面代码为：
Object o = 100;

ok，这是能够的！经过编译器的处理后上面代码为：
Object o = Integer.valueOf(100);

在来看下面代码：
Object o = Integer.valueOf(100);
int a = o;//编译失败！

上面代码是不行的，由于o不是Integer类型，不能自动拆箱，你须要先把o转换成Integer类型后，才能赋值给int类型。
Object o = Integer.valueOf(100);
int a = (Integer)o;

1.4　变态小题目
来看下面代码：
Integer i1 = 100;
Integer i2 = 100;
boolean b1 = i1 == i2;//结果为true

Integer i3 = 200;
Integer i4 = 200;
boolean b2 = i3 == i4;//结果为false

你可能对上面代码的结果感到费解，那么咱们来打开这个疑团。第一步，咱们先把上面代码经过编译器的“二次加工”处理一下：
Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf(100);
boolean b1 = i1 == i2;//结果为true

Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf(200);
boolean b2 = i3 == i4;//结果为false

这时你应该能够看到，疑团在Integer.valueOf()方法身上。传递给这个方法100时，它返回的Integer对象是同一个对象，而传递给这个方法200时，返回的倒是不一样的对象。这是咱们须要打开Integer的源码（这里就不粘贴Integer的源代码了），查看它的valueOf()方法内容。
Integer类的内部缓存了-128~127之间的256个Integer对象，若是valueOf()方法须要把这个范围以内的整数转换成Integer对象时，valueOf()方法不会去new对象，而是从缓存中直接获取，这就会致使valueOf(100)两次，都是从缓存中获取的同一个Integer对象！若是valueOf()方法收到的参数不在缓存范围以内，那么valueOf()方法会new一个新对象！这就是为何Integer.valueOf(200)两次返回的对象不一样的缘由了。

2　可变参数
可变参数就是一个方法能够接收任意多个参数！例如：fun()、fun(1)、fun(1,1)、fun(1,1,1)。你可能认为这是方法重载，但这不是重载，你想一想重载能重载多少个方法，而fun()方法是能够传递任何个数的参数，你能重载这么多个方法么？

2.1　定义可变参数方法
public void fun(int… arr) {}
上面方法fun()的参数类型为int…，其中“…”不是省略号，而是定义参数类型的方式。参数arr就是可变参数类型。你能够把上面代码理解为：public void fun(int[] arr)。
public int sum1(int[] arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
public int sum2(int... arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}

你可能会想，“int[]”和“int…”没有什么不一样，只是“int…”是一种新的定义数组形参的方式罢了。那么我应该恭喜你了！没错，这么理解就对了！但要注意，只有在方法的形参中可使用int…来代替int[]。

2.2　调用带有可变参数的方法
sum1()和sum2()两个方法的调用：
sum1(new int[]{1,2,3});
sum2(new int[]{1,2,3});

这看起来没什么区别！可是对于sum2还有另外一种调用方式：
sum2();
sum2(1);
sum2(1,2);
sum2(1,2,3);

　　这看起来好像是使用任意多个参数来调用sum2()方法，这就是调用带有可变参数方法的好处了。

2.3　编译器“二次加工”
编译器对sum2方法定义的“二次加工”结果为：
public int sum2(int[] arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}

即把“int…”修改成“int[]”类型。
编译器对sum2方法调用的二次加载结果为：
sum2(new int[0]);
sum2(new int[] {1});
sum2(new int[] {1, 2});
sum2(new int[] {1, 2, 3});

结论：可变参数其实就是数组类型，只不过在调用方法时方便一些，由编译器帮咱们把多个实参放到一个数组中传递给形参。

2.4　可变参数方法的限制
 一个方法最多只能有一个可变参数；
 可变参数必须是方法的最后一个参数。

3　加强for循环
加强for循环是for的一种新用法！用来循环遍历数组和集合。

3.1　加强for的语法
for(元素类型 e : 数组或集合对象) {
}
例如：
int[] arr = {1,2,3};
for(int i : arr) {
System.out.println(i);
}
　　加强for的冒号左边是定义变量，右边必须是数组或集合类型。例如上例中循环遍历的主浊arr这个int数组，加强for内部会依次把arr中的元素赋给变量i。

3.2　加强for的优缺点
 只能从头至尾的遍历数组或集合，而不能只遍历部分；
 在遍历List或数组时，不能获取当前元素下标；
 加强for使用便简单，这是它惟一的优势了；
 加强for比使用迭代器方便一点！

3.3　加强for原理
其实加强for内部是使用迭代器完成的！也就是说，任何实现了Iterable接口的对象均可以被加强for循环遍历！这也是为何加强for能够循环遍历集合的缘由（Collection是Iterable的子接口）。
但要注意，Map并无实现Iterable接口，因此你不能直接使用加强for来遍历它！
Map<String, String> map = new HashMap<String,String>();
map.put("1", "one");
map.put("2", "two");
map.put("3", "three");

for(String key : map.keySet() ) {
        String value = map.get(key);
        System.out.println(key + "=" + value);
    }

泛型

1　泛型概述
泛型是JDK5.0新特性，它主要应用在集合类上。有了泛型以后，集合类与数组就愈来愈像了。例如：Object[] objs = new Object[10]，能够用来存储任何类型的对象。String[] strs = new String[10]只能用来存储String类型的对象。
ArrayList list = new ArrayList()，能够用来存储任何类型的对象。ArrayList list = new ArrayList ()只有用来存储String类型的对象。
1.1　理解泛型类
泛型类具备一到多个泛型变量，在建立泛型类对象时，须要为泛型变量指定值。泛型变量只能赋值为引用类型，而不能是基本类型。例如ArrayList类中有一个泛型变量E，在建立ArrayList类的对象时须要为E这个泛型变量指定值。
list list = new ArrayList ();，
其中String就是给List的泛型变量E赋值了。查阅ArrayList的API你会知道，泛型变量E出如今不少方法中：
boolean add(E e)
E get(int index)
由于咱们在建立list对象时给泛型类型赋值为String，因此对于list对象而言，全部API中的E都会被String替换。
boolean add(String e)
String get(int index)
也就是说，在使用list.add()时，只能传递String类型的参数，而list.get()方法返回的必定是String类型。
list.add(“hello”);
String s = list.get(0);

1.2　使用泛型对象
建立泛型对象时，引用和new两端的泛型类型须要一致，例如上面的引用是List ，而new一端是new ArrayList ，两端都是String类型！若是不一致就会出错：
List