第6章 JavaAPI_补充案例

第六章补充案例
案例6-1常见的创建字符串的方式
一、案例描述
1、考核知识点
编号：00106001
名称：String类的初始化
2、练习目标
➢掌握创建String对象的两种方式
➢掌握如何使用String类的构造方法初始化String对象
3、需求分析
String类中有很多重载的构造方法，由于每个构造方法有其不同的作用，所以在不同场景下如何选择正确的构造方法，对于初学者来说显得尤为重要。

为了让初学者能熟悉每个构造方法的用法，本案例将使用不同的构造方法创建字符串，以加深对字符串初始化的理解。

4、设计思路（实现原理）
1)编写Example01类。

2)在main()方法中分别使用不同的构造方法创建字符串对象。

3)将字符串内容输出，根据打印结果观察字符串之间的区别，熟悉不同构造方法的用途。

二、案例实现
public class Example01{
public static void main(String[] args) {
// 方式1
String s1 = new String();
s1 = "abcde";
System.out.println("通过String()方法创建的字符串s1:" + s1);
// 方式2
byte[] bys = { 97, 98, 99, 100, 101 };
String s2 = new String(bys);
System.out.println("通过String(byte[] bytes)方法创建的字符串s2:" + s2);
// 方式3
String s3 = new String(bys, 2, 3);
System.out.println("通过String(byte[] bytes, int index, int length)方法创建的字符串s3:" + s3);
// 方式4
char[] chs = { 'a', 'b', 'c', 'd', 'e' };
String s4 = new String(chs);
System.out.println("通过String(char[] value)方法创建的字符串s4:" + s4);
// 方式5
String s5 = new String(chs, 1, 3);
System.out.println("通过String(char[] value, int index, int length)方法创建的字符串s5:" + s5);
// 方式6
String s6 = new String("abcde");
System.out.println("通过String(String str)方法创建的字符串s6:" + s6);
// 方式7
String s7 = "abcde";
System.out.println("直接给字符串对象赋值s7:" + s7);
}
}
运行结果如图6-1所示。

图6-1运行结果
三、案例总结
上面介绍过了String类的常用构造方法，一般情况下，常用的创建String对象的方式如下所示：String str1 = "string";
String str2 = new String("string");
这两种创建方式是有区别的，这和java的内存管理有关。

因为String对象创建后不可变，所以按照第一种方式创建的字符串会放在栈里，更确切的是常量池中，常量池就是用来保存在编译阶段确定好了大小的数据，一般我们定义的int等基本数据类型就保存在这里。

使用第一种创建字符串的方法时，编译器首先检查常量池，看看有没有一个“string”，如果没有则创建。

如果有的话，则直接把str1指向那个位置。

而第二种创建字符串的方法是通过new关键字，java会将new的对象放在堆中，这一部分对象是在运行时创建的对象。

所以我们每一次new的时候，即便堆中已经有了一个一模一样的，都会创建不同的对象。

接下来，通过一个例子来演示这两种创建字符串方式的区别。

public class Example {
public static void main(String[] args) {
String str1 = "string";
String str2 = new String("string");
String str3 = new String("string");
String str4 = "string";
/* 用于测试两种创建字符串方式的区别 */
System.out.println("(str1 == str4): "+(str1 == str4));
System.out.println("(str2 == str3): "+(str2 == str3));
System.out.println("(str3 == str1): "+(str3 == str1)); }
}
运行结果如图6-2所示。

图6-2运行结果
案例6-2字符串的判断操作
一、案例描述
1、考核知识点
编号：00106002
名称：String类的常见操作
2、练习目标
➢掌握如何使用String类中的判断方法对字符串进行操作。

3、需求分析
String类中提供了许多对字符串进行判断操作的方法，每个判断操作都有其自己的使用场景，为了让初学者能快速熟悉每个判断方法的用法，本案例将针对不同场景使用不同的判断方法，并根据判断操作输出的结果进行对比学习。

4、设计思路（实现原理）
1)编写Example02类。

2)在main()方法中，使用String类中的几种常见判断操作方法，依次实现对字符串的判断操作。

3)将判断结果输出，根据打印结果，熟悉不同判断方法的作用。

