首页  思维导图  详情

java从入门到精通

2023-06-10 00:14:58   36  举报





AI智能生成

云玩家的思维导图

Java

作者其他创作

大纲/内容

初识java

java简介

Java是一种面向对象的编程语言，由Sun Microsystems于1995年发布。Java设计的初衷是为了开发可移植、高性能的应用程序。Java代码可以在不同的操作系统上运行，包括Windows、Linux、Mac等。

java语言的特征

简单性、面向对象、分布性、编译和解释性、稳健性、安全性、可移植性、高性能、多线索性、动态性。

搭建环境

一、java安装包下载 1.1官网下载安装包：下载地址https://www.oracle.com/technetwork/java/javase/downloads/index.html二、环境配置 2.1电脑快捷搜索“环境变量”2.2新建JAVA_HOME 变量名：JAVA_HOME，变量值：java安装目录 填好信息，点击“确定”按钮   2.2继续新建CLASSPATH 2.3找到path，添加%JAVA_HOME%\bin和%JAVA_HOME%jre\bin                                                                                                                                      三、验证java是否安装成功：winR+cmd进入小黑窗，输入：java -version回车，有java版本号显示就是安装成功了

1.java_home

熟悉eclipse开发工具

熟悉eclipse

使用eclipse

eclipse创建Java项目 1.首先我们需要打开eclipse软件，选择创建好项目的地址，后点Launch后登录。

之后找到左上角的file选项卡，点击一下依次选择new-Java project选项

之后打开一个新建页面，在里面我们找到project name，在里面填写我们的Java项目名称，我选择的是JavaSE-11,然后直接选择finish即可完成创建。

创建后我们就会在左侧看到我们刚刚创建的项目了，点击展开找到里面的sec选项，在其上面选择new-class。

看到创建新class页面后，在里面找到name输入类名（大写字母开头），下方箭头所示处记得勾选上，然后点击finish即可完成创建。

程序调试

java语言基础

java主类结构

包声明（可选）：声明该Java文件所在的包。 导入其他类（可选）：在类中导入其他需要使用的类。 类声明：包含类的名称和类体（大括号中的所有内容）。 主方法（必需）：Java程序的入口点，程序从这里开始执行。 以下是Java主类结构的示例代码

package com.example; import java.util.Scanner; public class Main {    public static void main(String[] args) {       Scanner scanner = new Scanner(System.in);       System.out.println("请输入你的名字：");       String name = scanner.nextLine();       System.out.println("你好，" + name + "！");    } }

基本数据类型

基本数据类型：整数型，字符型，布尔型 1.整数型又分为:整数类型（byte，short,int，long);浮点型（float,double)。 2.字符类型（char）用于存储单个字符，占用16位（两个字节）的内存空间。 3.布尔型：通过boolean来定义布尔型变量，只有ture和flase两个值，分别代表“真”和“假”。

变量与常量

1.标识符是用来标识类名，变量名，方法名，数组名，文件名，的有效字符序列。 2.标识符里面只能含有英文字母，下划线，数字，美元符号。 3.标识符不能用数字开头。 4.关键字不能作为标识符。

在程序运行过程中，一直不会改变的量称为常量，通常也被称为“final 变量” ，常量名通常使用大写字母，但这并不是必须的，很多Java程序员使用大写字母表示常量，是为了清楚的表明正在使用常量

运算符

运算符是一些特殊的符号，主要用于数学函数、一些类型的赋值语句和逻辑比较方面。Java中提供了丰富的运算符，如赋值运算符、算术运算符和比较运算符等。

赋值运算符以符号“=”表示，它是一个双目运算符(又对两个操作数做处理)，其功能是将右边操作数所含的值赋给左边的操作数。

