第三篇Java核心技术复习博客

第四章：面向对象（下）

4.5异常

一、什么是异常

在Java语言中，引入了异常，以异常类的形式对这些非正常的情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理

1. package W;

3. public class A1 {

5. public static void main(String[] args) {

6. int result=divide(4,2);//调用divide（）方法//把2改成0的话0不允许做除数就会出现异常

7. System.out.println(result);

8. }

9. //下面的方法实现了两种整数相除

10. public static int divide(int x,int y){

11. int result=x/y;

12. return result;

13. }

14. }

运行结果如下：

 异常

1. package W;

3. public class A1 {

5. public static void main(String[] args) {

6. int result=divide(4,0);//调用divide（）方法//把2改成0的话0不允许做除数就会出现异常

7. System.out.println(result);

8. }

9. //下面的方法实现了两种整数相除

10. public static int divide(int x,int y){

11. int result=x/y;

12. return result;

13. }

14. }

运行结果如下：

Throwable类的继承体系

Throwable有两个直接子类Error和Exception，其中Error代表程序中产生的错误，Exception代表程序中产生的异常

接下来就对这两个直接子类进行详细的讲解：

      Error类称为错误类，它表示Java运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的。举一个生活中的例子，在盖校的过程中因偷工减料，导致大楼坍塌，这就相当于一个Error。使用iava俞令去运行一个不存在的类就会出现Error错误。
      Exception类称为异常类，它表示程序本身可以处理的错误，在开发Java程序中进行的异常处理，都是针对Exception类及其子类。在Exception类的众多子类中有一个特殊的Runtimefxcention类，该类及其子类用于表示运行时异常，除了此类，Exception类下所有其他的子莞都用于表示编译时异常。本节主婴针对Emception类及其子类进行讲解。
Throwable类中的常用方法

二、try...catch和finally

Java中提供了一种对异常进行处理的方式一一异常捕获。异常捕获通常使用
try...catch语句

1. //语法:

2. try{

3. //程序代码块

4. }catca（ExceptionType(Exception类及其子类 ) e）{

5. //对ExceptionType的处理

7. }

 其中在try代码块中编写可能发生异常的Java语句，catch代码块中编写针对异常进行处理的代码。当tny代码块中的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，并将这个对象传递给catch代码块。catch代码块需要一个参数指明它所能够接收的异常类型，这个参数的类型必须是Exception类或其子类。

1. package W;

3. public class A1 {

5. public static void main(String[] args) {

6. //下面的代码定义了一个try...catch...finally语句用于捕获异常

7. try {

9. int result=divide(4,2);//调用divide（）方法

10. System.out.println(result);

11. }catch(Exception e) {//对捕获的异常进行处理

12. System.out.println("捕获的异常信息为："+e.getMessage());

13. return;//结束整个方法

14. }finally {

15. System.out.println("进入finally代码块");

16. }

17. System.out.println("程序继续向下执行");

18. }

20. //下面的方法实现了两种整数相除

21. public static int divide(int x,int y){

22. int result=x/y;//定义变量result记录两个数相除的结果

23. return result;

24. }

25. }

运行结果如下：

把2改成0后出现异常打印了一个异常信息

1. package W;

3. public class A1 {

5. public static void main(String[] args) {

6. //下面的代码定义了一个try...catch...finally语句用于捕获异常

7. try {

9. int result=divide(4,0);//调用divide（）方法

10. System.out.println(result);

11. }catch(Exception e) {//对捕获的异常进行处理

12. System.out.println("捕获的异常信息为："+e.getMessage());

13. return;//结束整个方法

14. }finally {

15. System.out.println("进入finally代码块");

16. }

17. System.out.println("程序继续向下执行");

18. }

20. //下面的方法实现了两种整数相除

21. public static int divide(int x,int y){

22. int result=x/y;//定义变量result记录两个数相除的结果

23. return result;

24. }

25. }

 、运行结果如下：

三、thr ows关键字

Java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者在谓用方法时，就明确地知道该方法有异常，井且必须在程序中对异常进行处理，否则编译无法通过。

throws关键字声明抛出异常的语法格式如下:
修饰符 返回值类型 方法名 （[参数1，参数2....])throws ExceptionTypel[，ExceptionType2.....]{

}

从上述语法格式中可以看出，throws关键字需要写在方法声明的后面，throws后面鸳要声明方法中发生异常的类型，通常将这种做法称为方法雨明抛出一个异常

1. package W;