二、案例实现
public class Example02 {
public static void main(String[] args) {
String s = "HelloWorld";
System.out.println("***********字符串的判断操作***********");
System.out.println("s是和HelloWorld相等："+s.equals("HelloWorld"));
System.out.println("--------------------");
System.out.println("（不区分大小写）字符串s和'helloworld'相等："
+s.equalsIgnoreCase("helloworld"));
System.out.println("--------------------");
System.out.println("字符串s中包含'or'："+s.contains("or"));
System.out.println("--------------------");
System.out.println("字符串s以'Hel'开头："+s.startsWith("Hel"));
System.out.println("--------------------");
System.out.println("字符串s为空："+s.isEmpty());
}
}
运行结果如图6-3所示。

图6-3运行结果
三、案例总结
equals()方法比较的是两个字符串的引用是否相同；而“==”比较的是两个对象的地址是否相同。

接下来，通过一个例子来对比“==”和“equals”的区别。

public class Example {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
if (s1 == s2) {
System.out.println("s1 == s2");
} else {
System.out.println("s1 != s2");
}
if (s1.equals(s2)) {
System.out.println("s1 equals s2");
} else {
System.out.println("s1 not equals s2");
}
}
}
运行结果如图6-4所示。

图6-4运行结果
在上述代码中，==比较的是地址值，equals()方法比较的是字符串的引用。

案例6-3字符串的获取操作
一、案例描述
1、考核知识点
编号：00106002
名称：String类的常见操作
2、练习目标
➢掌握如何使用String类的获取方法对字符串进行操作。

3、需求分析
String类中提供了许多对字符串进行获取操作的方法，每个获取操作方法都有其各自的使用场景，为了让初学者能快速熟悉每个获取方法的用法，本案例将针对不同场景使用不同的获取方法，并根据获取结果进行参照学习。

4、设计思路（实现原理）
1)编写Example03类。

2)在main()方法中，使用String类中几种常见的获取方法，依次实现对字符串的获取操作。

3)将获取结果输出，根据打印结果，熟悉不同获取方法的作用。

二、案例实现
public class Example03{
public static void main(String[] args) {
String s = "HelloWorld";
System.out.println("字符串s是："+s);
System.out.println("***********字符串的获取操作***********");
System.out.println("字符串s的长度是："+s.length());
System.out.println("--------");
System.out.println("字符串s中第3个字符是："+s.charAt(2));
System.out.println("--------");
System.out.println("字符串s中第一次出现'l'字符的索引是："+s.indexOf('l'));
System.out.println("从字符串s的第5个字符开始，出现字符'l'的索引是："
+s.indexOf('l', 4));
System.out.println("--------");
System.out.println("字符串s中第5个字符到结尾组成的新字符串是："+s.substring(4));
System.out.println("字符串s中由第5个到第9个字符组成的新串是："+s.substring(4, 8));
}
}
运行结果如图6-5所示。

图6-5运行结果
从运行结果可知，字符串中索引的大小是从0开始的，其他方法运行正常。

三、案例总结
访问字符串中的字符时，不能超出字符的索引范围，否则会出现图6-6所示的异常。

图6-6运行结果
案例6-4字符串的转换和拼接操作
一、案例描述
1、考核知识点
编号：00106002
名称：String类的常见操作
2、练习目标
➢掌握如何使用String类的转换和拼接方法对字符串进行操作
3、需求分析
String类中提供了许多对字符串进行转换和拼接操作的方法，每个转换或拼接操作都有其各自的作用，为了让初学者能快速熟悉转换和拼接方法的用法，本案例将针对不同需求使用不同的转换和拼接方法，并根据输出结果进行参照学习。

4、设计思路（实现原理）
1)编写Example04类。

2)在main()方法中，使用String类中的转换和拼接方法，对字符串操作。

3)将操作结果输出，根据打印结果，熟悉上述转换和拼接方法的作用。

