Lesson 1

一、eclipse工具的使用

1. java代码的位置

1) 选择工作空间 workspace 选择一个文件夹存放程序(代码) 不要用中文和空格

2) 新建一个java 工程(Project)

3) 建包建类

2. 快捷键

alt + / ：代码自动补齐，需要配置的

打开preferences(首选项), 搜keys，打开快捷键配置面板

搜 alt+/ ，取消绑定

搜 content assist ，取消原先的绑定，配置成alt+/

ctrl+1: 错误自动修复，注意，放行的红叉是可修复的，圆形的是不可修复的

导包的三种方式：

1）将类名敲完整，按下alt+/ 进行补齐，会自动导包

2) ctrl+1,修正错误

3) ctrl+shift+o 整理包，导入需要的包，去掉多余的导包语句

ctrl+shift+f : 代码格式化

ctrl+2,L 自动声明变量

shift+enter 光标直接进入下一行

ctrl+alt+方向键(向上向下) 复制行

alt+ 方向键(向上向下) 移动当前行

3. 断点调试

1) 可以对程序进行调试

在行的开头双击左键打断点，用debug方式来运行程序，程序就会停留在断点位置

F5 跳入(step into) 跳入方法内部 F6 跳过，让当前行运行 F7跳出返回上一层程序

resume 直接运行到下一个断点

2) 查看源代码建议使用断点调试的方式，注意当前运行环境需要包含源码

4. junit单元测试

1) 写一个java类，声明测试方式

修饰符为 public void ,

在方法前面加注解，(@Test)

此方法就可以进行测试了(交给junit运行)

2) 需要在测试方法前做初始化工作

写一个静态方法 public static void init()

在方法前加注解 @BeforeClass

3) 需要在测试后释放资源

写一个静态方法

在方法前加注解 @AfterClass

二、jdk5新特性

1. 静态导入

1) 导入类的静态属性

import static java.lang.System.out;

out.println("haha");

2) 导入类的静态方法

import static java.lang.Math.*; // 导入Math类的所有静态成员

int num = abs(-10);

2. 增强for循环

1) 作用：对存储对象的容器进行迭代

2) jdk5以前怎么迭代

3) 增强for循环迭代数组

String [] arr = {"a", "b", "c"}; //数组的静态定义方式，只试用于数组首次定义的时候

// 传统方式

for(int i=0; i<arr.length; i++) {

// i依次表示数组的角标

String s = arr[i];

System.out.println(s);

}

System.out.println("-------------------------------------");

// 在jdk5中我们可以使用增强for循环迭代

// 增强for循环括号里写两个参数，第一个是声明一个变量，变量类型必须是数组元素的类型

// 第二个就是需要迭代的容器

// for循环会循环容器的length次, 每次都将容器的第n-1个元素赋值给声明的变量

for(String s : arr) {

// 循环体，执行arr.length

// 每次都将arr中的第n-1个元素给s

System.out.println(s); //

}

3. 基本数据类型的包装类

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

1) Integer x = 1; x = x + 1; 经历了什么过程？装箱à 拆箱 à 装箱

2) 为了优化，虚拟机为包装类提供了缓冲池， Integer池的大小 -128~127 一个字节的大小

3) String池

Java为了优化字符串操作提供了一个缓冲池

面试题：

String s = “abc” 和 String s = new String(“abc”) 的区别

String s = new String(“abc”) 创建了几个对象

String s = “a” + “b” + “c” + “d” 创建了几个对象

String s1 = “a” String s2 = “b” String s3 = s1 + s2; s3==”ab”?