3. public class A1 {

5. public static void main(String[] args) throws Exception{

6. //下面的代码定义了一个try...catch语句用于捕获异常

7. try {

8. int result=divide(4,2);//调用divide（）方法

9. System.out.println(result);

10. }catch(Exception e) {//对捕获的异常进行处理

11. e.printStackTrace();//打印捕获的异常信息

12. }

13. }

14. //下面的方法实现了两种整数相除，并使用throws关键字声明抛出异常

15. public static int divide(int x,int y)throws Exception{

16. int result=x/y;//定义变量result记录两个数相除的结果

17. return result;

18. }

19. }

 运行结果如下：

四、运行时异常和编译时异常

在实际开发中，经常会在程序编译时产生一些异常，而这些异常必须要进行处理，这种异常被称为编译时异常，也称为checked异常。另外还有一种异常是在程序运行时产生的，这种异常即使不编写异常处理代码，依然可以通过编译，因此被称为运行时异常，也称为unchecked异常。

1、偏译时异常
在Java中，Exception类中除了RuntimeExcurotion类及其子类都是编译时异常。编译时异常的特点是Java编译器会对其进行检查，如果出现异常就必须对异常进行处理，否则程序无法通过编译。

处理编译时期的异常有两种方式:

使用try...catch语句对异常进行捕获
使用throws关键字声明抛出异常，调用者对其处理
 2、运行时异常
RuntimeException类及其子类都是运行时异常。运行时异常的特点是Java编译不会对其进行检查，也就是说，当程序中出现这类异常时，即使没有使用trv..catch语句捕获或使用throws关键字声明抛出，程序也能编译通过。运行日异常一般是由程序中的逻辑错误引起的，在程序运行时无法恢复。比如通过组的角标访问数组的元素时，如果超过了数组的最大角标，就会发生运行时常

1. 代码如下所示:

2. int[ ] arr=new int[5];

4. System.out.println(arr[6]);

上面代码中，由于数组arr的length为5，最大角标应为4，当使用arr[6]访问数中的元素就会发生数组角标越界的异常

五、自定义异常

JDK中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况，例如文件4-38中在divide0方法中不允许被除数为负数。为了解决这个问题，在Java中允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类

1. nt result=x/y;//定义变量result记录两个数相除的结果

2. return result;

3. }

4. }

7. package W;