二、案例实现
public class Example04 {
public static void main(String[] args) {
String s = "HelloWorld";
System.out.println("字符串s是："+s);
System.out.println("***********字符串的转换和拼接操作***********");
char[] chs = s.toCharArray();
System.out.println("***********遍历chs数组***********");
for (int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("-----------------");
char[] chs2 = { 'a', 'b', 'c', '中', '国' };
System.out.println("通过String类的copyValueof()方法将字符数组chs2转换成字符串：
"+String.copyValueOf(chs2));
System.out.println("-----------------");
System.out.println("通过String类的valueOf ()方法将字符数组chs2转换成字符串：
"+String.valueOf(chs2));
System.out.println("-----------------");
int i = 100;
System.out.println("通过String类的valueOf ()方法将int类型的100转换成字符串：
"+String.valueOf(i));
System.out.println("-----------------");
System.out.println("字符串s的小写形式："+s.toLowerCase());
System.out.println("字符串s的大写形式："+s.toUpperCase());
System.out.println("-----------------");
System.out.println("字符串s拼接'world'后，生成的新字符串是："+s.concat("world"));
}
}
运行结果如图6-7所示。

图6-7运行结果
从运行结果可知，copyValueOf(char[] chs)方法和new String(char[] chs)方法都可以将一个字符数组转换成字符串，并且其他的方法运行正常。

三、案例总结
valueOf()方法有很多重载的形式，float、double、char等其它基本类型的数据都可以通过该方法转为String字符串类型。

案例6-5字符串的替换、切割等其他操作
一、案例描述
1、考核知识点
编号：00106002
名称：String类的常见操作
2、练习目标
➢掌握如何使用String类的替换、切割等方法对字符串进行操作
3、需求分析
String类中提供了许多对字符串进行替换、切割操作的方法，其中每个方法都有其各自的作用，为了让初学者能快速熟悉替换、切割方法的用法，本案例将针对不同需求使用不同的替换、切割方法，并根据输出结果进行参照学习。

4、设计思路（实现原理）
1)编写Example03类。

2)在main()方法中，使用String类中的替换和切割等方法，对字符串的操作。

3)将操作结果输出，根据打印结果，熟悉上述替换和切割方法的作用。

二、案例实现
public class Example05 {
p ublic static void main(String[] args) {
String s = "helloworld";
System.out.println("将字符串s中的字符l替换成p后："+s.replace('l', 'p'));
System.out.println("将字符串s中的字符ll替换成ak47后："+
s.replace("ll", "ak47"));
String ages = "20-30";
String[] strArray = ages.split("-");
for (int x = 0; x < strArray.length; x++) {
System.out.println("strArray数组中的索引为"+x+"处的值是："
+strArray[x]);
}
String name = " admin hello ";
System.out.println("去掉首尾空格后的字符串name：" + name.trim());
String s1 = "hello";
String s2 = "aello";
System.out.println("按照默认字典的顺序比较字符串s1和s2："+
pareTo(s2));// 7
}
}
运行结果如图6-8所示。

图6-8运行结果
三、案例总结
1、trim()方法只能去除两端的空格，不能去除中间的空格。

若想去除字符串中间的空格，则可以调用String类的replace()方法。

2、compareTo()的返回值是整型，它是先比较对应字符的大小(ASCII码顺序)。

如果第一个字符和参数的第一个字符不等，则结束比较并返回他们之间的差值；如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推。

直至比较的字符或被比较的字符有一方全比较完，这时就比较字符的长度。

案例6-6StringBuffer类的添加和删除操作
一、案例描述
1、考核知识点
编号：00106003
名称：StringBuffer类
2、练习目标
➢掌握String和StringBuffer的区别。

➢掌握如何使用StringBuffer对象的添加和删除方法操作字符序列。

3、需求分析
StringBuffer类有很多操作字符的方法，其中append()和insert()是常用的添加字符方法，delete()是常用的删除字符方法。

为了让初学者对StringBuffer类中的添加、删除方法有更深入的了解，本案例将演示StringBuffer对象的添加、删除操作。

4、设计思路（实现原理）
1)编写Example06类。

2)在main()方法中，使用StringBuffer类中的方法，依次实现字符序列的添加和删除操作。

3)将添加和删除操作的结果输出，根据打印结果，熟悉各个方法的作用。

