标签：通过 .class 效果 ast 快捷 java IV myeclipse 拆箱
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
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
1.2 使用泛型对象
创建泛型对象时，引用和new两端的泛型类型需要一致，例如上面的引用是List
标签：通过 .class 效果 ast 快捷 java IV myeclipse 拆箱
原文地址：https://www.cnblogs.com/csslcww/p/9175418.html