9. public class Excption2 {

11. public static void main(String[] args) {

12. try {

13. int result=divide(4,-2);//调用divide（）方法，传入一个负数作为被除数

14. System.out.println(result);

15. }catch (DivideByMinusExcption e) {//对捕获的异常进行处理

16. System.out.println(e.getMessage());//打印捕获的异常信息

17. }

19. }

20. //下面的方法实现了两种整数相除,使用throws关键字声明抛出异常

21. public static int divide(int x,int y)throws DivideByMinusExcption{

22. if (y<0) {

23. throw new DivideByMinusE

运行结果如下：

六、 访问控制

在Java中，针对类、成员方法和属性提供了四种访问级别，分别是private.default、protected和public。接下来通过一个图将这四种控制级别由小到大依次列出

上图中展示了Java中的四种访问控制级别，具体介绍如下:

• private(类访问级别): 如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其他成员访问，其他类无法直接访问。类的良好封装就是通过private关键字来实现的。
• default(包访问级别): 如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问。
• protected(子类访问级别): 如果一个类的成员被protected访问控制符修饰，那么这个成员晓能被同一包下的其他类访问，也能被不同包下该类的子类访问。
• public(公共访问级别):这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制符修饰，那么这个类或者类的成员能被所有的类访问，不管访问类与被访问类是否在同一个包中。

接下来通过一个表将这四种访问级别更加直观的表示出来，如下表所示

第五章

一、API_类的初始化

类的初始化

API指的是应用程序，编程接口

在操作string类之前，首先需要对string类进行初始化，在JAVA中可以通过以下两种方式对string类

进行初始化

1、使用字符串常量直接初始化一个string对象

String  str1="abc";
2、使用string的构造方法初始化，字符串对象string的构造方法

String()    创建一个内容为空的字符串
String(String value)      根据指定的字符串内容创建对象
String(char[ ] value)   根据指定的字符串数组创建对象

使用string的构造方法初始化，字符串对象string的构造方法

1. public class Test2 {

2. public static void main(String[]args) {

3. String str1="abc";

4. //字符串常量直接赋值

5. String str2=new String();

6. //String()空参数构造方法，创建一个String类对象，内容为空

7. String str3=new String("abcd");

8. //String(String s)创建一个String类对象，指定一个字符串内容

9. char[]charArray=new char[] {'E','F','G'};

10. String str4=new String(charArray);

14. System.out.println(str1);

15. System.out.println("a"+str2+"b");//ab

16. System.out.println(str3);

17. System.out.println(str4);

18. }

19. }

 运行结果如下:

二、API_类的常见操作

5.1String类和SreingBuffer类

1、String类的常见操作

String类在实际开发中的应用非常广泛，因此灵活的使用String类是非常重要的

 String类的常用方法

  在程序中，需要对字符串进行一些基本操作，如获得字符串长度获得指定位置的字符等。

1. package W;

2. /*

3. * String类的基本操作

4. * 在程序中，需要对字符串进行一些基本操作，如获取字符串长度，获取指定位置的字符等

5. * public int length() 获取字符串的长度

6. * public char charAt(int index) 获取字符串中指定位置上的字符

7. * public int indexof(char ch) 获取指定字符在字符串中第一次出现的位置

8. * public int lastIndexof(char ch)获取指定字符在字符串中最后一次出现的位置

9. * public int indexof（String str)获取指定子串在字符串中第一次出现的位置

10. * public int lastIndexof(String str)获取指定子串在字符串中最后异常出现的位置

11. */

12. public class Exampel {

13. public static void main(String[] args) {

14. //声明一个字符串

15. String s="abcabcdebca";

16. System.out.println("获取字符串的长度："+s.length());

17. System.out.println("获取字符串中第一个字符："+s.charAt(0));

18. System.out.println("获取字符c第一次出现的位置："+s.indexOf('c'));

19. System.out.println("获取字符c最后一次出现的位置："+s.lastIndexOf('c'));

20. System.out.println("获取子串ab第一次出现的位置："+s.indexOf("ab"));

21. System.out.println("获取子串ab最后一次出现的位置："+s.lastIndexOf("ab"));

22. }

24. }

运行结果如下：

程序开发中，经常需要对字符串进行转换操作，例如将字符串转换成数组的形式，将字符串中的字

符进行大小写转换等。

1. package W;

2. /*

3. * String类的转换操作

4. * 在程序开发中，经常需要对字符串进行转换操作，例如将字符串转换成数组的形式，将字符串的进行大小写转换等

5. * public char[]tochatArray()将此字符串转换成字符数组

6. * public static String valueof(int n)将指定int值转换成String类型

7. * public String touppercase() 将此字符串中的字符全部转换成大写字母，会返回一个新的字符串

8. */

9. public class Exampe {

10. public static void main(String[] args) {

11. //声明一个字符串

12. String s="abcde";

13. //将此字符串转换成字符数组

14. char[] charArray=s.toCharArray();

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

16. //a,b,c,d,e

17. if(i==charArray.length-1) {

18. //数组最后一个元素，直接打印元素

19. System.out.println(charArray[i]);

20. }else {

21. //打印元素值与逗号

22. System.out.print(charArray[i]+",");

23. }

24. }

25. System.out.println("将指定int值转换成String类型后的结果"+String.valueOf(12));

26. System.out.println("将字符串转换成大写字母的结果："+s.toUpperCase());

27. }

28. }

 运行结果如下：

 程序开发中，用户输入数据时经常会有一些错误和空格，这时可以使用String类的replace0和trim0方法，进行字符串的替换和去除空格操作

1. package W;

3. public class Example3 {

4. /*

5. * String类的替换与去除空格操作

6. * 程序开发中，用户输入数据时经常会有一些错误和空格，这时可以使用String类的replace()和trim()方法，进行字符串的替换和去除空格操作。

7. * public String replace(String oldStr, String newStr)

8. * 将原有字符串中o1dStr字符串内容用newStr字符串所替代，返回一个新的字符串

9. * public String trim() 返回一个新字符串，它去除了原有字符串的两端空格

10. */

12. public static void main(String[] args) {

13. //声明一个字符串

14. String s="itcast";

15. String s2="i t c a s t ";

16. //者换操作

17. System.out.println("将it替换成cn.it之后的结果："+ s.replace("it","cn.it"));

18. //去除空格操作

19. System.out.println("去除左右两边空格后的结果："+ s2.trim());

20. System.out.println("去除全部空格后的结果："+s2.replace(" ",""));

21. }

23. }

 运行结果如下：

操作字符串时，经常需要对字符串进行一些判断，如判断字符串是否以指定的字符串开始、结束，是否包含指定的字符串，字符串是否为空等

1. //判断字符串是否以指定的字符串开始与结束，是否包含指定字符串是否为空等

2. package W;

3. /*

4. * string类的判断操作

5. * 操作字符串时，经常需要对字符串进行一些判断，如判断字符串是否以指定的字符串开始、结束，是否包含指定的字符串，字符串是否为空等。

6. * public boolean startsWith(String stx)判断字符串是否以给定字符串stx开头

7. * public boolean endswith(Stringstx）判断字符串是否以给定字符串stx结尾

8. * public boolean contains(String str)判断字符串是否包含给定的字符串stx

9. * public boolean isEmpty()判断字符串内容是否为空

10. * public boolean equals(String stx)判断字符串与给定字符串stx的内容是否相同

11. */

13. public class Example4 {

15. public static void main(String[] args) {

16. //声明一个字符串

17. String s="String";

18. String s2 ="Str";

19. System.out.println("判断字符串是否以Str开头："+s.startsWith("Str"));

20. System.out.println("判断字符串是否以ng结尾："+s.endsWith("ng"));

21. System.out.println("判断字符串是否包含tri："+ s.contains("tri"));

22. System.out.println("判断当前字符串内容是否为空："+s.isEmpty());

23. System.out.println("判断两个字符串中的内容是否相同："+ s.equals(s2));

25. }

27. }

 运行结果如下：

在String类中针对字符串的截取和分割操作提供了两个方法，其中，substring0方法用于截取字符串的一部分，split0方法可以将字符串按照某个字符进行分割

1. //字符串的截取和分割操作

2. package W;

3. /*

4. * String类的截取与分割操作

5. * 在String类中针对字符串的截取和分割操作提供了两个方法

6. * 其中，substring()方法用于截取字符串的一部分

7. * split()方法可以将字符串按照某个字符进行分割

8. * public String substring(int start)返回一个新字符串，它从原有字符串指定位置开始截取，到字符串末尾结束

9. * public String substring(intstart, int end) 返回一个新字符串，它从原有字符串指定位置开始截取，到指定位置结束

10. * public String[] split(String regex)按照指定的字符串进行分割返回一个字符串数组

11. *

12. */

13. public class Example5 {

14. private static int i;

16. public static void main(String[] args) {

17. //声明一个字符串

18. String s="羽毛球一篮球一乒乓球";

19. //截取操作

20. System.out.println("从第5个字符开始截取到末尾的结果："+ s.substring(4));

21. System.out.println("从第5个字符开始截取到第6个字符结束的结果："+s.substring(4,6));//不包含结尾位置的字符

22. //分割操作

23. System.out.println("打印分割后的每个字符串内容");

24. String[] strArray = s.split("-");

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

26. // 羽毛球，篮球，乒乓球

27. if (i== strArray.length -1) {

28. //数组最后一个元素，直接打印数组元素值

29. System.out.println( strArray[i]);

30. }else {

31. //打印数组元素值与逗号

32. System.out.print( strArray[i] +",");

33. }

34. }

35. }

36. }

 运行结果如下：

 String字符串在获取某个字符时，会用到字符的索引，当访问字符串中的字符时，如果符的索引不存在，则会发生StringIndexOutOfBoundsException ( 字符串角标越界异常)

1. package W;

2. /*

3. * String类的异常演示

4. * String字符串在获取某个字符时，会用到字符的索引，当访问字符串中的字符时

5. * 如果字符的索引不存在，则会发生StringIndex0utOfBoundsException（字符串角标越界异常)

6. */

7. public class Example6 {

8. public static void main(String[] args) {

9. //声明一个字符串

10. String s="abcde12345";

11. System.out.println( s.charAt(10) );

12. }

13. }

 运行结果如下：

2、StringBuffer类 

由于字符事是常量，因此一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符事。为了便于对字符串进行修改，在JDK中提供了一个StringBuffer类(也称字符事缓冲区)，StringBuffer和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或副除字符时，并不会产生新的StringBuffcr对象

针对添加和删除字符的操作，StringBuffer类提供了一系列的方法，具体如下表所示

1. /*

2. * stringbuffer的构造方法

3. * public stringBuffer（）空参数构造方法

4. * public stringBuffer(string data)创建带有内容的字符串缓冲区

5. *

6. * stringbuffer类的常用方法

7. * public stringBuffer append(string str)向字符串缓冲区的末尾添加数据，返回当前的stringBuffer对象自身

8. * public stringBuffer insert（int index，string str）向字符串缓冲区指定位置上，插入指定数据

9. * public stringBuffer delete(int start,int end)删除字符串缓冲区指定范围内的数据

10. * public stringBuffer deleteCharAt(int index)删除字符串缓冲区内指定位置上的数据

11. * public int length（）获取字符串缓冲区的长度

12. * public stringBuffer replace（int start，int end,string str)替换字符串缓冲区指定范围内的字符串

13. * public stringBuffer setcharAt(int index,char ch)替换字符串缓冲区指定位置上的字符

14. * public stringBuffer reverse()字符串缓冲区数据翻转方法

15. */

16. public class Test1{

17. public static void main(String[] args) {

18. System.out.println("1、添加----------------");

19. add();

20. System.out.println("2、删除----------------");

21. remove();

22. System.out.println("3、修改----------------");

23. alter();

24. }

25. public static void add() {

26. //定义一个字符串缓冲区

27. StringBuffer sb=new StringBuffer();

28. //向缓冲区的末尾添加指定字符串

29. sb.append("abcdefg");

30. System.out.println("append添加数据后的结果："+sb);

31. //向缓冲区指定位置插入字符串

32. sb.insert(2, "123");

33. System.out.println("插入数据后的结果:"+sb);

34. }

35. public static void remove() {

36. //定义一个字符串缓冲区对象

37. StringBuffer sb=new StringBuffer("abcdefg");

38. //删除字符串缓冲区指定范围内的数据

39. sb.delete(1, 5);//不包含结尾位置元素

40. System.out.println("删除指定范围数据后的结果："+sb);

41. //删除字符串缓冲区指定位置上的字符

42. sb.deleteCharAt(2);

43. System.out.println("删除指定位置数据后的结果："+sb);

44. //清除字符串缓冲区

45. sb.delete(0, sb.length());

46. System.out.println("清除缓冲区数据后的结果："+sb);

48. }

49. public static void alter() {

50. //定义一个字符串缓冲区对象

51. StringBuffer sb=new StringBuffer("abcdef");

52. //修改指定位置的字符

53. sb.setCharAt(1, 'p');

54. System.out.println("修改指定位置数据后的结果"+sb);

55. //修改指定范围内的数据

56. sb.replace(1, 3, "qq");

57. System.out.println("替换指定范围内字符串的结果"+sb);

58. //字符串缓冲区数据翻转

59. System.out.println("字符串缓冲区数据翻转后的结果"+sb.reverse());

60. }

61. }

 运行结果如下：

 案例：

1. /*

2. * 记录一个子串在整串中出现的次数

3. * 思路：

4. * 1.定义一个整串，定义一个子串

5. * 2.获取子串在整串中出现的次数

6. */

7. public class Test1{

8. public static void main(String[] args) {

9. //1.定义一个整串，定义一个子串

10. String str = "nbaernbatnbaynbauinbapnba";//整串

11. String key = "nba";//子串

12. //2.获取子串在整串中出现的次数

13. int count = getKeyStringCount(str,key);

14. System.out.println("count="+count);

16. }

17. //获取子串在整串中出现的次数

18. public static int getKeyStringCount(String str, String key) {

19. //定义计数器，用来记录出现的次数

20. int count = 0;

21. //如果整串中不包含子串，则直接返回count

22. if(!str.contains(key)) {

23. return count;

24. }

25. //定义变量，用来记录key出现的位置

26. int index = 0;

27. /*

28. * 1.查找子串在整串中出现的位置

29. * 2.将出现的位置记录在index变量中

30. */

31. while((index = str.indexOf(key)) != -1) {

32. //子串出现次数累加

33. count++;

34. //截取整串，从子串出现的位置后面开始，到整串末尾

35. str = str.substring(index + key.length());

36. }

37. return count;

38. }

39. }

运行结果如下：

5.2System类和Runtime类

1、System类

System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的,因此，想要引用这些属性和方法，直接使用System类调用即可。

System类的常用方法

1. import java.util.Set;

2. /*

3. * System类的方法

4. * public static Properties getProperties()

5. * 方法用于获取当前系统的全部属性，该方法会返回一个Properties类型的容器

6. * 其中封装了系统的所有属性，这些属性是以”属性名=属性值“的形式存在的

7. * public static String getProperty(String key)

8. * 获取指定键(属性名)所对应的系统属性值

9. */

10. public class TrigonometricFunction{

11. public static void main(String[] args) {

12. //获取当前系统属性

13. Properties properties = System.getProperties();

14. System.out.println(properties);

16. //获取所有系统属性的key(属性名)，返回Set对象

17. Set<String> PropertyNames = properties.stringPropertyNames();

18. for(String key : PropertyNames) {

19. //获取当前键key(属性名)所对应的值(属性值)

20. String value = System.getProperty(key);

21. System.out.println(key +"--->"+value);

23. }

24. }

25. }

 运行结果如下：

• currentTTimeMillis（）

currentTTimeMillis（）方法 返回一个long类型的值，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，单位是毫秒，通常也将该值称作时间数

1. 第二个:/*

2. * public static long currentTimeMillis()

3. * 方法返回一个long类型的值，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，单位是毫秒，通常也将该值称作时间戳

4. */

5. public class TrigonometricFunction{

6. public static void main(String[] args) {

7. //计算程序在进行求和操作时所消耗的时间

9. //计算程序在进行求和操作时所消耗的事件

10. long startTime = System.currentTimeMillis();

11. int sum =0;

12. for (int i=0;i < 100000000; i++) {

13. sum+= i;

14. }

15. //循环结束后的当前时间

16. long endTime =System.currentTimeMillis();

17. System.out.println("程序运行的时间为："+ (endTime - startTime) + "毫秒");

18. }

19. }

 运行结果如下：

• arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
• arrayoopy0方法用于将一个数组中的元素快速拷贝到另一个数组。其中的参数具体作用如下:

src;表示源数推
dest，来示目标数组。
srcPos，表示源数组中持贝元素的起始位置
destPos;表示揭贝到目标数组的起始位置。
length，表示拷贝元素的个数

1. /*

2. * arraycopy(Object src,int srcPos,Object dest,int destpos,int length)

3. * arraycopy()方法用于将一个数组中的元素快速拷贝到另一个数组。其中的参数具体作用如下:

4. * src:表示源数组。

5. *dest:表示目标数组。

6. *srcPos:表示源数组中拷贝元素的起始位置destPos:表示拷贝到目标数组的起始位置

7. *lenqth: 表示拷贝元素的个数。

8. */

10. public class Test2{

11. public static void main(String[] args) {

12. int[] fromArray ={101,102,103,104,105,106}; //源数组

13. int[] toArray ={201,202,203,204,205,206,207}; //目标数组

14. //拷贝数组元素，从fromArray数组2角标位置开始，拷贝4个素，到toArray数组3角标位置

15. System.arraycopy(fromArray,2,toArray,3,4);

16. //打印toArray数组中的元素

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

18. System.out.println(i+":" + toArray[i]);

19. }

20. }

21. }