二、案例实现
public class Example06 {
// 创建对象
StringBuffer sb = new StringBuffer();
System.out.println("sb:" + sb);
System.out.println("****StringBuffer的添加方法****");
sb.append(100).append("hello").append(true).append(12.5);
System.out.println("使用StringBuffer对象添加任意数据类型的数据后sb:" + sb);
sb.insert(8, "world");
System.out.println("在sb的第9个位置插入'world'字符串后sb:" + sb);
System.out.println("****StringBuffer的删除方法****");
sb.deleteCharAt(1);
System.out.println("删除sb中第2个位置的字符后sb:" + sb);
sb.delete(5, 10);
System.out.println("删除sb中第6个到第11个字符后的sb:" + sb);
}
}
运行结果如图6-9所示。

图6-9运行结果
三、案例总结
1、访问StringBuffer对象中的字符时，不能超出字符的索引范围，否则会出现异常，这与数组中的角标越界异常非常相似。

2、思考一下：String类和StringBuffer类同样是操作字符串的相关类，那么他们有什么不同之处呢？
a)String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。

而StringBuffer表示字
符容器，其内容和长度都可以随时修改。

在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer类。

b)String类覆盖了Object类的equals()方法，而StringBuffer类没有覆盖Object类的equals()方法，
具体示例如下：
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.equals(s2)); // 打印结果为true
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2)); // 打印结果为false
c)String类对象可以用操作符“+”进行连接，而StringBuffer类对象之间不能，具体示例如下：
String s1 = "a";
String s2 = "b";
String s3 = s1+s2; // 合法
System.out.println(s3); // 打印输出 ab
StringBuffer sb1 = new StringBuffer("a");
StringBuffer sb2 = new StringBuffer("b");
StringBuffer sb3 = sb1+sb2; // 编译出错
案例6-7StringBuffer类的替换、截取和反转操作
一、案例描述
1、考核知识点
编号：00106003
名称：StringBuffer类
2、练习目标
➢掌握如何使用StringBuffer对象的替换、截取和反转方法操作字符序列。

3、需求分析
StringBuffer类有很多操作字符的方法，其中replace(int start, int end, String str)是用来替换字符的方法；substring(int start) 和substring(int start, int end)是用来截取字符的方法；reverse()是用来反转字符顺序的方法。

为了让初学者快速的熟悉上述方法的作用，本案例将根据这些方法，演示字符序列的替换、截取和反转操作。

4、设计思路（实现原理）
1)编写Example07类。

2)在main()方法中，通过StringBuffer类的替换、截取和反转等方法依次实现对字符序列的操
作。

3)将替换、截取和反转操作的结果输出，根据打印结果，加深不同方法的理解。

二、案例实现
public class Example07{
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("hello").append("world").append("java");
System.out.println("追加字符串后的sb:"+sb);
System.out.println("****字符序列的替换方法**** ");
sb.replace(5, 10, "林青霞");
System.out.println("使用replace()方法替换后的sb:"+sb);
System.out.println("****字符序列的截取方法**** ");
String s = sb.substring(5);
System.out.println("使用substring()方法截取后的s:"+s);
System.out.println("sb:"+sb);
System.out.println("****字符序列的反转方法**** ");
sb.reverse();
System.out.println("使用reverse()方法反转后的sb:"+sb);
}
}
运行结果如图6-10所示。

图6-10运行结果
三、案例总结
StringBuffer类的截取方法substring(int start)、substring(int start, int end)的返回值是String类型。

而其它添加、删除、替换、反转方法的返回值都是Stringbuffer类型的。

案例6-8System类的常用方法
一、案例描述
1、考核知识点
编号：00106004
名称：System类
2、练习目标
➢掌握System类中获取时间和复制数组以及关闭Java虚拟机的方法。

3、需求分析
System类定义了一些与系统相关的属性和方法，其中包括终止当前正在运行Java虚拟机、以毫秒单位获取当前时间、复制数组等功能。

为了让初学者更加深入的了解System类的作用，本案例将演示使用System类的方法获取系统属性和当前时间的操作。

4、设计思路（实现原理）
1)编写Example08类。

2)在main()方法中，通过调用System类的常用方法，依次实现获取系统信息的操作。