public class Fuzhi {       public static void main(String[] args) {         // TODO Auto-generated method stub         int a,b,c; //声明int变量a,b,c         a = 15; //将15赋值给a         c = a; //将a的值赋给c         b = a + 4; //将a与4的和赋值给变量b，然后给c         c = b;  //将c的值赋给b         System.out.println("c值为: "+c);         System.out.println("b值为："+b);     }   }

Java中的算术运算符主要有+(加号)、-(减号)、*(乘号)、/(除号)、%(求余)，它们都是双目运算符。

自增和自减运算符 自增和自减运算符是单目运算符，可以放在变量之前，也可以放在变量之后。自增和自减运算符的作用是使变量的值增1或减1. a++; ++a a--; --a 符合在前 ++i --i 先计算后使用 符合在后 i++ i-- 先使用后计算

public static void main(String[] args) {//主函数           // TODO 自动生成的方法存根           int a =1;//创整型量初始值为1           System.out.println("a="+a);//输出此时a的值            a++;   // a自增+1           System.out.println("a++="+a);//输出此时a的值            a++;  // a自增+1           System.out.println("a++="+a);// 输出此时a的值            a++;  //a自增+1           System.out.println("a++="+a);// 输出此时a的值            a--;  //a自减-1             System.out.println("a--="+a);// 输出此时a的值          }     }

关系运算符 关系运算符属于双目运算符，用来判断一个操作数与另外一个操作数之间的关系。关系运算符的计算结果都是布尔类型的。

public static void main(String[] args) {//主函数               int num1 =4,num2=7; //声明int型变量num1，并赋值4，声明int型变量num2，并赋值7 int num3 =7;        //声明int型变量num3，并赋值7 System.out.println("numl<num2 的结果:"+(num1 < num2)); //输出numl<num2 的结果的值 System.out.println("numl>num2 的结果:"+(num1 > num2)); //输出numl>num2 的结果的值 System.out.println("num1==num2的结果:"+(num1 ==num2));//输出numl==num2 的结果的值 System.out.println("numl!=num2 的结果:"+(num1 != num2));//输出numl!=num2 的结果的值 System.out.println("numl<=num2的结果:"+(num1 <= num2));//输出numl<=num2 的结果的值  System.out.println("num2>=num3的结果:"+(num2>= num3));//输出numl>=num2 的结果的值    }           }

逻辑运算符 逻辑运算符包括&&(逻辑与)、(逻辑或)、!(逻辑非)。逻辑运算符计算的值必须是 boolean 型数据。在逻辑运算符中，除了“!”是单目运算符之外，其他都是双目运算符。

位运算符 位运算的操作数类型是整形，可以有符号的，也可以是无符号的，位运算符可以分为两大类，位逻辑运算符和位移运算符。

复合赋值运算符 和其他主流编程语言一样，Java 中也有复合赋值运算符。所谓的复合赋值运算符，就是将赋值运算符与其他运算符合并成一个运算符来使用，从而同同时实现两种运算符的效果。

三元运算符 三元运算符的使用格式为:条件式?值1:值2 三元运算符的运算规则为:若条件式的值为true，则整个表达式取值1，否则取值 2 三元运算符等价于if.....else语句

数据类型转换

类型转换是将一个值从一种类型更改为另一种类型的过程。例如，不仅可以将 String类型数据“457”转换为一个数值型，而且可以将任意类型的数据转换为为 String 类型。 隐式转换:不会丢失数据； 显示转换：可能会丢失数据 数据类型转换有两种方式，即隐式转换与显式转换。 从低级类型向高级类型的转换，系统将自动打执行，程序员无须进行任何操作。这种类型的转换称为隐式转换，也可以称为自动转换。下列基本类数据类型会涉及数据转换，不包括逻辑类型。这些类型按精度从“低”到“高”排列的顺序为 byte<short<int<long<float<double。

public static void main(String[] args) {         // TODO Auto-generated method stub     byte mybyte = 27;     int myint = 150;     float myfloat = 452.12f;     char mychar = 10;     double mydouble = 45.46546;     System.out.println("byte型与float型数据进行运算结果为:"+(mybyte+myfloat));     System.out.println("byte型与int型数据进行运算结果为:"+(mybyte*myint));     System.out.println("byte型与char型数据进行运算结果为:"+(mybyte/mychar));     System.out.println("double型与char型数据进行运算结果为:"+(mydouble+mychar));     }   }

代码注释与编码规范

流程控制

复合语句

与c语言及其语言相同，Java语言的复合语句是以一整个块区为单位的语句，所以又称块语句，复合语句由开括号“{”开始，闭括号“}”结束，在前面的学习中我们也接触到了这种复合语句，例如：在定义一个类或方法时，类型就是以“{”与“}”作为开始和结束的标记，方法体同样也是以”{”与”}”作为标记，复合语句中的每个语句都是从上到下被执行，复合语句以整个块为单位能够用在任何一个单位语句可以使用的地方，并且在复合语句中还可以嵌套复合语句

条件语句

条件语句可根据不同的条件执行不同的语句，条件语句包括if语句与switch多分支语句

if条件语句是一个重要的编程语句，用于告诉程序在某个条件成立的情况下执行某段语句，而在例外一种情况下执行例外一种语句

if...else语句：if...else语句是条件语句中最常见的一种形式，它会针对某种条件有选择的做出处理，通常表现为“如果满足某种条件，就进行某种处理，否则就是进行例一种处理”语法如下: if(布尔表达式){ 语句1;}else { 语句 2;

if...else if多分支语句：if...else if多分支语句用来针对某一件事的多种情况进行处理，同常表现为“如果满足某种条件，就进行某种处理，否则如果满足例一种条件则执行例外一种处理”语法如下: if(表达式1){ 语句1 else if(表达式 2){ 语句2 } ........ else if(表达式n){ 语句n }

循环语句

循环语句就是满足一定条件的情况下反复执行某一个操作的语句

while循环语句：while语句也称条件判断语句，它的循环方式利用一个条件来控制是否要继续反复执行这个语句，语法如下： while (条件表达式）{        语句序列 }

do...while循环语句：do...while循环语句与while循环语句类似，它们之间的区别是while语句为先判断条件是否成立在执行循环体，而do...while循环语句则先执行一次循环后，在判断条件是否成立

嵌套while do …while嵌套循环 语句语法如下： 1； while(条件1){ 2 do{ 3 }while（条件2） 4 } 5；

do while嵌套while 1 do{ 2 while(条件1){ 3 } 4 }while(条件2){ 5

do while嵌套for 1 do{ 2 for(3;4;5){ 6 } 7 }while(条件) 8

for 循环语句：for循环是Java程序设计中最有用的循环之一，一个for循环可以用来重复执行某条语句，直到某个条件得到满足，for循环有两种语句，一种是传统的for语句，一种是foreach语句：for(表达式1;表达式2;表达式3) { 语句 }

for嵌套while 1 for(2;3;4){ 5 while(条件){ 6 } 7 } 8

循环控制

控制循环的跳转需要用到 break 和 continue 两个关键字，这两条跳转语句的跳转效果不同，break 是中断循环，continue是直接执行下一次循环。

break语句：break是跳出循环         使用break语句可以跳出switch结构，在循环结构中，同样也可用break语句跳出当前循环体，从而中断当前循环

continue语句：continue是跳过本次循环      是针对break语句的补充，continue不是立即跳出本次循环，而是跳过本次循环，回到循环的条件测试部分，重新开始执行循环，在for循环语句中遇到continue后，首先执行循环的增量部分，然后进行条件测试，在while和do...while循环中，continue语句控制直接回到条件测试部分    语法：1 for(2;3;4){ 5; if(条件){ countinue； } 6; } 7

数组

数组概述

数组是具有相同数据类型的一组数据的集合，在程序设计中引入数组可以更有效地管理和处理数据。数组是具有相同数据类型的一组数据的集合

一维数组

当在程序中需要处理一组数据， 或者传递一组数据时，就可以使用数组实现。

创建一维数组 arr：数组名。length：数组长度属性，返回int值 声明一维数组有两种方式: 数组元素类型 数组名字[]; 数组元素类型[] 数组名字;

初始化一维数组 数组可以与基本数据类型一样进行初始化操作，也就是赋初值。数组的初始化可分别初始化组中的每个元素。数组的初始化有以下方式:1.int arr[]new int[]{1,2,3,5,25}

2.int arr2[]={34,23,12,6} 分配内存 数组名 =new 数组元素的类型[ 行数] [列数]; 设置初始值 数组名= new 数组元素的类型[ ] [ ]{{值1，值2，...},{值1，值2，...},{值1，值2，...}};

二维数组

二维数组常用于表示表，表中的信息以行和列的形式表示，第一个下标代表元素所在的行，第二个下标代表元素所在的列。

创建二维数组 二维数组有两种声明方式: 1.数组元素类型数组名字[][]; 数组元素类型[][]数组名字; 2.声明二维数组: int a[][];

数组的基本操作

Java.util包的Arrays类包含了用来操作数组（如排序和搜索）的各种办法

遍历数组 遍历数组就是获取数组中的每个元素，通常遍历数组都是使用for循环来实现的，遍历一维数组很简单，也很好理解，遍历二维数组需使用双层for循环，通过数组的Length属性可获得数组的长度。

例题:定义二维数组,将二维数组中的元素梯形输出

在遍历数组时使用forech语句遍历二维数组案例

使用sort()方法将数组排序后输出

复制数组 Arrarys 类的copyOf0方法与copyOfRange方法可实现对数组的复制。copyOf方法是复制数组 至指定长度，copyOfRangeO方法则将指定数组的指定长度复制到一个新数组中。 1. copyOf()方法 该方法提供了多种使用方式，用于满足不同类型数组的复制。语法如下: Arrays.copyof(arr,int newlength) y an:要进行复制的数组。

查询数组 查询数组元素（先排序再查询） 语法如下:索引=Arrays.binarySearch(数组名，元素)；

数组排序算法

在程序设计中，经常需要将一组数据进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序等。

排序算法 使用冒泡排序时，排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。 冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面(也就是交换两个元素的位置)，这样较小的元素就像气泡一样从底部上升到顶部。

直接排序 将最大的数放到最后，固定不动，第二次再将最大的数放到最后，固定不动，往后继续。 直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法

int []array= {63,4,24,1,3,15};//创建数组,元素乱序            LT sorter=new LT ();//创建直接排序类的对象            sorter.sort(array);//调用排序对象,对数组排序           }           public void sort(int[]array) {            for(int i=1;i<array.length;i++) {             for(int j=0;j<array.length-i;j++) {              if(array[j]>array[j+1]) {               int temp = array[j];//把第一个元素值保存到临时变量中               array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中               array[j+1]=temp;//把临时变量(第一个元素原值)保存到第二个元素单元中              }             }            }            showArray(array);//输出直接选择排序后的数组元素           }                      public void showArray(int[]array) {            for(int i:array) {//遍历数组             System.out.print(">"+i);//输出每个数组元素值            }            System.out.println();            }           }

反转排序 把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换

public static void main(String[] args) {         // TODO Auto-generated method stub         int[] array = {10,20,30,40,50,60};    //创建一个数组         LT sorter = new LT();//创建反转排序的对象         sorter.sort(array);        //调用排序对象方法，将数组排序     }     public void sort(int[] array) {         System.out.println("数组原有内容：");         showArray(array);        //输出排序前的数组元素         int temp;         int len = array.length;         for(int i = 0;i < len / 2;i++) {             temp = array[i];             array[i] = array[len - 1 - i];             array[len - 1 - i] = temp;         }         System.out.println("数组反转后内容");         showArray(array);        //输出排序后的数组元素     }     public void showArray(int[] array) {         for(int i: array) {        //遍历数组             System.out.print("\t"+ i); //输出每个数组元素值         }         System.out.println();          } }

类和对象

面向对象概述

对象： （1）从这一问题中抽象出对象，这里抽象出的对象为大雁 （2）识别这个对象的属性。对象具备的属性都是静态属性，如大雁有一对翅膀，黑色的羽毛等。 （3）识别这个对象的动态行为，即这只大雁可以进行的动作，如飞行，觅食等，这些行为都是这个对象基于其属性而具有的动作。 （4）识别出这个对象的属性和行为后，这个对象就被定义完成了。然后可以根据这只大雁具有的特性制定这只大雁从北方飞向南方的具体方案。

类： 类就是同一类事物的统称，如果将现实世界中的一个抽象成对象，类就是这类对象的统称，在Java语言中，类对象的行为是以方法的形容来定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。

封装： 面向对象程序设计具有以下特点：封装性，继承性和多态性；（1）封装是面对对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装思想，（2）采用封装的思想保证了类内部数据结构的完整性，使用类的用户不能轻易的直接操作类的数据结构，只能执行类允许公开的数据

继承： （1）类与类之间具有关系，这种关系被称为关联。关联主要描述两个类之间的一般二元关系。（2）继承性主要利用特定对象之间的共同属性。

多态： 继承，父类和子类，其实将父类对象应用于子类的特征就是多态。

类

类是封装对象的属性和行为的载体，而在Java语言中对象的属性以及成员变量的形式存在，对象方法以成员方法的形式存在。

成员变量： 在Java中，对象的属性也称为成员变量，成员变量可以任意类型，整个类中均是成员变量作用范围。

成员方法：  一个成员方法可以有参数，这个参数可以是对象，也可以是基本数据类型的变量，同时成员方法有返回值和不返回值的选择，如果方法需要返回值，可以在方法中使用retnrn关键字，使用这个关键字后，方法的执行将被终止。

权限修饰符： public和protected修饰的类可以由子类访问，如果子类和父类不在同一包中，那么只有修饰符为public的类可以被子类进行访问。如果父类不通过继承产生的子类访问它的成员变量，那么必须使用private声明父类这个成员变量。

局部变量：  局部变量是在方法被执行时创建的，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

局部变量的有效范围：  （1）可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。（2）在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量。

this关键字：  this关键字用于表示本 类当前对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。

类的构造方法

类的构造方法： 在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法，构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调整用构造方法。

//构造方法：调用构造方法创造一个对象  public Bird(String name,String wing,String mouth,String head) {  //传入参数//构造了鸟这个类   this.name = name;   this.wing = wing;   this.mouth = mouth;   this.head = head;     }

静态变量和静态方法

静态变量和静态方法：  由static修饰的变量和方法被称为静态变量和静态方法,有时在处理问题时会需要两个类在同一内存区域共享一个数据，被声明为static的变量和方法被称为静态变量。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和“.”运算符调用静态成员。

静态变量 把共享的变量用static修饰,该变量就是静态变量.可以在本类或其他类使用类名和"."运算符调用静态变量. 语法如下: 类名.静态类成员(static public int 变量)

package cnn;   public class staticdemo { static double PI=3.1415926;//静态变量 static final int i=3;//静态常量 static void method() {//在类中定义静态方法  System.out.println("这是静态方法");//打印   }  public static void main(String[] args) {   // TODO Auto-generated method stub   System.out.println(staticdemo.PI);//调用静态变量   System.out.println(staticdemo.i);   staticdemo.method();  }//调用静态方法   }

总结以下使用static关键字要注意的几点： ：在静态方法中不可使用this关键字。 ：在静态方法中不可以直接调用非静态方法。 ：局部变量不可以使用static关键字声明。 ：主方法必须用static声明。 ：只有内部类可以使用static关键字声明。

类的主方法

在主方法的定义中可以看到其具有以下特点： 主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。 主方法没有返回值。 主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数。 读取主方法的参数组，在项目创建part类，在主方法中编写一下代码，并在Eclipse中设置程序参数。

类的主方法：  主方法是类的入口点，它定义了程序从何处开始，主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。

public class part {  public static void main(String [] args) {//主方法   for(int i=0;i<args.length;i++) {//根据参数个数做循环操作    System.out.println(args[i]);//打印结果   }  } }

运行需要的步骤：

选择自变量，输入参数，每个参数需要空格

运行结果

对象

Java是一门面向对象的程序设计语言，对象是由类实例化而来的，所有问题都通过对象来处理。对象可以通过操作类的属性和方法来解决相应的问题，所以了解对象的产生，操作和消亡是十分必要的。

对象的创建： 对象可以认为是在一类事物中抽象出某个特例，可以通过这个特例来处理这类事物出现的问题。在Java语言中，通过new操作符来创建对象。

对象的引用 在Java语言中，一切都可以看作为对象，但真正的操作标识符实质上是一个引用 类名 对象的引用变量

对<strike>象的销毁 (1)对象引用超过其作用范围,这个对象将被视为垃圾; 例:</strike> { Example e = new example();} [对象e超过其作用范围,将消亡] (2)将对象赋值为null; 例:{Example e = new Example(); e=null;}(当对象被置为null值时,将消亡)

继承、多态、抽象类与接口

类的继承

继承在人类个体之间说的是物质的继承，那么在Java中类与类之间的继承也类似于此，类在继承关系中分为两种，一种是父类，属于是被继承类，一种是子类，属于是继承类，如果某一个类继承了另一个类，那么该类就是子类，被继承的类就是父类。

Java中类的继承需要使用关键字extends 语法：  class Child extends Parent{}//类Child 继承于类 Parent

Java只支持单继承（一个类只有一个父类），子类在继承父类后，创建子类对象的同时也会调用父类的构造方法。 例子： 创建父类Parent   }public class Parent { public Parent (){ System.out.println("调用Parent类构造方法"); }

创建子类Child  class Child extends Parent{    public Child() {     System.out.println("调用Child类构造方法");    }   }

创建demo public class Demo {    public static void main(String[] args) {    new Child();   }   }

object类

在Java中所有的类都直接或间接的继承java.lang.Object类，他是所有类的父类，如果创建一个新类时没有指定继承，那么就默认继承Object类。

Object类中主要包括： clone() finalize() equals() toString()

1.getClass() 它是Object类定义的方法，他会返回对象执行时的Class实例，调用getName()可以获取类的名称 语法： getClass().getname(); 2.toString() 功能：将一个对象返回为字符串形式（一个String实例） 实际运用中多会进行重写，为对象提供一个特定的输出模式，当这个类转换为字符串或字符串连接时，将自动调用重写的toString()方法

public class Student {        String name;  int age;    public Student(String name,int age) {   this.name =name;   this.age = age;     }  public String toString() {   return "我叫"+name+",今年"+age+"岁。";  }  public static void main(String[] args) {   Student s1 =new Student("张三",16);   System.out.println(s1);   Student s2 =new Student("李四",19);   System.out.println(s2);     } }

3.equals() 在Java中有两种比较对象的方式: == 运算符 equals()方法 区别： == 是比较两个对象引用的内存地址 equals()是比较两个对象的实际内容

public class People {    int id; //身份证号  String name; //名字  public People(int id, String name) {   this.id = id;         this.name = name;     }   public boolean equals(Object obj) {//重写 Object 类的 equals()方法    if(this==obj)//如果参数与本类是同一个对象     return true;    if(obj==null)//如果参数是null     return false;    if(getClass()!=obj.getClass())//如果参数与本类类型不同     return false;    People other = (People)obj;//将参数强转成本类对象    if(id!=other.id)//如果两者的身份证号不相等     return false;    return true;   }   public String toString() {//重写 Object 类的 toString()方法    return name;  //只输出名字   }   public static void main(String[]args) {    People p1 = new People(220,"tom");       People p2 = new People(220,"汤姆");       People p3 = new People(330,"张三");    Object o=new Object();    System.out.println(p1+"与"+p2+"是否为同一人？");           System.out.println("equals()方法结果:"+p1.equals(p2));           System.out.println("==运算符的结果:"+(p1==p2));            System.out.println();           System.out.println(p1+"与"+p3+"是否为同一人？");                     System.out.println(p1.equals(p3));          System.out.print(p1+"与"+o+"是否为同一人？");          System.out.println(p1.equals(0));      }     }

对象类型转换

对象类型转换在Java编程中经常遇到，主要包括向上转型和向下转型操作

向上转型： 向上转型可以被理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果，在运行向上转型的过程中，父类的对象无法调用子类独有的属性或者方法

向下转型： 向下转型可以被认为将父类类型的对象转换为子类类型的对象，但是，运行向下转型，如果把一个较抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误，因此向下转型是不安全的

public class Bird { class Pigeon extends Bird{} public static Demo4{  public static void main(String[] args) {   // TODO Auto-generated method stub   Pigeon  bird = new Pigeon();   //某一只鸽子是一只鸟   Pigeon pigeon = bird;         //某一只鸟是一只鸽子 } }

使用instanceof关键字判断对象类型

使用instanceof关键字判断对象类型： 当在程序中执行向下转型操作时，如果父类对象不是子类对象的实例，就会发生classcastException异常，所以在使用向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例，这个判断通常使用instanceof关键字来完成，可以使用instanceof关键字来判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类

class Quadrangle {} class Square extends Quadrangle {} class Circular {}   public class Demo5{     public static void main(String args[]){         Quadrangle q = new Quadrangle();   //四边形对象         Square s = new Square();           //正方形对象         System.out.println(q instanceof Square);//判断四边形是否为正方形的子类         System.out.println(s instanceof Quadrangle);//判断正方形是否为四边形的子类         System.out.println(q instanceof Circular);  //判断正方形是否为圆形的子类 } }

方法的重载

方法的重载就是同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可人

final关键字

final被译为“最后的” “最终的”，fianl是Java语言中的一个关键字，凡是被fianl关键字修饰过的内容都是不可改变的

fianl变量： fianl关键字可用于变量声明，一旦该变量被设定，就不可以在改变该变量的值，通常，有fianl定义的变量为常量

fianl方法 ： （1）修饰的方法不能被重写（2)该类方法不可以被继承；（3）将方法定义为fianl类型，乐意防止子类修改父类的定义与实现方式，同时定义为fianl方法的执行效果要高于非fianl方法（4)在修饰权限中曾经提到过private修饰符，如果一个父类的某个方法被设置为private，子类将五法访问该方法，自然无法覆盖该方法。private final void test() {     …//省略一些程序代码 }

class Dad{     pubilc final void turnOnThe TV(){         System.out.println("爸爸打开了电视"); } } class Baby extebds Dad{     public final void turnOnThe TV(){         System.out.println("宝宝也要打开电视"); }   }

fianl  类： 定义为fianl的类不能被继承，如果希望一个类不被任何类继承，并且不允许其他人对这个类进行任何改动，可以将这个类设置为fianl类

多态

多态: 利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理

public void draw(Square s){    //绘制正方形的方法 }      public void draw(Circular c){  //绘制圆形的方法 }

public class Shope { //图形类  Square extends Shope{}  //正方形类继承图形类  class Cirular extends Shape{}  //圆形类继承圆形类    public static class Demo6{   public static void draw(Shape s) {   //绘制方法    if(s instanceof Square) {        //如果是正方形     System.out.println("绘制正方形");     } else if(s instanceof Circular) {  //如果是圆形     System.out.println("绘制圆形");    }else {     System.out.println("【绘制父类图形");  //如果是其他类型    }  }  public static void main(String[] args) {   // TODO Auto-generated method stub   draw(new Shape());   draw(new Square());   draw(new Circular());    } } }

抽象类与接口

通常可以说四边形具有4条边，或者更具体点，平行四边形是具有对边平行且相等特性的特殊四边形，等腰三角形是其中两条边相等的三角形，这些描述都是合乎情理的，但对于图形对象却不能使用具体的语言进行描述，它有几条边，究竟是什么图形，没有人能说清楚，这种类在Java中被定义为抽象类。

抽象类 在解决实际问题时，一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。回想继承和多态原理，继承树中越是在上方的类越抽象，如鸽子类继承鸟类、鸟类继承动物类等。在多态机制中，并不需要将父类初始化对象，我们需要的只是子类对象，所以在Java语言中设置抽象类不可以实例化对象，因为图形类不能抽象出任何一种具体图形，但它的子类却可以。 Java 中定义抽象类时，需要使用 abstract 关键字，其语法如下:           [权限修饰符] abstract class 类名{ 类体

接口 instanceof 对象名 instanceof 类名        判断对象是否属于该类或其子类 对象名 instanceof 接门名    判断对象是否属于该接口的实现类

包和内部类

java类包

在Java中定义好一个类，通过Java编译器进行编译之后，都会生成一个扩展名为class的文件，当程序的规模逐渐扩大时，就很容易发生类名称冲突的现象。

类名冲突：  Java中每个接口或类都来自不同的类包，无论是JavaAPI中类与接口还是自定义的类与接口，都需要隶属于某个类包，这个类包包含了一些类和接口，如果没有包的存在，管理程序中类的名称将是一件非常麻烦的事，如果程序只有一个类组成，自然不会出现类名重叠的问题，但是随着程序的类的数量增多，难免会出现这一问题。

完整的类途径: 一个完整的类名需要包名与类名的组合，每个类都隶属于一个类包，只要保证同一类包中的类不同名，就可以有效地避免同名类冲突的情况

创建包：  在Eclipse中创建包的步骤如下： （1）在项目的src节点上点击，选择‘新建’/‘包’命令（英语为NEW / Package）

（2）弹出‘新建Java包’（NEW Package）对话框，在‘名称’（Name)文本框输入新建的包名

3.右击新创建的包，选择New,这样新建的类会默认保存在该包中。另外也可以在New java class对话框中指定新建类所在包。         4.语法（注意：Java包的命名规则是全部使用小写字母）

导入包：  1.使用import关键字入包：在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以使用import关键字指定后加上’*‘，这表示可以在程序中使用该包中的所有类

import com.mr*;     //导入com.mr包含中的所有类   import com.mr.Math  //导入com.mr包含Math类

内部类

一个文件中定义两个类，则其中任何一个类都不在另一个类的内部，如果在类中在定义一个类，则将在类中在定义的那个类称为内部类

成员内部类: 1.成员内部简介: 在一个类中使用内部类，可以在内部类中之恶存取所在类的私有成员变量，成员内部类的语法如下：class OuteClass {          //外部类    class InnerClass {   //内部类

在成员内部类可以随意使用外部类的成员变量以及成员方法，尽管这些类成员被修饰为private,尽管成员变量i以及成员方法g（）都在外部类中被修饰为private，但在成员内部类中可以直接使用。

【例8.3】使用成员内部类模拟发动机点火

public class c {  private String brand;  //汽车品牌  public c(String brand) {//汽车类的构造方法，参数为汽车品牌   this.brand=brand; //给汽车品牌赋值  }  class En{   //发动机类（内部类）   String model;  //发动机型号   public En (String model) {  //发动机类的构造方法，参数为发动机型号    this.model=model;   //给发动机型号赋值   }   public void ignite() {   //（发动机）点火方法    System.out.println("发动机"+this.model+"点火");  }  }  public void start() {  //启动（汽车）方法   System.out.println("启动"+this.brand);       }  public static void main(String[] args) {   // TODO Auto-generated method stub     c c = new c("大众朗行");  //创建汽车类对象，并为汽车品牌赋值     c.start();   //汽车类对象调用启动（汽车）方法     //创建发动机类（内部类）对象，并为发动机型号赋值     c.En engine = c.new En("EA211");     engine.ignite();  //发动机类对象调用（发动机）点火方法2    }     }

使用this关键字获取内部与外部类的引用： 如果在外部类中定义的成员变量的成员变量名称相同，可以使用this关键字

public class TSN{  private int x = 7;  //外部类的x  private class Inner{   private int x = 9;  //内部类的x   private void doit() {    int x = 11;  //局部变量x    x++;    this.x++;  //调用内部类的x    TSN.this.x++;  //调用外部类的x   }   } }

匿名内部类： 匿名类是只在创建对象时才会编写类体的一种写法，匿名类的特点是‘现用现学’，其语法如下：new 父类/父接口（）{         子类实现的内容   }；

使用匿名内部类创建一个抽象类的对象

package package2;  abstract class Dog {      String Color;      public abstract void move();      public abstract void call();     }        public class Test2{      public static void main(String[] args) {       // TODO Auto-generated method stub        Dog maomao = new Dog() {  //内部匿名类，补全方法         public void move() {          System.out.println("四腿狂奔");  //输出四腿狂奔         }         public void call() {          System.out.println("嗷呜~");  //输出嗷呜         }        };        maomao.Color = "灰色";        maomao.move();        maomao.call();      }       }

结果

使用匿名内部类应该遵循以下原则： （1）匿名类不能写构造方法 （2）匿名类不能定义静态的成员 （3）如果匿名类创建的对象没有赋值给任何引用变量，会导致该对象用完一次就会被java虚拟机销毁。

异常处理

异常概述

在程序中，异常可能由程序员没有预料到的各种情况产生，也可能由超出了程序员可控范围的环境因素产生。在Java中，这种在程序运行时可能出现的一些错误称为异常。异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。

public class Baulk {  public static void main(String[] args) {   // TODO Auto-generated method stub   int result=3/0;//定义int型变量并赋值   System.out.println(result);//将变量输出  }   }

异常的抛出与捕捉

异常的抛出与捕捉  为了保证程序有效地执行，需要对抛出的异常进行相应的处理。在Java中，如果某个方法抛出异常，既可以在当前方法中进行捕捉，而后处理该异常，也可以将异常向上抛出，交由方法调用者来处理。

抛出异常 异常抛出后，如果不做任何处理，程序就会被终止。

public class Thundering {    public static void main(String[] args) {   // TODO Auto-generated method stub   String str ="lili";//定义字符串   System.out.println(str+"年龄是：");//输出提示信息   int age =Integer.parseInt("20L");//数据类型转换   System.out.println(age);//输出信息  }   }

捕捉异常 Java语言的异常捕获结构由try、catch和finally 三部分组成。其中，try语句块存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。语法如下：

try{ //程序代码块 } catch（Exceptiontype1 e）{ //对 Exceptiontype1 e的处理 } catch（Exceptiontype2 e）{ //对 Exceptiontype2 e的处理 } ...... finally{ //程序代码块 }

完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。但是，在以下4种特殊情况下，finally块不会被执行： 1.在finally语句块中发现了异常 2.在前面的代码中使用了System.exit（）退出程序。 3.程序所在线程死亡。 4.关闭CPU。

public class Baulk {  public static void main(String[] args) {   // TODO Auto-generated method stub   try {  //try语句包含可能出现的异常代码   int result=3/0;//定义int型变量并赋值   System.out.println(result);//将变量输出   }catch(ArithmeticException e){//捕捉异常，算法异常    System.out.println("捕捉到算法异常");//输出异常   }finally {//最后结束    System.out.println("程序结束");//输出语句   }  }   }

public class Thundering {    public static void main(String[] args) {   // TODO Auto-generated method stub   try {//try包含可能出现异常的程序代码   String str ="lili";//定义字符串   System.out.println(str+"年龄是：");//输出提示信息   int age =Integer.parseInt("20L");//数据类型转换   System.out.println(age);//输出信息   int result=3/0;//定义int型变量并赋值   System.out.println(result);//输出变量信息   }catch(ArithmeticException e){//捕捉异常    System.out.println("捕捉到算法异常");//输出异常   }catch(NumberFormatException e) {//捕捉异常2    System.out.println("捕捉到数字格式异常");//输出异常   }finally {//最后结束    System.out.println("程序结束");//输出语句   }  }   }

java常见的异常类

自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需继承Exception类即可自定义异常类。在程序中使用自定义异常类，大体可分为一下几个步骤： （1）创建自定义异常类。 （2）在方法中通过throw关键字抛出异常对象。 （3）如果在当前抛出异常的方法中处理异常，可以使用try—catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。 （4）在出现异常的方法的调用者中捕获并处理异常。

public class MyException extends Exception {//创建自定义异常，继承Exception类  public MyException(String ErrorMessage) {//构造方法   super(ErrorMessage);//父类构造方法  } }

public class Tran {  static  int avg(int number1,int number2) throws MyException {//定义方法，抛出异常   //number1和number2一定要在0~100之间   if(number1<0 ||number2<0) {//判断方法中参数是否满足指定条件    throw new MyException("不可以使用负数");//错误信息   }      if(number1>100 ||number2>100) {//判断方法中参数是否满足指定条件    throw new MyException("数值太大 ");//错误信息   }   return (number1+number2)/2;//将参数平均值返回  }  public static void main(String[] args) {//主方法   // TODO Auto-generated method stub   try {//try处理可能出现的异常代码   int result =avg(2,5);//调用avg方法   System.out.println(result);//将avg方法返回值输出   }catch(MyException e) {//捕捉异常    System.out.println(e);//输出异常信息   }  }   }

在方法中抛出异常

若某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用throws、throw关键字在方法中抛出异常。

hrow关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常使用逗号隔开。 使用throws关键字将异常抛给上一级后，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

public class Shoot {//创建类  static void pop()throws NegativeArraySizeException{   //定义方法并抛出异常 NegativeArraySizeException异常   int[]arr=new int[-3];//创建数组  }  public static void main(String[] args) {//主方法   // TODO Auto-generated method stub   try {//try语句处理异常信息    pop();//调用pop（）方法   }catch(NegativeArraySizeException e) {    System.out.println("pop()方法抛出异常");//输出异常信息   }  }   }

throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常;如果要捕捉throw抛出的异常，则必须使用try-catch语句块。 throw通常用来抛出用户自定义异常。

public class MyException1 extends Exception {//创建自定义异常类  String message;//定义String类型的变量  public MyException1(String err) {//父类方法   message=err;  }  public String getMessage() {//对外提供getmessage方法   return message;  } }

public class Captor {//创建类  static int quotient(int x,int y)throws MyException1{//定义方法抛出异常   if(y<0) {//判断参数是否小于0    throw new MyException1("除数不能是负数");//异常信息输出   }   return x/y;//返回值  }  public static void main(String[] args) {   // TODO Auto-generated method stub   try {//try语句捕捉异常    int result=quotient(3,-1);//调用quotient方法   }catch(MyException1 e) {//处理自定义异常    System.out.println(e.getMessage());//输出异常信息   }catch(ArithmeticException e) {//处理ArrthmeticExceeption异常    System.out.println("除数不能为0");//输出提示信息   }catch(Exception e) {//处理其他异常    System.out.println("程序发生了其他的异常");//输出提示信息   }  }   }

运行时异常

RuntimeException 异常是程运行程中抛出的异常。Java类的每个包中都定义了异常类，所有些类都是Throwable 类的子类。Throwable类派生了两个子类，分别是Exception 类和 Error 类。Error及其子类用来描述Java错误及资耗尽的错误，这类错误比较严重。Exception称为非致命性类，可以通过捕捉处理使程序继续执行。Exception据错误发生的原因分为 RuntimeException异常和除RuntimeException之外的异常。

RuntimeException异常的种类

异常的使用原则

java异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕捉程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时可遵循以下几条原则： 1.在当前方法中使用try-catch语句捕捉异常。 2.一个方法被覆盖时，则覆盖它的方法必须抛出相同的异常或异常的子类。 3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。

字符串

string类

单个字符串可以使用char类型保存，多个字符串组成的文本就需要保存在string对象中。string通常被称为字符串，一个string对象最多可以保存（2^32-1）个字节（占用4GB空间大小）的文本内容

声明字符串 str = "你好";  str = new String("你好");//10和11行输出结果一致  String:指定该变量为字符串类型 str:任意有效的标识符，表字符串变量的名称

创建字符串 1.String(char a[])该方法用一个字符数组ch创建String对象 char[] ch = {'g','o','o','d'};   str = new String(ch);   //两者等价于 String ch = new String("good")

2.String(char a[],int offset,int lenght)该方法提取字符数组c中的一部分创建一个字符串对象。参数offest表示开始截取字符串的位置，lenght表示截取字符串的长度。char[] c = {'s','t','u','d','e','n','t'};   String s = new String(c,1,3);//1为前索引，3为个数   //两者等价于 String s = new String("tud")

3.String(char value)该构造方法可分配一个新的String对象，使其表示字符串数组参数中所有的元素连接的结果 char[] c = {'s','t','u','d','e','n','t'};   String s = new String(c);   //两者等价于 String s = new String("student")

除了以上几种使用String类的构造方法来创建字符串变量外，还可以通过将字符串常量的引用赋值给一个字符串变量来创建字符串，代码如下：String str1,str2; str1 = "we are students" str2 = "we are students"

连接字符串

对于已声明的字符串，可以对其进行相应的操作。连接字符串就是字符操作中较简单的一种。可以对多个字符串进行连接，也可使字符串与其他数据类型进行连接。

连接多个字符串 使用“+”运算符可实现拼接多个字符串的功能，“+”运算符可以连接多个字符串并产生一个String对象。除了“+”运算符，“+=”同样可以实现字符串拼接。 例  使用“+”和“+=”拼接字符串。

例题10.1【先连接对联的上，下联，再分行输出在控制台】

public class join {//创建类    public static void main(String[] args) {//主方法   // TODO 自动生成的方法存根   String s1 = new String("春色绿千里");//声明String对象s1   String s2 = new String("马蹄香万家");//声明String对象s2   String s = s1 + "\n" + s2;//将对象s1,"\n"和对象s2连接并结果赋值给s   System.out.println(s);//将s输出  }   }

连接其他数据类型      字符串也可同其他基本数据类型进行连接。如果将字符串同这些数据类型进行连接，会将这些数据直接转换成字符串。 例  在项目中创建类Link，在主方法中创建数值型变量，实现将字符串与整型、浮点型变量相连的结果输出。

注意：         只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式，所以应谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果。 如果将上例中的输出语句修改为： System.out.println(”我每天花费”+booktime+”小时看书；"+(practice+booktime)+”小时上机练习”)；

由于运算符是有优先级的，圆括号的优先级最高，所以先被执行，再将结果与字符串相连。 注意：

1 字符串在计算公式中的先后顺序会影响运算结果。 2 String a="1”+2+3+4 一“1234"             //碰到字符串后，直接输出后面内容 3 String b= 1+2+3+"4" 一"64”             //碰到字符串前，先做运算，后输出内容 4 String c="1"+(2+3+4)一"19”             //碰到字符串后，先运算括号中的值，后输出内容

获取字符串信息

（1）获取字符串长度 使用string类的length（）方法可获取声明的字符串对象的长度：(str为字符串长度)  str.length(); 获取字符串的长度：

例如，定义一个字符串num，使用length)方法获取其长度。代码如下： String num ="12345 67890”; int size = num.length(); 将size输出，得出的结果就是： 11

（2）字符串查找 String类提供了两种查找字符串的方法，即indexO方法（）与lastIndexOf()方法 1.indexOf(String s):该方法用于返回参数字符串s在指定字符串中第一次出现的索引位置 str.indexOf(substr)  str：任意字符串对象             sbustr：要搜索的字符串

String str = "we are students"; int size = str.indexOf("a");//变量size的值是3

2.lastindexOf(String str):该方法用于返回指定字符串最后一次出现的索引位置 str.lastindexOf(substr)  str：任意字符串对象             sbustr：要搜索的字符串

public class Test {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = "we are students";//定义字符串str   int size = str.lastIndexOf("");//将空字符串在str中的索引位置赋值给变量size   System.out.println("空字符串在字符串str中的索引位置是："+size);//将变量size输出   System.out.println("字符串str的长度是："+str.length());//将字符串str的长度输出  }   }

（3）获取指定索引位置的字符 使用charAt()方法可将指定索引处的字符返回： str.charAt(int index)  str：任意字符串                  index:整数型，用于指定要返回字符的下标

例题10.4【查看指定索引位置上的字符】

public class Ref {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = "hello word";//定义字符串str   char mychar = str.charAt(6);//将字符串str中索引位置是6的字符返回   System.out.println("字符串str中索引位置是6的字符为："+mychar);//输出信息  }   }

字符串操作

（1）获取子字符串 通过string类的substring（）方法可对字符串进行截取。substring（）方法被两种不同的重载形式，来满足不同的需求。 1，substring（int beginIndex）【前索引，后索引（前含后不含）】该方法返回是从指定的索引位置开始截取直到该字符串结尾的子串 str.substring(int beginIndex)

beginIndex:指定从某一索引处开始截取字符串   代码如下： String str = "hello word";   String substr = str.substring(3);

2、substring(int beginIndex,int endIndex)：  该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。 substring(int beginIndex,int endIndex)

beginIndex:开始截取子字符串的索引位置             endIndex:子字符串在整个字符串中的结束位置

例题10.5【《将进酒》的作者是谁】

public class Subs {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = "《将进酒》:李白(唐)";//定义的字符串   String substr = str.substring(6,8);//对字符串进行获取   System.out.print("《将进酒》的作者是："+ substr);//输出获取后的字符串  }   }

（2）去除空格 trim()方法返回字符串的副本，忽略前导空格和尾部空格： str.trim()

例题10,6【去掉字符串首，尾的空格】

public class Black {  //创建类   public static void main(String[] args) {//主方法    // TODO Auto-generated method stub    String str = "   java  class   ";//定义字符串str    System.out.println("字符串原来的长度："+str.length());    //教案str原来的长度输出    //将str去掉前导空格和尾部空格后的长度输出    System.out.println("去掉空格后的长度："+str.trim().length());   }   }

（3）字符串替换 replace（）方法可实现将指定的字符或字符串替换成新的字符或字符串。 str.replace(CharSequence target,CharSequence replacement)  target:要替换的字符或字符串                replacement：用于替换原来字符串的内容

例题10.7【将单词a替换成A】   public class NewStr {  public static void main(String[] args) {   // TODO Auto-generated method stub   String str = "address";//定义字符串str   String newstr = str.replace("a", "A");   //将str中“a”替换成“A”并返回新字符串newstr   System.out.println(newstr);//输出  }   }

（4） 判断字符串的开始与结尾 startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束，这两个方法的返回值都是Boolean类型。 1，startsWith()方法   该方法用于判断当前字符串对象的前缀是否为参数指定的字符串结束 str.startsWith(String prefix) prefix:指作为前缀的字符串 2，endsWith方法   该方法用于判断当前字符串是否为以给定的字符串结束 str.endsWith(String suffix) suffix:作为后缀的字符串

例题10.8【判断字符串是否以指定的内容开始或结束】

public class StartOrEnd {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String num1 = "22045612";   String num2 = "21304578";   boolean b = num1.startsWith("22");//判断字符串num1是否以22开始   boolean b2 = num2.endsWith("78");//判断字符串num2是否以78结束   System.out.println("字符串num1是以‘22’开始的吗？"+b);   System.out.println("字符串num2是以‘78’结束的吗？"+b2);//输出信息  }   }

判断字符串是否相等         1.对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。         2.即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串，代码如下： String tom = new String("i am a student"); String jerry = new String("i am a student"); boolean b = (tom == jerry);

因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsignorecase()方法。         3.equals()方法         1.如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。语法如下： str.equals(String otherstr)     4.equalsIgnoreCase（）方法

1.忽略了大小写的情况比较两个字符串是否相等，返回结果为Boolean类型。语法如下： str.equalsIgnoreCase（String otherstr）

例题10.9【判断“abc”与“ABC”是否相等】  public class Opinion {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String s1 = new String("abc");   String s2 = new String("ABC");   boolean b = s1.equals(s2);   boolean b2 = s2.equalsIgnoreCase(s2);   System.out.println(s1 + "equals" + s2 + ":" + b);   System.out.println(s1 + "equalsIgnoreCase" + s2 + ":" + b2);  }   }

按字典顺序比较两个字符串         1.语法如下： str.compearTo(String otherstr)   说明：compareTo（）方法只有在equals（）方法返回turn时才返回0.

例题10.10【判断字母b的位置】 public class Wordbook {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = new String("b");   String str2 = new String("a");   String str3 = new String("c");   System.out.println(str + "compareTo" + str2 + ":"   + str.compareTo(str2));   System.out.println(str + "compareTo" + str3 + ":"     + str.compareTo(str3));  } }

7.字母大小写转换         1.toLowerCase()方法【转换小写】 str.toLowerCase()  2.toUpperCase()方法【转换大写】 str.toUpperCase()

例题10.11【字母大小写转换】 public class UpAndLower {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = new String("Oh My God");//创建字符串str   String newstr = str.toLowerCase();//使用toLower方法实行大小写转换   String newstr2 = str.toUpperCase();//使用toUpper方法实行大小写转换   System.out.println(newstr);//将转换后的结果输出   System.out.println(newstr2);  }   }

字符串分割         1.split（）方法 str.split()   2.split(String sign,int limit)方法 str.split(String sign,int limit)

例题10.12【按要求分割】  public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = "192.168.0.1";   String[] firstArray = str.split("\\.");//按照"."进行分割，使用转义字符"\\."   String[] secondArray = str.split("\\.",2);//按照"."进行两次分割，使用转义字符"\\."   System.out.println("str的原值为：["+ str +"]");//输出str原值   System.out.print("全部分割的结果为：");//输出全部分割的结果   for(String a :firstArray) {    System.out.print("["+ a +"]");   }   System.out.println();   System.out.print("分割两次的结果：");//输出分割两次的结果   for(String a : secondArray) {    System.out.print("["+ a +"]");   }   System.out.println();  }   }

格式化字符串

String类的静态format)方法用于创建格式化的字符串。format(方法有两种重载形式。

(1) format(String format,Object...args)     该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。语法如下： str.format(String format,Object…args)

(2) format(Local l,String format,Object...args)1：格式化过程中要应用的语言环境。如果1为null，则不进行本地化。 format:  格式字符串。 args:  格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0。

日期和时间字符串格式化 (1)日期格式化 下面的例子，返回一个月中的天数。实例代码如下： 1 Date date = new Date();                     //创建Date对象date 2 String s =String.format("te", date);        //通过format()方法对date进行格式化

例题10.13【按照格式化输出今天的年，月，日】

import java.util.Date; public class Eval {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Date date = new Date();//创建Date对象date   String year = String.format("%tY", date);//将date进行格式化   String month = String.format("%tB", date);   String day = String.format("%td", date);   System.out.println("今年是："+year + "年");//输出信息   System.out.println("现在是："+month);   System.out.println("今天是："+day + "号");     }   }

时间格式化        使用format0方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等格式化时间的转换符 时间格式化转换符：

例题10.14【按照格式输出当下的时分秒】

import java.util.Date; public class GetDate {  public static void main(String[] args) {   // TODO 自动生成的方法存根   Date date =new Date();//创建Date对象date     String hour = String.format("%tH", date);//将date进行格式化     String minute= String.format("%tM", date);     String second = String.format("%tS", date);     System.out.println("现在是："+hour+"时"+minute +"分"+second + "秒");//输出信息  }   }

格式化常见的日期时间组合  格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常用的如下：

例题10.15【输出当下的年月日】 import java.util.Date; public class DateAndTime {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Date date = new Date();//创建Date对象date   String time = String.format("%tc", date);//将date格式化   String form = String.format("%tF", date);   System.out.println("全部的时间信息是："+ time);//将格式化后的日期时间输出   System.out.println("年-月-日格式"+ form);  }   }

常见类型格式化

例题10.16【使用转换符获取表达式的结果】  public class General {    public static void main(String[] args) {   // TODO 自动生成的方法存根 String str=String.format("%d",400/2);//将结果以十进制格式显示 String str2=String.format("%b",3>5);//将结果以boolean型显示 String str3=String.format("%x",200);//将结果以十六进制显示z System.out.println("400的一半是："+str);//输出格式字符串 System.out.println("3>5正确吗："+str2); System.out.println("200的十六进制数是："+str3);  }  }

使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\d”表示数字9中的任何一个，“d”就是元字符。正则表达式中的元字符及其意义如下：

在正则表达式中，可以使用方括号括起若千个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。例如，reg =“[abc]4”，这样字符串 a4、b4、4 都是和正则表达式匹配的字符串。方括号元字符还可以为其他格式。

在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如，“A*”代表 A 可在字符串中出现 0次或多次。限定修饰符的用法如表下：

例题 【验证Email地址是否”“合法】  代码如下： public class Judge {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";   //定义要匹配e-mail地址的正则表达式   String str1 = "aaa@";//定义要进行验证的字符串   String str2 = "aaaaa";   String str3 = "1111@111ffyu.dfg.com";   if(str1.matches(regex)) {//判断字符串变量的hi发与正则表达式匹配    System.out.println(str1+"是一个合法的E—mail地址格式");   }   if(str2.matches(regex)) {    System.out.println(str2+"是一个合法的E—mail地址格式");   }   if(str3.matches(regex)) {    System.out.println(str3+"是一个合法的E—mail地址格式");   }  }   }

字符串生成器

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大地增加系统开销。而JDK 新增了可变的字符序列 StringBuilder类,大大提高了频繁增加字符串的效率。 —

例题  【效率比拼】 代码如下： public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = "";//创建空字符串   long starTime = System.currentTimeMillis();//定义对字符串执行操作的起始时间   for(int i = 0;i < 10000;i++) {//利用for循环执行10000次操作    str = str + i;//循环追加字符串   }   long endTime = System.currentTimeMillis();//定义字符串操作后的时间   long time = endTime - starTime;//计算字符串执行操作的时间   System.out.println("String消耗时间："+time);//将执行的时间输出   StringBuilder builder = new StringBuilder("");//创建字符串生成器   starTime = System.currentTimeMillis();//更新操作执行的时间   for(int j = 0;j<10000;j++) {//利用for循环进行操作    builder.append(j); //循环追加字符    }   endTime = System.currentTimeMillis();//更新操作后的时间   time = endTime - starTime;//更新追加操作执行的时间   System.out.println("StringBuilder消耗时间："+time);//将操作时间输出  }

1.append()方法 该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的费据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下: append(content) 其中，content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象

2.insert(int offset, arg)方法 该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入 int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下: insert(int offset arg)

arg:将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。向字符串生成器中指定的位置添加字符，代码如下: 1 StringBuilder bf= new StringBuilder("hello")；//创建字符生成器 2 bf.insert(5，"world");//添加至字符生成器的位置及内容 3 System.out.println(bf.toString());//此时输出信息为hello word

3.delete(int start , int end)方法（前删后不删） 移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end-1处的字符。如果不存在这种字符，则一直到序列尾部。如果 stat 等于 end，则不发生任何更改。语法如下: delete(int start , int end) start:将要删除的字符串的起点位置  end:将要删除的字符串的终点位置

删除指定位置的子字符串，代码如下: 1 StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器 2 bf.delete(5,10);//删除的子字符串 3 System.out.preintln(bf.toString());//此时输出的信息为Strinder

常用库类

包装类

Java 是一种面向对象语言，但在 Java 中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java 提出了包装类的概念，它主要是将基本数据类型封装在包装类中，如 int 型的包装类 merer、 boolean 型的包装类 Boolemn 等，这样便可以把这些基本数据类型转换力开多Jva中的包装美及其对应的基本数据类型如下：

一，Integer类   Java.lang包中的integer类，byte类，short类和long类，分别将基本数据类型interesting，byte，short和long封装成一个类，由这些类都是number类的子类，区别就是封装不同的数据类型，其包含的方法基本相同。 integer类在对象包装一个基本数据类型int的值，该类的对象包含int类型的字段。

2.常用方法： Integer类的常用方法如表11.2所示

例题11.1【integer类的常用方法】 public class IntegerDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   int num =  Integer.parseInt("456");//将字符串转换成int类型   Integer iNum = Integer.valueOf("456");//创建一个integer对象   System.out.println("int数据与integer对象的比较："+iNum.equals(num));   String str2 = Integer.toBinaryString(num);//获取数字的二进制表示   String str3 = Integer.toHexString(num);//获取数字的十六进制表示   String str4 = Integer.toOctalString(num);//获取数字的八进制表示   String str5 = Integer.toString(num, 15);//获取数字的十五进制表示   num表要转换的数，15表转换的进制   System.out.println("456的二进制表示为："+str2);   System.out.println("456的二进制表示为："+str3);   System.out.println("456的二进制表示为："+str4);   System.out.println("456的二进制表示为："+str5);  }   }

Integer类提供了以下4个常量: MAXVALUE:表示int类型可取的最大值，即231-1。 MINVALUE:表示int类型可取的最小值，即-23。 SIZE:用来以二进制补码形式表示int值的位数。 TYPE:表示基本类型int的Class 实例。

例题11.2【查看integer类的常量值】    public class GetGon {    public static void main(String[] args) {   // TODO 自动生成的方法存根   int maxint  = Integer.MAX_VALUE;//获取integer类的常量值   int minint = Integer.MIN_VALUE;   int intsize = Integer.SIZE;   System.out.println("int类型可取的最大值是："+maxint);//将常量值输出   System.out.println("int类型可取的最小值是："+minint);   System.out.println("int类型可取的二进制数是："+intsize);    }   }

二、double类Double类和Float 类是对 double、float 基本类型的封装，它们都是Number 类的子类，都是对浮点数进行操作，所以常用方法基本相同，本节将对 Double 类进行讲解。对于Float类，可以参考 Double类的相关内容。 Double 类在对象中包装一个基本类型为 double 的值，每个Double类的对象都包含一个 double类型的字段。此外，该类还提供多个方法，可以将 double 类型转换为 String 类型，将 String 类型转换为 double类型，也提供了其他一些处理 double 类型时有用的常量和方法。

Double 类主要提供了以下常量: MAX_EXPONENT:返回 int 值，表示有限 double变量可能具有的最大指数 MIN EXPONENT:返回int值，表示标准化 double变量可能具有的最小指数 NEGATIVE_INFINITY:返回 double值，表示保存 double 类型的负无穷大值的常量  POSITIVE_INFINITY:返回 double值，表示保存 double类型的正无穷大值的常量

三，Boolean类 Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。此外，此类还为 boolean 类型和String类型的相互转换提供了许多方法,1了处理 boolean 类型时非常有用的其他一些常量和方法。Boolean 类的常用方法如表下： 4

例题11.4【Boolean类的常用方法】 public class BooleanDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Boolean b1 = Boolean.valueOf(true);//创建Boolean对象   Boolean b2 = Boolean.valueOf("ok");   System.out.println("b1:"+b1.booleanValue());   System.out.println("b2:"+b2.booleanValue());    }   }

Boolcan 提供了以下3个常量： TRUE:对应基值ie的 Boolean 对象  FALSEr对应基值lse 的 Boolcan 对象 TYPE:基本类型boolean的Class对象

四，character类   Character 类在对象中包装一个基本类型为 char 的值，该类提供了多种方法，以确定字符的类别(写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作，常用的方法如下：题

例题11.5【character类的常用方法】  public class UpperOrLower {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Character mychar1 = Character.valueOf('A');   Character mychar2 = Character.valueOf('a');   if(Character.isUpperCase(mychar1));//判断是否为大写字母   System.out.println(mychar1+"是大写字母");   System.out.println("转换为小写字母的结果："+Character.toLowerCase(mychar1));   if(Character.isLowerCase(mychar2)) {//判断是否为小写字母    System.out.println(mychar2+"是小写字母");    System.out.println("转换为大写字母的结果："+Character.toUpperCase(mychar2 ));   }     }   } =

五，number类   前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类一Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byte、int、short、long、float 和 double 的方法。例如，doubleValue0方法返回双精度浮点值，floatValue0方法返回单精度浮点值，这些方法如下：

数字处理

一，数字格式  1， 数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。在 Java 中使用 javatextDecimalFormat格式化数字，本节将着重讲解DecimalFormat类。

2，在Java中，没有格式化的数据遵循以下原则: 口如果数据绝对值大于0.001 并且小于 10000000，使以常规小数形式表示。 口如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。 由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在 Jaw中，可以使用DecimalFormat类进行格式化操作。

3，DecimalFormat类是NumberFormat的一个子类用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一”情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中applyPattern0方法来实现数字格式化。

4，当格式化数字时，可在DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照定的特殊字符规则进行匹配。表11.7 列举了格式化模板中的特殊字符及其所代表的含义。

例题11.6【DecimalFormat 类的常用方法】 import java.text.DecimalFormat; public class DecimalFormatSimpleDemo {  static public void SimgleFormat(String pattern,double value) {   DecimalFormat myFormat = new DecimalFormat(pattern);   String output = myFormat.format(value);//将数字进行格式化   System.out.println(value+""+pattern+""+output);  }    static public void UseApplyPatternMethodFormat(String pattern,double value) {   DecimalFormat myFormat = new DecimalFormat();   myFormat.applyPattern(pattern);//调用applypattern方法设置格式化模板   System.out.println(value+""+pattern+""+myFormat.format(value));  }    public static void main(String[] args) {   // TODO 自动生成的方法存根   SimgleFormat("###,###,###",123456.789);//调用静态simgleformat方法   SimgleFormat("00000000.###kg",123456.789);//在数字后加上单位   SimgleFormat("000000.000",123.78);   UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分数形式   UseApplyPatternMethodFormat("###.##",123456.789);//将小数后格式化为两位   UseApplyPatternMethodFormat("0,00\u2030",0.789);//将数字转换为千分数形式  }   }

在DecimalFormat类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字行格式化设置。例如： DecimalFormat myFormat = newDecimalFormat();//实例化decimalFormat类对象 myFormat.setGroupingSize(2);//设置将数字分组的大小 myFormat.setGroupingUsed(false）；//设置是否支持分组

在项目中创建 DecimalMethod类，在类的主方法中调用setGroupingSize0与 setGroupingUsed0方法实现数字的分组： import java.text.DecimalFormat; public class DecimalMethod {    public static void main(String[] args) {   // TODO 自动生成的方法存根   DecimalFormat myFormat = new DecimalFormat();   myFormat.setGroupingSize(2);//将数字分组为2   String output = myFormat.format(123456.789);   System.out.println("将数字以每两个数字分组"+output);   myFormat.setGroupingUsed(false);//设置不允许分组   String output2 = myFormat.format(123456.789);   System.out.println("不允许数字分组"+output2);        }   }

二，Math类   Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便可以使用如下形式调用: Math.数学方法

在 Math 类中，除函数方法外还存在一些常用数学常量，如I、E等。这些数学常量作为Mah的成员变量出现，调用起来也很简单。可以使用如下形式调用， Math.PI Math.E Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。

1.三角函数方法 Math类中包含的三角函数方法如下:  publicstatic double sin(double a):返回角的三角正弦 public static double cos(double a):返回角的三角余弦 public static double tan(double a):返回角的三角正切 public static double asin(double a):返回一个值的反正弦 public static double acos(double a):返回一个值的反余弦 public static double atan(double a):返回一个值的反正切 public static double toRadians(double angdeg):将角度转换为弧度 public static double toDegrees(double angrad):将弧度转换为角度

例题11.7【]在Java代码中进行三角函数运算】  public class TrigonometricFunction {    public static void main(String[] args) {   // TODO 自动生成的方法存根   System.out.println("90度的正弦值："+Math.sin(Math.PI/2));//取90的正弦   System.out.println("0度的余弦值："+Math.cos(0));//取0的余弦   System.out.println("60度的正切值："+Math.tan(Math.PI/3));//取60的正切   System.out.println("2的平方根与2 商的反正弦值："+Math.asin(Math.sqrt(2)/2));   System.out.println("2的平方根与2 商的反正弦值："+Math.acos(Math.sqrt(2)/2));   System.out.println("1的反正切值："+Math.atan(1));//取1的反切值   System.out.println("120度的弧度值："+Math.toRadians(120.0)); //取120的度的弧度值   System.out.println("Π/2的角度值："+Math.toDegrees(Math.PI/2));//取Π/2的角度     }   }

2.指数函数方法 Math类中与指数相关的函数方法如下： publicstatic double exp(doublea):用于获取e的a次方，即取e^2 publicstatic double log(doublea):用于取自然对数，即取Ina的值 publicstaticdoublelog10(doublea):用于取底数为10的a的对数。 public static doublesqrt(doublea):用于取a的平方根，其中a的值不能为负值。 public static double cbrt(doublea):用于取a的立方根。 public static double pow(double adouble b):用于取a的b次方

例题11.8【在Java代码中进行指数函数运算】 public class ExponentFunction {    public static void main(String[] args) {   // TODO 自动生成的方法存根   System.out.println("e的平方值："+Math.exp(2));//取e的2 次方   System.out.println("以e为底2的对数值”"+Math.log(2));//取以e 为底2的对数   System.out.println("以e为底2的对数值”"+Math.log(2));//取以10 为底2的对数   System.out.println("4的平方根值："+Math.sqrt(4));//取4的平方根   System.out.println("8的立方根值："+Math.cbrt(8));//取8的立方根   System.out.println("2的2次方值："+Math.pow(2, 2));//取2的2次方  }   }

3.取整函数方法 在具体的问题中，取整操作使用也很普遍，所以Java在Mah类中添加了数字取整方法。Mahx 中主要包括以下几种取整方法: public static double ceil(double a): 返回大于等于参数的最小整数 public static double floor(double a): 返回小于等于参数的最大整数 public static double rint(double a): 返与参数最接近的整数，如果存在两个同样接近的整数. 则结果取偶数。 public static int round(float a): 将参数加上05 后返与参数最近的整数 public static longround(double a): 将参数加上05 后返与参数最近的整数，然后强制转换为长整型。

例题11.9【各场景下取整函数的运算结果】   public class IntFunction {  public static void main(String[] args) {   // TODO Auto-generated method stub   System.out.println("使用ceil()方法取整："+Math.ceil(5.2));   //返回一个大于等于参数的整数   System.out.println("使用floor()方法取整："+Math.floor(2.5));   //返回一个小于等于参数的整数   System.out.println("使用rint()方法取整："+Math.rint(2.7));   //返回与参数最接近的整数   System.out.println("使用rint()方法取整："+Math.rint(2.5));   //返回与参数最接近的整数   System.out.println("使用round()方法取整："+Math.round(3.4f));   //将参数加上0.5后返回最接近的整数   System.out.println("使用round()方法取整："+Math.round(2.5));   //将参数加上0.5后返回最接近的整数，并强制转换为长整型        }   }

4.取最大值、最小值、绝对值函数方法 在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下: public static double max(double adouble b):取a与b之间的最大值。 publicstaticintmin(intaint b):取a与b之间的最小值，参数为整型。 publicstaticlongmin(longa,longb):取a与b之间的最小值，参数为长整型。 public static float min(float a,float b): 取a与b之间的最小值，参数为单精度浮点型。 public static double min(double a,double b): 取a与b之间的最小值，参数为双精度浮点型 public staticintabs(inta):返回整型参数的绝对值。 public static longabs(longa):返回长整型参数的绝对值。 public static float abs(float a):返回单精度浮点型参数的绝对值。 public static double abs(doublea):返回双精度浮点型参数的绝对值。

例题11.9【取最大值、最小值、绝对值的方法】   public class AnyFunction {  public static void main(String[] args) {   // TODO Auto-generated method stub   System.out.println("4和8较大值："+Math.max(4, 8));   //取两个参数的最大值   System.out.println("4.4和4较小值："+Math.min(4.4, 4));   //取两个参数的最小值   System.out.println("-7的绝对值："+Math.abs(-7));   //取参数的绝对值  }   }

Random类是JDK 中的随机数生成器类，可以通过实例化一个 Random 对象创建一个随机数生器，语法如下: Random r = new Random():

以这种方式实例化对象时，Java 编译器将以系统当前时间作为随机数生成器的种子。因为解时刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两个运行结累的随机数。 用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下: Random r = new Random(seedValue)

Random类对象。  scedValue:随机数生成器的种子。 在Random 类中，提供了获取各种数据类型随机数的方法，下面列举几个常用的方法：  public int nextInt（）:返回一个随机整数。  public int nextInt(int n): 返回大于等于0且小于n 的随机整数。  public long nextLong(): 返回一个随机长整型值。 public boolean nextBoolean(): 返回一个随机布尔型值。 public float nextFloat(): 返回一个随机单精度浮点型值。 public double nextDouble(): 返回一个随机双精度浮点型值。  public double nextGaussian():返回一个概率密度为高斯分布的双精度浮点型值

例题11.11【获取不同的取值范围，不同类型的随机数】   import java.util.Random; public class RandomDemo {  public static void main(String[] args) {   // TODO Auto-generated method stub   Random r = new Random();//实例化一个Random类   //随机产生一个整数   System.out.println("随机产生一个整数："+r.nextInt());   //随机产生一个大于等于0小于10的整数   System.out.println("随机产生一个大于等于0小于10的整数："+r.nextInt(10));   //随机产生一个布尔型的值   System.out.println("随机产生一个布尔型的值："+r.nextBoolean());   //随机产生一个双精度浮点型的值   System.out.println("随机产生一个双精度浮点型的值："+r.nextDouble());   //随机产生一个单精度浮点型的值   System.out.println("随机产生一个单精度浮点型的值："+r.nextFloat());   //随机产生一个概率密度为高斯分布的双精度浮点型的值   System.out.println("随机产生一个概率密度为高斯分布的双精度浮点型的值："+r.nextGaussian());  }   }

四，BigInteger类 1，在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数大公约数以及判断是否为质数等操作。 2，使用 BigInteger类，可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。 例如，将2转换为 Biglnteger 类型，可以使用以下语句进行初始化操作:   Biglnteger twolnstance = new Biglnteger("2");

一旦创建了对象实例，就可以调用 BigInteger 类中的一些方法进行运算操作，包括基本的数学运享和位运算以及一些取相反数、取绝对值等操作。下面列举了 BigInteger 类中常用的几种运算方法

public BigInteger add(BigInteger val): 做加法运算。 public BigInteger subtract(BigInteger va): 做减法运算 public BigInteger multiply(BigInteger val): 做乘法运算 public BigInteger divide(BigInteger val): 做除法运算。 public BigInteger remainder(BigInteger val): 做取余操作。 public BigInteger]] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中lt爱险法的商一个值为商，第二个值为余数。 public BigInteger pow(int exponent): 进行取参数的 exponent 次方操作。 public BigInteger negate0: 取相反数。 public BigInteger shifLef(int n): 将数字左移n位，如果n为负数，做右移操作 public BigInteger shiftRight(int n):将数字右移n位，如果n为负数，做左移操作 public BigInteger and(BigInteger val): 做与操作。 public BigInteger or(Biglnteger val): 做或操作。 public int compareTo(BigInteger val): 做数字比较操作。 public boolean equals(Object x): 当参数 x是 BigInteger 类型的数字并且数值与对象实例的数相等时，返回 true。 public BigInteger min(BigInteger val): 返回较小的数值。 public BigInteger max(BigInteger val): 返回较大的数值 。

例题11.12【使用BigInteger类进行数学运算】 import java.math.BigInteger; public class BigIntegerDemo {  public static void main(String[] args) {   // TODO Auto-generated method stub   //第一个大数字   BigInteger b1 = new BigInteger("987654321987654321");   //第二个大数字   BigInteger b2 = new BigInteger("123456789123456789");   //加法运算   System.out.println("加法操作："+b1.add(b2));   //减法运算   System.out.println("减法操作："+b1.subtract(b2));   //乘法运算   System.out.println("乘法操作："+b1.multiply(b2));   //除法运算   System.out.println("除法操作："+b1.divide(b2));   //取商运算   System.out.println("取商："+b1.divideAndRemainder(b2)[0]);   //取余运算   System.out.println("取余数："+b1.divideAndRemainder(b2)[1]);   //2次方运算   System.out.println("做2次方操作："+b1.pow(2));   //相反数运算   System.out.println("取相反数操作："+b1.negate());  }   }

五，BigDecimal类   BirDecimal 类支持任何精度的定点数，可以用它来精响计货值在BigDecimal类中，常用的两个构造方法如下：

在上述方法中，BigDecimal 类中 divide0方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义如下：

例题11.13【使用BigDecimal类进行数学运算】 import java.math.BigDecimal; import java.math.RoundingMode; public class BigDecimalDemo {  public static void main(String[] args) {   // TODO Auto-generated method stub   //第一个大小数   BigDecimal b1 = new BigDecimal("0.00987654321987654321");   //第二个大小数   BigDecimal b2 = new BigDecimal("0.00123456789123456789");   //加法运算   System.out.println("两个数字相加结果："+b1.add(b2));   //减法运算   System.out.println("两个数字相减结果："+b1.subtract(b2));   //乘法运算   System.out.println("两个数字相乘结果："+b1.multiply(b2));   //除法运算，商小数点后保留9位，并将结果进行四舍五入操作   System.out.println("两个数字相除，保留小数点后9位结果："+b1.divide(b2,9,RoundingMode.HALF_UP));           }   }

system类

1.Svstem类是JDK 中提供的系统类，该类是用 fial 修饰的，所以不允许被承。System 类提供了很多系统层面的操作方法，并且这些方法全部都是静态的。System类提供的较常用方法如表 11.11所示。

一，控制台输出字符   System类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3个静态对象:in、out和err。本书中的代码多次使用了这些对象，最常见的就是 out 对象。

1.不会自动换行的print（)方法  System.out.print("Hello!");  2.可以自动换行的println()方法  System.outprintln("书籍是人类进步的阶梯!");

二，计时  1.System.currentTimeMillis0方法可以获取自1970年1月1日零点至今的毫秒数。虽然Dae也有类似的方法，但代码会比 System 类多，所以System.currentTimeMillis0方法是为获取当前毫最常用的方法。因为该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。

例题11.14【查看执行一万次字符串拼接所消耗的时间】 public class SystemTimeDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   long start = System.currentTimeMillis();//程序开始记录时间   String str = null;//创建null字符串   for(int i = 0;i<10000;i++) {//循环一万次    str +=i;//字符串与循环变量拼接   }   long end = System.currentTimeMillis();//记录循环结束时间   System.out.println("循环用时："+(end-start)+"毫秒");  }   }

scanner类

1.与C语言不同，Java 从控制台中读出用户输入的值，用到的不是一行可以直接使用的代码，而是由一个叫 Scanner 的类来实现的。Scanner 英文直译就是扫描仪，它的用途就和现实生活的扫描仪一样可以把数字化信息流转为人类可识别的文字。控制台输出内容用到了 System.out 就表示向控制台输出Systemin就表示从控制台输入，让Scanner 扫描Systemin就可以获取用户输入的值了。  2.使用Scanner类首先要引入该类，其语法如下:   import iava.util.Scanner;//引入Scanner类

4.使用Scanner类扫描控制台的代码如下: Scanner sc = new Scanner(System.in);

例题11.15【猜数字游戏】 import java.util.Random; import java.util.Scanner; public class ScannerDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Random r = new Random();   int num = r.nextInt(100);//从1~99取值   int input = -1;//记录用户输入的值   Scanner sc = new Scanner(System.in);//扫描器扫描控制台输入   while(true) {    System.out.println("猜一猜随机数是多少？");    input = sc.nextInt();//获取用户输入的一个整数    if(input>num) {//如果大于随机数     System.out.println("你输入的数字大了！");    }else if (input < num) {//如果小于随机数     System.out.println("你输入的数字小了!");    } else if (input == num) {//如果等于随机数     break;//结束循环    }else {     System.out.println("您的输入有误!");    }   }   System.out.println("恭喜你答对了!");   sc.close();//关闭扫描器  }   }

日期时间类

1，date类： Date 类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如表11.14所示。

1,  使用 Date类的第2种构造方法创建一个 Date类的对象，代码如下: long timeMillis=System.currentTimeMillis();  //当前系统时间所经历的毫秒数 Date date = new Date(timeMillis);

例题11.16【获取当前的日期和时间】  import java.util.Date; public class DateDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Date date = new Date();//创建现在的日期   //Date date = new Date(1234567891223L);//创建指定时间后加 L   long value = date.getTime();//获得毫秒数   System.out.println("日期:" + date);   System.out.println("到现在所经历的毫秒数为:"+value);   }   }

2.日期时间格式化          1.DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种: SHORT:完全为数字，如12.13.52或3:30pm。 MEDIUM:较长，如Jan 12,1952。 LONG:更长，如January12,1952或3:30:32pm。 FULL:完全指定，如Tuesday、April12、1952AD或3:3042pm PST         2.可以使用其静态方法getDateInstance(进行创建，语法如下:   DateFormat df = DateFormat.getDatelnstance();

例题11.17【以中文形式打印当前的日期和时间】  import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; public class DateFormatDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   DateFormat df = new SimpleDateFormat("yyyy年MM月dd日EEEEHH时mm分ss秒");   System.out.print("各位观众大家好，现在是");   System.out.print(df.format(new Date()));   System.out.println(",欢迎收看新闻.");  }   }

runtime类

1.Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF MONTH、HOU等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected         2.Calendar 提供了一个类方法 getInstance0，以获得此类型的一个通用的对象。Calendar 类的getInstance0方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下:     Calendar rightNow = Calendar.getlnstance();

说明：         由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getlnstance方法创建其对象外，还可以使用其子类创建对象，例如GregorianCalendar类。  Calendar类提供的常用字段及说明如表9.15所示：

说明：         从上面的表格中可以看到，add方法和roll方法都用来为给定的日历字段添加或减去指定的时间量，它们的主要区别在于使用add方法时会影响大的字段，像数学里加法的进位或错位，而使用roll方法设置的日期字段只是进行增加或减少，不会改变更大的字段。

Runtime类  1.Runtime类是 JDK 提供的运行时类，该类为Ja 提供了与当前运行环境相连接的一个通Java程可以利用设头提的超行环填执行一些简单的操作。Runtime 类不能使用 new 关键字创建看例，只能通过RuntimegetRuntime0方法获取实例。         2.Runtime类的常用方决知表1121所示，本节将重点讲解利用 Runtime 类执行本地命令和查看虚拟机所占内存这两个操作。 —

1.执行本地命令          1.Runtime类提供exec0方法让Java代码可以执行系统的命令，exec0方法有很多重载的形式，例如： Process exec(String command) Process exec(Stringl cmdarray)    2.Proces 类的常用方法如表 11.22 所示，开发可以使用 getlnputStream0方法获取进返回的信息。 command:要执行的系统命令，字符串类型 cmdarray: 要执行的命令和相应的命令参数，字符串数组类型 其实这两个重载方式很类似，如执行“javac hello.java”这行命令，使用第一种重载方式的代码如下: Runtime.getRuntime().exec("javac hello.java"); 使用第二种重载方式的代码如下: String command] = ( "javac","hello.java" ;Runtime.getRuntime().exec(command);

例题11.19【让Java程序执行 Windows 系统的 help 命令】  import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; public class RuntimeExecDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Runtime r = Runtime.getRuntime();//获取本地Runtime对象   try {    Process p =r.exec("help");//执行help命令，获取进程对象    InputStream is = p.getInputStream();//获取进程的字节输入流    BufferedReader br = new BufferedReader(new InputStreamReader(is));    String str = null;//创建null 字符串    while((str = br.readLine()) != null) {//如果字符流中可以获取非空内容     System.out.println(str);//打印获取的内容    }   } catch (IOException e) {    e.printStackTrace();   }  } }

2.查看内存       1.Runtime类可以通过freeMemory0方法查看当前Java虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张

例题11.20【监控虚拟机内存使用情况】   public class MemoryDamo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Runtime r=Runtime.getRuntime();//获取本地Runtime对免   Integer ints[] = new Integer[10000];//创建长度为10000的整型   long before = r.freeMemory();//获取当前空闲内存数   System.out.println("赋值前空闲内存字节数:"+ before);   for (int i = 0, length = ints.length; i < length; i++) {//循环为整型数组赋值    ints[i]= i;//赋值   }   long after = r.freeMemory();//获取当前空闲内存数   System.out.println("赋值后空闲内存字节数:"+after);   System.out.println("数组用掉的内存字节数:"+(before- after));//输出数组用掉的内存量  }   }

子主题