运行结果如下：

2、Runtime类

Runtime类用于表示虚拟机运行时的状态，它用于封装JVM虚拟机进程。每次使用java命令启动虚拟机都对应一个Runtime实例，并且只有一个实例，因此该类采用单例模式进行设计，对象不可以直接实例化。

若想在程序中获得一个Runtime实例，只能通过以下方式:
Runtime run = Runtime .getRuntime():

 由于Runtime类封装了虚拟机进程，因此，在程序中通常会通过该类的实例对象获取当前寻虚拟的相关信息

1. /*

2. * Runtime类的使用

3. * public int availableProcessors()想Java虚拟机返回可以处理器的数目

4. * public long freeMemory()返回Java虚拟机中的空闲内存里

5. * public long maxMemory()返回Java虚拟机试图使用的最大内存量

6. * public static Runtime getRuntime()返回与当前Java应用程序相关的运行时对象

7. */

8. public class Test2{

9. public static void main(String[] args) {

10. //获取Runtime类对象

11. Runtime rt = Runtime.getRuntime();

12. System.out.println("处理器的个数:"+rt.availableProcessors()+"个");

13. System.out.println("空闲内容数量："+rt.freeMemory()/1024/1024+"M");

14. System.out.println("最大可用内存数量:"+rt.maxMemory()/1024/1024+"M");

15. }

16. }