3)将获取到的系统信息输出，根据打印结果，熟悉System类中常用方法的作用。

二、案例实现
import java.util.Arrays;
public class Example08{
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
int[] arr2 = { 5, 6, 7, 8, 9 };
long time = System.currentTimeMillis();
System.out.println("系统当前时间是："+time);
System.arraycopy(arr, 3, arr2, 3, 2);
System.out.println("数组arr的内容是："+Arrays.toString(arr));
System.out.println("数组arr2的内容是："+Arrays.toString(arr2));
System.exit(100);
System.out.println("HelloWorld");
}
}
运行结果如图6-11所示。

图6-11运行结果
从图6-11中可以看出，控制台没有打印“Helloworld”，说明System的exit()方法起到了终止Java虚拟机运行的功能。

三、案例总结
System类中所提供的属性和方法都是静态的，因此，想要引用这些属性和方法，需要使用System类直接调用。

案例6-9Runtime类的常用方法
一、案例描述
1、考核知识点
编号：00106005
名称：Runtime类
2、练习目标
➢掌握Runtime对象的获取方法。

➢熟练使用Runtime对象的exec()方法执行dos命令。

3、需求分析
Runtime类中提供了一个exec()方法，该方法用于执行一个dos命令，从而实现和在命令行窗口中输入dos命令同样的效果。

为了让初学者能够熟悉Runtime中常用方法的用法，本案例将通过调用Runtime对象的exec()方法演示开启记事本的操作。

4、设计思路（实现原理）
1)编写Example09类。

2)在main()方法中，通过Runtime类的getRuntime()方法获取Runtime对象r。

3)调用r对象的exec()方法，使其执行notepad.exe命令并打开记事本。

二、案例实现
import java.io.IOException;
public class Example09{
public static void main(String[] args) {
Runtime r = Runtime.getRuntime();
try {
r.exec("notepad.exe");
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果如图6-12所示。

图6-12运行结果
三、案例总结
Runtime类用于表示虚拟机运行时的状态，它用于封装JVM虚拟机进程。

每次使用java命令启动虚拟机都对应一个Runtime实例，并且只有一个实例，因此该类采用单例模式进行编写，对象不可以直接实例化，需要通过Runtime.getRuntime()方法获取。

案例6-10Math类的常用方法
一、案例描述
1、考核知识点
编号：00106006
名称：Math类
2、练习目标
➢掌握Math类中一些常用的数学运算方法，例如求绝对值、三角函数等。

3、需求分析
在程序开发中，会遇到一些对数字进行运算处理的情况。

这时，可以通过Java API提供的Math类，实现对数字的运算处理。

为了让初学者能熟悉Math类的常用方法，在案例中将列举常用的数学运算，并依次输出运算结果。

4、设计思路（实现原理）
1)编写Example10类。

2)在main()方法中分别使用Math类的常用方法操作数字运算。

3)分别将表达式的运算结果输出。

二、案例实现
public class Example10{
public static void main(String[] args) {
System.out.println("π的值是:"+Math.PI);
System.out.println("自然对数的底数:"+Math.E);
System.out.println("3的绝对值:"+Math.abs(3));
System.out.println("27的立方根是:"+Math.cbrt(27));
System.out.println("16的平方根是:"+Math.sqrt(16));
System.out.println("4的平方是:"+Math.pow(4, 2));//4的2次方
System.out.println("12.345使用ceil方法后的结果是:"+Math.ceil(12.345));
System.out.println("-12.345使用floor方法后的结果是："
+Math.floor(-12.345));
for(int x=0; x<3 ;x++){
System.out.println(Math.random());
}
for(int x=0; x<3 ;x++){
System.out.println((int)(Math.random()*100+1)); //边界值 1 - 100 }
}
}
运行结果如图6-13所示。

图6-13运行结果
三、案例总结
Math的round()方法用于对某个小数进行四舍五入，此方法会将小数点后面的数字全部忽略，返回一个int值。

而ceil()方法和floor()方法返回的都是double类型的数，这个数在数值上等于一个整数。

案例6-11Random类的常用方法
一、案例描述
1、考核知识点
编号：00106007
名称：Random类
2、练习目标
➢掌握如何使用Random类中的方法创建随机数。

3、需求分析
在Java API中提供了一个Random类，它包含多种随机产生数字的方法。

为了让初学者能够掌握Random类每个随机方法的不同，在案例中使用Random类中的不同方法随机生成数字，并根据两输出结果来对比学习。

4、设计思路（实现原理）
1)编写Example11类。