/*1. String s = "abc"，虚拟机首先会检查String池里有没有"abc"对象(通过equals方法)

// 如果有，直接返回引用，如果没有，会在池里创建一个“abc”对象，并返回引用

String s1 = "abc";

String s2 = "abc";

System.out.println(s1==s2); // result: true

/* 2. String str = new String("abc");

不管缓冲池是否有"abc", 都会在堆内存创建一个"abc"对象，返回引用

// 此时，负责检查并维护缓冲池，其实堆内存的对象是缓冲池中"abc"对象的一个拷贝

String s1 = new String("abc");

String s2 = new String("abc");

System.out.println(s1==s2); // result: false

/* 3. String s = "a" + "b" + "c" + "d"; java编译器有个合并已知量的优化功能

// 在编译阶段就把"a" + "b" + "c" + "d" 合并为 ”abcd“

String s = "a" + "b" + "c" + "d";

// String s = "abcd";

System.out.println(s=="abcd");// result: true

/* 4. String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;

// String是常量，不能相加的，java如何实现的？

StringBuilder sb = new StringBuidler(s1);

sb.append(s2);

s3 = sb.toString();

也就是说实际上s3是方法返回的String对象

凡是方法返回的字符串对象都是在堆内存的

String s1 = "a";

String s2 = "b";

String s3 = s1 + s2; // 堆内存的对象

System.out.println(s3=="ab");// result: false

4) 单列集合 Collection

List list = new ArrayList();

list.add("aaa");

list.add("bbb");

list.add("ccc");

// 传统方式1

/* 1.获得迭代器

Iterator iter = list.iterator();

// 2.循环判断迭代器是否有下一个

while(iter.hasNext()) {

String str = (String) iter.next(); // 将迭代器的指针移向下一个，并将迭代当前指向的元素返回

System.out.println(str);

}

// 传统方式2

for(Iterator iter=list.iterator(); iter.hasNext(); ) {

String s = (String) iter.next();

System.out.println(s);

}

System.out.println("--------------------------------");

// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能

for(Object obj : list) {

String s = (String) obj;

System.out.println(s);

}

5) 双列集合 Map

Map map = new HashMap();

map.put("a", "aaa");

map.put("b", "bbb");

map.put("c", "ccc");

// 传统方式迭代1

// 1. 获得所有的key

Set keys = map.keySet();

// 2.迭代keys获得所有的key

Iterator iter = keys.iterator();

while(iter.hasNext()) {

String key = (String) iter.next(); // a b c

// 3.根据key获得对应的value

String value = (String) map.get(key);

System.out.println(key + "=" + value);

}

System.out.println("---------------------------------");

// 传统方式2，必须掌握这种方式

// 1.获得所有的键值对Entry对象

Set entrys = map.entrySet();

// 2.迭代出所有的entry

iter = entrys.iterator();

while(iter.hasNext()) {

Map.Entry entry = (Entry) iter.next();

// 分别获得key和value

String key = (String) entry.getKey();

String value = (String) entry.getValue();

System.out.println(key + "=" + value);

}

System.out.println("-------------------------------------");

System.out.println("增强for循环迭代，");

// 增强for循环迭代，

// 原则上map集合是无法使用增强for循环来迭代的，

// 因为增强for循环只能针对实现了Iterable接口的集合进行迭代

// Iterable是jdk5中新定义的接口，就一个方法iterator方法

// 只有实现了Iterable接口的类，才能保证一定有iterator方法

// java有这样的限定是因为增强for循环内部还是用迭代器实现的

// 而实际上，我们可以通过某种方式来使用增强for循环

for(Object obj : map.entrySet()) {

// obj 依次表示Entry

Map.Entry entry = (Entry) obj;

System.out.println(entry.getKey() + "=" + entry.getValue());

}

6）集合迭代注意问题

// 在使用迭代器迭代集合的过程中，不能对集合进行增删操作

@Test

public void test4() {

List list = new ArrayList();

list.add("wangwu");

list.add("zhangsan");

list.add("lisi");

Iterator iter = list.iterator();

while(iter.hasNext()) {

String name = (String) iter.next();

if("wangwu".equals(name)) {

// 从集合中删掉

//list.remove(name);

// 迭代过程中删除元素需要调用迭代器的方法

iter.remove(); // 删除我迭代的集合被我迭代的最后一个元素

}

// 1 2 4

System.out.println(list.size());

}

@Test

public void test5() {

List list = new ArrayList();

list.add("aa");

list.add("bb");

// 使用ListIterator迭代器

ListIterator listIterator = list.listIterator();

while(listIterator.hasNext()) {

listIterator.next();

// 迭代过程中增加元素

listIterator.add("cc");

}

System.out.println(list.size());

}

7) 增强for循环注意问题

//在使用增强for循环时，不能对元素进行赋值

int[] arr = {1,2,3};

for(int num : arr) {

num = 0;

}

System.out.println(arr[1]);

4. 可变参数

1) jdk5中方法的形参可以定义为可变参数，传入实参个数可变

// 设计一个方法求n个数的和

public static int getSum(int... arr) {

// 可变参数在方法中仍被看做一个数组

int sum = 0;

for(int num : arr)

sum += num;

return sum;

}

2)Arrays.asList为例演示传入不同参数的情况

// list长度为3

List list = Arrays.asList("a","b","c");

// list长度为1，因为考虑1.4语法

String[] arr = {"a","b","c"};

List list = Arrays.asList(arr);

// 同时符合1.4和1.5的语法,此时会优先考虑1.4的语法

// 原因是有了新功能要保证以前的代码不出错，向后兼容

// 现在就需要将arr作为一个元素存入集合

Object obj = arr;

List list2 = Arrays.asList(obj); // 此时只符合1.5的语法，不符合1.4的语法，没有歧义

List list3 = Arrays.asList(new Object[]{arr}); // 优先考虑1.4，所以数组会拆开

//System.out.println(list3.size());

// 基本数据类型数组只符合1.5的语法

int[] nums = {1,2,3};

list = Arrays.asList(nums);

System.out.println(list.size());

5. 枚举

问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个

解决办法：

1）在setGrade方法中做判断，不符合格式要求就抛出异常

2）直接限定用户的选择，通过自定义类模拟枚举的方式来限定用户的输入

写一个Grade类，私有构造函数，对外提供5个静态的常量表示类的实例

3) jdk5中新定义了枚举类型，专门用于解决此类问题

4) 枚举就是一个特殊的java类，可以定义属性、方法、构造函数、实现接口、继承类

//枚举类就是一个java类，也可以声明属性，方法，构造函数

public enum Grade4 {

A("90-100"),B("80-89"),C("70-79"),D("60-69"),E("0-59");

private String value;

private Grade4(String value) {

this.value = value;

}

public String getValue() {

return value;

}

//枚举类就是一个java类, 也可以继承抽象和实现接口

public enum Grade5 {

// 抽象类不能创建实例对象

A("90-100"){

// new了一个Grade5的子类实例