运行结果如下：

Runtime类中提供了一个exec（）方法，该方法用于执行一个dos命令，从而实现和在命令窗口中输入dos命令同样的效果

1. /*

2. * Runtime类中提供了一个exec()方法，该方法用于执行一个dos命令，从而实现和在命令行窗口中输入dos命令同样的效果

3. */

4. import java.io.IOException;

5. public class Test2{

6. public static void main(String[] args) throws IOException {

7. //获取Runtime类对象

8. Runtime rt = Runtime.getRuntime();

9. rt.exec("notepad.exe");//调用exec()方法，会自动打开一个记事本

10. }

11. }

1. /*

2. * 打开的记事本并在3秒后自动关闭

3. * public Process exec(String command)在单独的进程中执行指定的字符串命令

4. */

5. public class Test2{

6. public static void main(String[] args) throws IOException, InterruptedException {

7. //获取Runtime类对象

8. Runtime rt = Runtime.getRuntime();

10. //得到一个表示进程的procss对象

11. Process process = rt.exec("notepad.exe");

12. Thread.sleep(3000);//程序休眠3秒

13. process.destroy();//杀掉进程

14. }

15. }

 5.3Math类和Random类

1、Math类

Math类是数学操作类，提供了一系列用于数学运算的静态方法，包括求绝对值、三角函数等。Math类中有两个静态常量PI和E，分别代表数学常量π和e。
由于Math类比较简单，因此初学者可以通过查看API文档来学习Math类的具体用法。