2)在main()方法中，通过Random的无参构造方法，创建Random对象r。

3)编写两个for循环，在第一个循环体内，调用r对象的nextInt()方法生成随机数，并打印该随
机数；在第二个循环体内，调用r对象的nextInt(10)方法，生成10以内的随机数，同样也打
印该随机数。

二、案例实现
import java.util.Random;
public class Example11 {
public static void main(String[] args) {
Random r = new Random();
System.out.println("使用r对象随机生成int取值范围内的5个数");
for (int x = 0; x < 5; x++) {
System.out.println(r.nextInt());
}
System.out.println("使用r对象随机生成5个10以内的整数");
for (int x = 0; x < 5; x++) {
System.out.println(r.nextInt(10));
}
}
}
运行结果如图6-14所示。

图6-14运行结果
三、案例总结
1、当使用Random类的有参构造方法创建多个Random对象时，如果传入的种子相同，则他们产生随机数的序列是相同的。

2、Random类的nextInt(100)只能获取0~100之间的int类型的随机数，包括0，但不包括100。

案例6-12包装类的基本用法
一、案例描述
1、考核知识点
编号：00106008
名称：包装类
2、练习目标
➢掌握包装类的作用和概念。

➢掌握包装类中的常用方法。

3、需求分析
Java API针对八种基本类型提供了八种包装类来实现各种高级功能，比如说，某基本类型的范围判断，整数的进制转换等。

为了让初学者能够熟悉包装类的基本用法，在案例中列举出包装类常用方法并输出结果。

4、设计思路（实现原理）
1)编写Example12类。

2)在main()方法中分别使用Integer类的属性和方法获取Integer类型的取值范围和进制间的转
换结果。

3)分别将包装类的取值范围和转换结果输出。

二、案例实现
public class Example12 {
public static void main(String[] args) {
System.out.println("int范围的最大值是"+Integer.MAX_VALUE);
System.out.println("int范围的最小值是"+Integer.MIN_VALUE);
// 把60转变成二进制，八进制，十六进制
System.out.println("60的二进制值是："+Integer.toBinaryString(60));
System.out.println("60的八进制值是："+Integer.toOctalString(60));
System.out.println("60的十六进制值是："+Integer.toHexString(60));
}
}
运行结果如图6-15所示。

图6-15运行结果
三、案例总结
Java语言是一个面向对象的语言，但java中的基本数据类型却不是面向对象的，它通过包装类可以将基本数据类型的值包装为引用数据类型的对象。

案例6-13包装类的装箱和拆箱
一、案例描述
1、考核知识点
编号：00106008
名称：包装类
2、练习目标
➢掌握包装类的装箱和拆箱概念
3、需求分析
包装类和基本数据类型在进行转换时，引入了装箱和拆箱的概念，其中装箱是指将基本数据类型的值转为引用数据类型，反之，拆箱是指将引用数据类型的对象转为基本数据类型。

为了让初学者增加对包装类的装箱和拆箱功能的理解，本案例将演示基本数据类型和包装类的装箱和拆箱的效果。

4、设计思路（实现原理）
1)编写Example13类。

2)在main()方法中，利用Integer的构造方法和intValue()方法，实现int类型数据100的装箱和
拆箱操作。

3)分别将装箱和拆箱的结果输出，根据打印结果熟悉装箱和拆箱之间的区别。

二、案例实现
public class Example13 {
public static void main(String[] args) {
Integer num = new Integer(100); //装箱
int value = num.intValue(); //拆箱
System.out.println("num:"+num);
System.out.println("value:"+value);
}
}
运行结果如图6-16所示。

图6-16运行结果
三、案例总结
1、包装类的装箱和拆箱实质上是基本数据类型和引用数据类型相互转换的过程。