1. /*

2. * Math类中的常用方法

3. * public static int abs(int a)返回参数的绝对值

4. * public static double cell(double a)返回大于参数的最小的整数

5. * public static double floor(double a)返回小于参数的最大的整数

6. * public static long round(double a)四舍五入

7. * public static float max(float a,float b)返回两个数的较大值

8. * public static double min(double a, double b)返回两个数的较小值

9. * public static double random()返回一个大于等于0.0小于1.0的随机小数

10. */

11. public class Test2{

12. public static void main(String[] args) {

13. System.out.println("计算绝对值后的结果："+Math.abs(-1));

14. System.out.println("求大于参数的最小整数："+Math.ceil(5.6));

15. System.out.println("求小于参数的最大的整数："+ Math.floor(-4.2));

16. System.out.println("对小数进行四舍五入后的结果："+Math.round(-4.6));

17. System.out.println("求两个数的最大值："+ Math.max(2.1, -2.1));

18. System.out.println("求两个数的最大值："+ Math.min(2.1, -2.1));

19. System.out.println("生成一个大于等于小于1.0的随机值"+Math.random());

20. }

21. }

运行结果如下：

 2、Random类

• 在JDK的java.util包中有一个Random类，它可以在指定的取值范围内随机产生数字。在Random类中提供了两个构造方法，具体如下表所示。