案例6-14包装类的自动装箱和拆箱
一、案例描述
1、考核知识点
编号：00106008
名称：包装类
2、练习目标
➢掌握包装类中自动装箱和拆箱技术。

3、需求分析
在JDK5.0的版本中提供了自动拆箱和装箱技术，也就是可以自动进行基本数据类型和包装类对象之间的转换。

为了让初学者增加对包装类的自动装箱和拆箱功能的理解，接下来通过一个案例实现了包装类的自动装箱和拆箱功能。

4、设计思路（实现原理）
1)编写Example14类。

2)在main()方法中，使用Integer对象进行基本的数学运算操作，并打印出运算后的结果。

二、案例实现
public class Example14 {
public static void main(String[] args) {
Integer x = 10; //装箱
x = x + 1;
System.out.println("x的值是:"+x);
}
}
运行结果如图6-17所示。

图6-17运行结果
三、案例总结
1、包装类都重写了Object类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。

2、除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，
但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。

具体示例如下：
Integer i = Integer.valueOf("123"); // 合法
Integer i = Integer.valueOf("12a"); // 不合法
3、除了Character外，包装类都有parseXXX(String s)的静态方法，将字符串转换为对应的基本类型的
数据。

参数s不能为null，而且同样必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。

具体示例如下：
int i = Integer.parseInt("123"); // 合法
Integer in = Integer.parseInt("itcast");// 不合法
4、在使用包装类对象时，要注意该对象是否为null。

案例6-15Date类的构造方法
一、案例描述
1、考核知识点
编号：00106009
名称：Date类
2、练习目标
➢掌握Date类的作用以及概念。

➢掌握如何通过Date类的构造方法创建Date对象。

3、需求分析
在Java API中提供了一个Date类用于表示日期和时间。

Date类中大部分构造方法都被声明为已过时，只有两个构造方法是建议使用的。

为了让初学者了解这两个构造方法的用法，本案例将通过Date类的构造方法创建2个Date对象，并打印他们对应的值。

4、设计思路（实现原理）
1)编写Example15类。

2)在main()方法中，分别利用Date的两个构造方法创建两个Date对象，并打印Date对象的值。

二、案例实现
import java.util.Date;
public class Example15{
public static void main(String[] args) {
// 方式一
Date d1 = new Date();
// Sat Dec 21 15:40:24 CST 2013
System.out.println(d1);
System.out.println("****************");
//方式二
Date d2 = new Date(1387611761750L);
System.out.println(d2);
System.out.println("-------------------");
}
}
运行结果如图6-18所示。

图6-18运行结果
三、案例总结
由于Date类在设计之初，没有考虑国际化的问题，因此从JDK 1.1 开始，Date类中相应的功能被Calendar类中的方法取代了。

那么，对于Date类，只需要了解如何通过创建对象封装时间值即可
案例6-16Calendar类的常用方法
一、案例描述
1、考核知识点
编号：00106010
名称：Calendar类
2、练习目标
➢掌握Calendar类的作用以及概念。

➢掌握如何使用Calendar类的常用方法。

3、需求分析
从JDK1.1开始，Calendar类逐渐取代了Date类，Calendar类包含了大量操作日期和时间的方法。

为了让初学者熟练掌握Calendar类中方法的用法，本案例将通过这些方法求出1998年2月份的天数。

4、设计思路（实现原理）
1)编写Example16类。

2)在main()方法中，通过静态方法getInstance()创建一个Calendar对象。

3)将Calendar对象的日期设置为1998年3月1日。

4)将Calendar对象表示的日期向前推1日，即1998年2月的最后一天。

5)打印2月的最后一天的数字，即1998年2月份的天数。

二、案例实现
import java.util.Calendar;
public class Example16 {
public static void main(String[] args) {
// 获取Calendar对象
Calendar c = Calendar.getInstance();
int year = 1998;
c.set(year, 2, 1);// 把日期设置为2013年3月1日
c.add(Calendar.DATE, -1);// 把日期往前推1日
System.out.println("1998年2月份的天数是："+c.get(Calendar.DATE));
}
}
运行结果如图6-19所示。

图6-19运行结果。