• 表中列举了Random类的两个构造方法，其中第一个构造方法是无参的，通过它创建的Random实例对象每次使用的种子是随机的，因此每个对象所产生的随机数不同。如果希望创建的多个Random实例对象产生相同序列的随机数，象时调用第二个构造方法，传入相同的种子即可

第一个构造方法

1. import java.util.Random;

2. /*

3. * 使用构造方法Rundom（）产生随机数

4. * public int nextInt(int n）0-n之间的随机整数，包含0，不包含n

5. */

7. public class Test1 {//创建类

9. public static void main(String[] args) {//主方法

10. Random r=new Random();

11. //随机产生10个[0,100]之间的整数

12. for(int i=0;i<10;i++) {

13. System.out.println(r.nextInt(100));

14. }

15. }

16. }

 运行结果如下：

第二个构造方法

1. import java.util.Random;

2. /*

3. * 使用构造方法Rsndom（long seed）产生随机数

4. */

5. public class Test2 {

7. public static void main(String[] args) {

8. Random r=new Random(13);

9. //随机产生10个[0,100]之间的整数

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

11. System.out.println(r.nextInt(100));

12. }

13. }

14. }

 运行结果如下：

 相对于Math的random()方法而言，Random类提供了更多的方法来生成各种伪随机数，不仅可以生成整数类型的随机数，还可以生成浮点类型的随机数，表中列举了Random类中的常用方法

表中，列出了Random类常用的方法，其中，Random类的nextDouble()方法返回的是0.0和1.0之间double类型的值，nextFloat()方法返回的是0.0和1.0之间float类型的值，nextint(int n)返回的是0《包括)和指定值n(不包括)之间的值

1. /*

2. * Random类中的常用方法

3. * public float nexFloat()随机生成0.0 -1.0之间的float小数

4. * public double nextDouble()随机生成0.0 -1.0之间的double小数

5. */

6. public class Test1 {//创建类

8. public static void main(String[] args) {//主方法

9. Random r1=new Random();

10. System.out.println("产生float类型随机数"+r1.nextFloat());

11. System.out.println("产生0-100之间int类型随机数"+r1.nextInt(100));

12. System.out.println("产生double类型随机数"+r1.nextDouble());

13. }

14. }

运行结果如下：

5.4 包装类

在Java中，很多类的方法都需要接收引用类型的对象，此时就无法将个基本数据类型的值传入。为了解决这样的问题，JDK中提供了一系列的包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。在Java中，每种基本类型都有对应的包装类，具体如下表所示。

表中，列举了8种基本数据类型及其对应的包装类。其中，除了integer和character类，其它包装类的名称和基本数据类型的名称一致，只是类名的第一个字母需要大写。
包装类和基本数据类型在进行转换时，引入了装箱和拆箱的概念，其中装箱是指将基本数据类型的值转为引用数据类型，反之，拆箱是指将引用数据类型的对象转为基本数据类型。

1. /*

2. * 装箱：装箱是指将基本数据类型的值转换为引用数据类型

3. *

4. * 通过构造方法，完成装箱操作

5. * int-->Integer

6. * Integer(int n)

7. */

8. public class TrigonometricFunction{

9. public static void main(String[] args) {

10. int a = 20;

11. Integer in = new Integer(a);

12. System.out.println(in);

13. }

14. }

运行结果如下：

1. /*

2. * 拆箱：拆箱是指将引用数据类型的对象转为基本数据类型

3. *

4. * Integer类的方法

5. * public int intValue() 以int类型返回该Integer的值

6. */

7. public class TrigonometricFunction{

8. public static void main(String[] args) {

9. Integer num = new Integer(20);

10. int a= 10;

11. int sum = num.intValue() +a;

12. System.out.println("sum="+sum);

14. }

15. }

 运行结果如下：

Integer类除了具有object类的所有方法外，还有一些特有的方法，如下表所示

 

列举了Integer的常用方法，其中的intValue()方法可以将Integer类型的值转为int类型，这个方法可以用来进行拆箱操作

1. /*

2. * 通过一个案例来演示parseInt()方法的使用，该案例实现了在屏幕上打印”*“矩形，其中宽和高分别设为20和10

3. *

4. * Integer类得到方法：

5. * public static int parInt(String s)将字符串整数，解析成int类型

6. * StringBuffer的方法：

7. * public String toString() 获取字符串缓冲区的内容，以字符串形式返回

8. */

9. public class TrigonometricFunction{

10. public static void main(String[] args) {

11. int w = Integer.parseInt("20");

12. int h = Integer.parseInt("10");

13. for(int i = 0; i<h; i++) {//行数

14. StringBuffer sb = new StringBuffer() ;

15. for(int j = 0; j < w;j++) {

16. sb.append("*");

17. }

18. System.out.println(sb.toString());

19. }

20. }

21. }

 运行结果如下：

案例篇 字符串排序程序设计

1. /*

2. * 字符串排序程序

3. */

5. public class TrigonometricFunction{

6. private static final Object[] num_arr = null;

7. public static void main(String args[]) {

8. String numStr = "20 78 9 -7 88 36 29";

9. System.out.println(numStr);

10. //调用方法，实现得到一个有小到大的字符串

11. numStr = sortStringNumber(numStr);

12. System.out.println(numStr);

13. }

14. //返回一个到一个由小到大的字符串"-7 9 20 29 36 78 88"

15. public static String sortStringNumber(String numStr) {

16. //1.将字符串变成字符串数组

17. String[] str_arr = numStr.split(" ");

18. //2.将字符串数组变成int数组

19. int[] num_arr = toIntArray(str_arr);

20. //3.对int数组元素排序

21. Arrays.sort(num_arr);

22. //4.将排序后的int数组变成String

23. String temp = arrayToString(num_arr);

24. return temp;

25. }

27. //将int数组转换成String

28. public static String arrayToString(int[] num_arr) {

29. StringBuffer sb = new StringBuffer();

30. //通过循环，得到每一个int元素

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

32. //判断当前元素，是否为数组最后一个元素

33. if(i == num_arr.length -1) {

34. sb.append(num_arr[i]);

35. }else {

36. //不是最后一个元素

37. sb.append(num_arr[i]+" ");

38. }

39. }

40. return sb.toString();

41. }

42. //将String数组转换成int数组

43. public static int[] toIntArray(String[] str_arr) {

44. //创建int数组

45. int[] arr = new int[str_arr.length];

46. //把String数组元素转换成int元素，存储到int数组中

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

48. //得到每一个字符串str_arr[i]

49. //把字符串数字转换成int类型 Integer.parseInt(String str)

50. arr[i] = Integer.parseInt(str_arr[i]);

51. }

52. return arr;

54. }

55. }

 运行结果如下：

 5.5 JDK型特性——switch语句支持字符串类型

第2章讲解switch条件语句时，演示了switch语句表达式中接收int类型的例子。在JDK7中，switch语句的表达式增加了对字符串类型的支持由于字符串的操作在编程中使用频繁，这个新特性的出现为Java编程带来了便利。

1. /*

2. * 在JDK7中，switch语句的表达式增加了对字符串类型的支持

3. */

4. public class TrigonometricFunction{

5. public static void main(String[] args) {

6. String week = "Friday";

7. switch(week) {

8. case"Monday":

9. System.out.println("星期一");

10. break;

11. case"Tuesday":

12. System.out.println("星期二");

13. break;

14. case"Wednesday":

15. System.out.println("星期三");

16. break;

17. case"Thursday":

18. System.out.println("星期四");

19. break;

20. case"Friday":

21. System.out.println("星期五");

22. break;

23. case"Sturday":

24. System.out.println("星期六");

25. break;

26. case"Sunday":

27. System.out.println("星期天");

28. break;

29. default:

30. System.out.println("您输入有误...");

32. }

33. }

34. }

运行结果如下：