Java从入门到精通思维导图模板_ProcessOn思维导图、流程图

什么是Java语言

Java的应用领域

Java的版本

怎样学好Java

Java API 文档

Java简介

Java语言的特性

JDK下载

在Windows 10系统下搭建JDK环境

搭建Java环境

初识Java

Eclipse简介

下载Eclipse

安装Eclipse的中文语言包

Eclipse的配置与启动

Eclipse工作台

透视图与视图

菜单栏

工具栏

“包资源管理器”视图

“控制台”视图

熟悉Eclipse

创建Java项目

创建Java类文件

使用编译器编写程序代码

运行Java程序

使用Eclipse

程序调试

熟悉Eclipse开发工具

修饰词 class 类名{ 程序代码}

Java主类结构

是整数类型的数据

整数类型

浮点数常量就是在数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。其中，单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。当然，在使用浮点数时也可以在结尾处不加任何的后缀，此时虚拟机会默认为double双精度浮点数。浮点数常量还可以通过指数形式来表示。

浮点类型

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号引起来，它可以是英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。

字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号引起来。一个字符串可以包含一个字符或多个字符，也可以不包含任何字符，即长度为0。

字符类型

布尔常量及布尔型的两个值true和false，该常量用于区分一个事物的真与假。

布尔类型

基本数据类型

标识符：用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。

关键字：关键字又称保留字，是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。在输入代码中彩色字的即为关键字。

标识符和关键字

告诉编译器这个变量的数据类型。

声明变量

在程序运行过程中一直不会改变的量，通常也被称为“final变量”。

声明常量

成员变量：在类体中所声明的变量，成员变量在整个类中都有效。

局部变量：在类的方法体中声明的变量，包括方法的参数。局部变量只在当前代码块中有效。

在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

变量的有效范围

变量与常量

赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量，表中列出了Java中的赋值运算符及用法。在赋值运算符的使用中，需要注意以下几个问题： (1) 在Java中可以通过一条赋值语句对多个变量进行赋值 int.X，Y，z； X=Y=Z=5；//为三个变量同时赋值 intx=y=z=5；//这样写是错误的（2）除了“=”，其它的都是特殊的赋值运算符，以“+=”为例，x += 3就相当于x=x+3，首先会进行加法运算x+3，再将运算结果赋值给变量x。-=、*=、/=、%=赋值运算符都可依此类推在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范在为变量赋值时围小于源类型时，需要进行强制类型转换。然而在使用+=、-=、*=、/=、%= 运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式地声明。

赋值运算符

算术运算符就是用来处理四则运算的符号，这是最简单、最常用的运算符号算术运算符看上去比较简单，也很容易理解，但在实际使用时有很多需要注意的问题，具体如下: (1)在进行自增 (++) 和自减 (--) 的运算时，如果运算符放在操作数的前面则是先进行自增或自减运算，再进行其它运算。反之，如果运算符放在操作数的后面则是先进行其它运算再进行自增或自减运算。 (2)在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数 (3) 在进行取模(%) 运算时，运算结果的正负取决于被模数(%左边的数)的符号，与模数(%右边的数)的符号无关

算术运算符

++a（--a）//表示在使用变量a之前，先计算a的值a++（a--）//表示在使用变量a之后，再计算a的值

自增和自减运算符

比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。== 相等于！= 不等于< 小于> 大于 <= 小于等于 >= 大于等于比较运算符在使用时需要注意一个问题，不能将比较运算符“==”误写成赋值运算符“=”。

比较运算符

&&，与true&&ture==tureture&&false==falsefalse&&false==false两者都为真，结果才是真|，或true||ture==truetrue||false==turefalse||false==false只要有一者为真就是真！，非!true==false!false==ture非真即假非假即真

逻辑运算符

&，按位与两者都为1，结果才是1|，按位或只要有一者为1，结果就为1~，按位取反0变1，1变0^，按位异或两者相同即为0，不同即为1移位操作<<，左移整体左移，空位补0，溢出去掉>>，右移整体右移，正数补0，负数补1，溢出去掉>>>，无符号右移整体右移，空位补0，溢出去掉

位运算符

使用格式：条件式？值1：值2运算规则：若条件式的值为true，则整个表达式取值1，否则取值2

三元运算符

在对一些复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，我们把这种顺序称为运算符的优先级。

运算符优先级

运算符

从低级类型向高级类型的转换，系统自动执行，且不会丢失数据

隐式类型转换

把高精度的变量的值赋给低精度的变量，又称强制类型转换，可能会丢失数据

显式类型转换

数据类型转换

在编写程序时为了使代码与阅读，通常会在实现功能的同时为代码写一些注释。注释是对程序的某个功能或某行代码的解释，说明它是在Java源文件中有效，在编译程序时编译器会忽略这些注射信息，我会将其注释到class字节码文件中去。

Java中的注释有三种类型，具体如下：单行注释：通常用于对程序中的某一行代码进行解释，用符号“//”，“//”后面为被注释的内容。多行注释：顾名思义就是在注释中的内容可以为多行，它以符号“/*”开头，以符号“*/”结尾。文档注释：以“/**”开头，并在注释内容末尾以“*/”结束。

代码注释

（1）Java中的程序代码可分为结构定义语句和功能执行语句。其中结构定义语句用于声明一个类或方法功能执行语句用于实现具体的功能，每条功能执行语句的最后都必须用分号（；）结束。（2） Java语言严格区分大小写。（3）虽然Java没有严格要求，用什么样的格式来编排程序代码，但是出于可读性的考虑，应该让自己编写的程序代码，整齐美观，层次清晰。（4） Java程序中一句连续的字符串不能分开在两行中书写。如果为了便于阅读，想将一个太长的字符串分在两行中书写，可以先将这个字符串分成两个字符串，然后用加号将这两个字符串连起来，在加号处断行。

编码规范

代码注释与编码规范

Java语言基础

复合语句

if语句是指如果满足某种条件，就进行某种处理，其语法格式如下所示:if (条件语句）{ 代码块}上述语法格式中，判断条件是一个布尔值，当值为true时，才会执行{}中的语句。if语句的执行流程如下图所示

if 条件语句

if（表达式）{ 语句1 }else{ 语句2 }if后面“（）”内的表达式必须是Boolean型的。

if...else语句

if（判断条件1）｛执行语句1｝else if（判断条件）｛执行语句2 ｝…else if（判断条件n）｛执行语句n｝else｛执行语句n+1｝

if...else if...else语句

Switch语句也是一种很常见的选择语句。和if条件语句不同，他只能针对某个表达式的值做出判断，从而决定执行哪一段代码。在Switch语句中，使用Switch关键词来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句，Switch语句的基本语法结果如下所示：switch (表达式){case 目标值 1:执行语句 1break;case 目标值 2:执行语句 2break;…………执行语句 n+1break;} 注意:1、条件表达式的返回值类型必须是以下类型之一:int 、byte、 char、short 、string(如果传入其他值，程序会报错。) 2、case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。 3、break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止 switch语句的执行。 4、在一些特殊情况下，多个不同的case值执行一组相同的操作，这时可以不用breakwhile以及do..while循环嵌套

switch 多分支语句

条件语句

while语句和if条件语句有点类似，都是根据条件判断来决定是否执行后面的代码，区别在于，while循环语句会反复的进行条件判断，只要条件成立，｛｝内的执行语句就会执行，直到条件不成立，while循环结束。 While循环语句的语法结构如下所示： while(循环条件) { 执行语句 .......}

while 循环语句

do...while循环语句和while循环语句功能类似。其语句结构如下：do { 执行语句 .........} while(循环条件);

do...while 循环语句

for循环语句是最常用的循环语句，一般用在循环次数已知的情况下，其语法格式如下： for(初始化表达式；循环条件；操作表达式）{ 执行语句 ......} 在上述语法格式中， For后面的（）中包括三部分内容，初始化表达式、循环条件和操作表达式，他们之间用“；”分隔，｛｝中的执行语句为循环体。如果用1表示初始化表达式（从for循环开始带结束只执行一次）、2表达循环条件、3表示操作表达式、4表示循环体，则for循环的执行流程如下： for(1；2；3；){4}第一步，执行1第二步，执行2，如果判断结果为 true，执行第三步，如果判断结果为 false，执行第五步第三步，执行4第四步，执行3，然后重复执行第二步第五步，退出循环

for 循环语句

循环语句

用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。 break：跳出当前循环体while（...） do for{ { { ... ... ... break; break; break; ... ... ...} }while（...）; }div data-t=\"flow\" data-processon-v=\

break 语句

用在循环语句中，它的作用是终止本次循环，执行下一次循环。可以立刻重新开始下一轮循环，而不在循环循环后面的语句。 continue:跳过本次循环while（...） do for{ { { ... ... ... continue; continue; continue; ... ... ...} }while（...）; }

continue 语句

循环控制

流程控制

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。一维数组的创建有两种形式。 1.先声明，再用new关键字进行内存分配声明一维数组有下列两种方式：数组元素类型数组名字[]；数组元素类型[] 数组名字；数组元素类型决定了数组的数据类型，它可以是Java中任意的数据类型，包括简单类型和组合类型。声明一维数组：int arr[] 声明数组后我们还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用它还要为它分配内存空间。在位数组分配内存空间时必须指明数组的长度，格式如下：数组名字=new 数组元素的类型[数组元素的个数] 数组名字：被连接到数组变量的名称。数组元素的个数：指定数组中变量的个数，即数组的长度。为数组分配内存：arr=new int[5] 2. 声明的同时为数组分配内存数组元素的类型数组名=new 数组元素的类型[数组元素的个数]；

是用来存储一组或多组相同类型数据的数据类型在程序中，可以通过“数组名.length”的方式来获取数组的长度，也就是元素的个数。正在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式。类型【】数组名=new类型【】｛元素，元素，……｝；类型【】数组名=｛元素，元素，….｝； 1、每个数组的索引都有一个范围，从0～length-1，在访问数组的元素时，索引不能超过这个范围，否则程序会报错 2、在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常。

数组概述

创建一维数组

初始化一维数组

使用一维数组

一维数组

多维数组可以简单地理解为在数组中的嵌套数组。在程序中比较常见的就是二维数组。二维数组的定义方式:方式一：int【】【】arr=new int【n】【m】特点：元素固定方式二：int【】【】arr=new int【n】【】特点：可以让一维数组储存的元素是可变的方式三：int【】【】arr=｛｛1，2｝，｛3，4，5，6｝，｛7，8，9｝｝；直接把里面的所有元素的都附上二维数组的访问同样也是通过索引去访问的

创建二维数组

初始化二维数组

/* * 随机点名器 * */ import java.security.SecureRandom;import java.util.Scanner;public class Bhs { // 1、存储全班同学的姓名创建一个存储多个同学的姓名的容器（数组） // 键盘录入每个同学的姓名，存储到数组容器中 public static void addStudentName(String[]students) { //键盘录入多个同学姓名存储到容器中 Scanner sc =new Scanner (System.in); for(int i=0;i<students.length;i++){ System.out.println(\"存储第\"+(i + 1)+\"个姓名：\"); students[i]=sc.next(); }} // 2、总览全班同学姓名 public static void printStudentName(String[]students) { //遍历数组，得到每个同学姓名 for(int i=0;i<students.length;i++) { String name =students[i]; System.out.println(\"第\"+(i+1)+\"个学生姓名：\"+name); } } // 3、随机点其中一人 public static String randomStudentName(String[] studrents) { //根据数组产孤独，获取随机数 int index =new SecureRandom().nextInt(studrents.length); //通过随机索引从数组中获取名字 String name =studrents[index]; return name; } public static void main(String[]args) { System.out.println(\"-----随机点名器--------\"); String[] students=new String[3]; addStudentName(students); printStudentName(students); String randomName=randomStudentName(students); System.out.println(\"被点到名字的同学是：\"+randomName); }}

使用二维数组

二维数组

操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数字的遍历。索引思想，操作数组中的元素，赋值还是获取值，都是依赖索引 arr［0］索引思想：操作数组。arr［0］赋值，获取循环：循环的变量，从0开始，每次递增。

遍历数组

填充替换数组元素

对数组进行排序

复制数组

2.binarySearch（Object[] a，int fromlndex，int tolndex，Object key） import java.util.Arrays;//导入java.util.Arrays类public class Job11 {//创建类 public static void main(String[] args) {//主方法 // TODO Auto-generated method stub String str[]=new String[] {\"ab\

查询数组

数组的基本操作

冒泡排序

直接选择排序

反转排序就是以相反的顺序把原有数组的内容重新排序。反转排序的基本思想比较简单，其实现思路是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，依此类推，直到把所有数组元素反转替换。

反转排序

数组排序算法

数组

不能动的部分，这个部分称为“属性”，任何对象都会具备其自身属性，如一个人，其属性有身高、年龄、性别等。

静态部分

对象可执行的动作，这部分称为“行为”，如人的喜怒哀乐、说话、行走等。

动态部分

对象是事物存在的实体。通常会将对象划分为两个部分，即静态部分与动态部分。

对象

封装对象的属性和行为的载体，是同一类事物的统称，具有相同特性和行为的一类事物实体被称为类。如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称。类是构造对象时所依赖的规范，类是时间事物的抽象称呼，而对象则是这个事物对应的实体。类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。不能将一个事物描述成一类事物，如一只鸟不能称为鸟类。

类

封装是面向对象编程的核心思想在面向对象程式设计方法中，封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。采用封装的思想保证了类内部数据结构的完整性，使用类的用户不能轻易的直接操作类的数据结构，只能执行类允许公开的数据，这样就避免了外部操作对内部数据的影响，提高了程序的可维护性。

封装

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重写编写原有类的情况下，对原有类的功能进行扩展。继承不仅增强了代码的复用性、提高开发效率，而且也减少了代码的重复性，还为程序的维护补充提供了便利。

继承

多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其它类继承后，它们可以既有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut”这个单词时，理发师的行为是剪发，演员的行为表现是停止表演，不同的对象，所表现的行为是个一样的。

多态

面向对象概述

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

public class part{//类 private String name;//String类型的成员变量 public String getName() {//name的Getter方法 return name; } public void setName(String name) {//name的Setter方法 this.name=name;//将参数值赋予类中的成员变量 }}

成员变量

在Java语言中，使用成员方法对应于类对象的行为。定义成员方法的语法格式如下：权限修饰符返回值类型方法名（参数类型参数名）{ .... //方法体 return 返回值；}

成员方法

极限修饰符

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。在实际上，方法中的形参也可以作为一个局部变量。局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否者会出现编译错误。

局部变量

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。

在相互不嵌套的作用域中，可以同时声明两个名称和类型相同的局部变量。

但是在相互嵌套的区域中不可以这样声明，如果将区域变量id在方法体的for循环中再次进行定义，编译器将会报错。

局部变量的有效范围

this关键字用来表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。public void setName(String name) {//定义一个setName()方法 this.name=name;//将参数值赋予类中的成员变量 }} this除了可以调用成员变量或成员方法，还可以作为方法的返回值。 public Book getBook{ return this;//返回Book类的本类对象}

this 关键字

1.构造方法的定义在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具体如下: 方法名与类名相同在方法名的前面没有返回值类型的声明在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。2.构造方法的重载与普调方法一样，构造方法也可以重载，在一个类中可以定又多小构遗方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以运过调用不同的构造方法来为不同的属性进行就值。

在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。构造方法的特点：构造方法没有返回值。构造方法的名称要与本类的名称相同。构造方法的定义语法格式：（public ：构造方法修饰符；Book：构造方法的名称）public Book(){..... //构造方法体} 在构造方法中可以为成员变量赋值，这样当实例化一个本类对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。

类的构造方法

由static修饰的变量和方法被称为静态变量和静态方法。被声明为static的变量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和”.“运算符调用静态成员。语法如下：类名.静态类成员静态变量与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等。尽管使用这种方式调用静态成员比较方便，但静态成员同样遵循着public、private和protected修饰符的约束。

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

静态变量和静态方法

主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法的语法如下：public stasti void mian(String args){ .... //方法体} 在主方法的定义中可以看到其具有以下特点：主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。主方法没有返回值。主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数。

类的主方法

在Java中，对象是通过类创建出来的，因此，在程序设计时，最重要的就是类的设计。假设要在程序中描述一个学校所有学生信息，可以先设置一个学生类(Student)，在这个类中定义两个属性name、age分别表示学生的姓名和年龄，定一个方法introduce()表示学生做自我介绍。具体如下：public class Student { String name; //定义一个姓名属性 int age; //定义一个年龄属性 public void introduce() { //方法中打印属性name和age的值 System.out.println(\"大家好，我叫\" + name+ \

对象的创建

用户使用new操作对象符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。

访问对象的属性和范围

真正的操作标识符实质上是一个引用，引用的语法：类名对象的引用变量b d1 =new b();b是类名，d1是引用名，new b对象的实体；

对象的引用

在Java中，当一个对象成为垃圾后仍会占用内存空间，时间一长，就会导致内存空间不足。针对这种情况，Java中引入了垃圾回收机制。一个对象在称为垃圾后会暂时保存内存中，当这样的垃圾堆积到一定程度时，Java虚拟机会启动垃圾回收器将这些垃圾对象从内存中释放。某些对象不是通过new操作符在内存中获取存储空间的，这种对象无法被垃圾回收机制识别。在Java中，提供了一个finalizer()方法

对象的销毁

对象：对象是由类实例化而来的，所有问题都通过对象来处理。对象可以通过操作类的属性和方法来解决相应的问题

类和对象

Java语言中每个类只能继承一个父类extends 继承父类写法与普通写法相同public class 父类类名（）{}子类public class 子类类名 extends 父类类名（）{} 所有类的构造方法第一行都有一个隐藏的“super（）；”作用是在执行该构造方法之前调用其父类构造方法

方法的重写(子类重写父类方法)：返回参数相同，方法名相同，传入参数相同，只有方法体不同在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中下需要对继承的方法进行一些修改，即对父类的方法进行重写。需要注意的是，在子类中重写的方法需要和父类重写的方法具有相同的方法名、参数列表以及返回值类型。方法重写是对父类功能的一些改进，同时也是对父类功能的扩展，而也是多态的一个非常重要的前提就是方法的重写子类重写父类要保证子类方法的权限必须大于或者等于父类方法权限，否则将会报错

类的继承

1.getClass（）方法 getClass（）方法是Object类定义的方法，它会返回对象执行时的Class实力，然后使用此实例调用getName（）方法可以取得类的名称。语法如下：getClass（）.getname（）；可以将 getClass（）方法与toString（）方法联合使用。

2.toString（）方法 toString（）方法的功能是将一个对象返回为字符串形式，它会返回一个String实例。在实际的应用中通常重写toString（）方法，为对象提供一个特定的输出模式。当这个类型转换为字符串或与字符串连接时，将自动用重写的toString（）方法。

3.equals（）方法在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals（）方法。两者的区别在于：“==”比较的是两个对象引用内存地址是否相等，而equals（）方法比较的是两个对象的实际内容。

Object类：所有类的父类，Java类层中的最高层类。

object 类

子类对象赋值给父类引用Animal a=new Dong（）；自动类型转换

向上转型

父类对象赋值给子类引用Dog a=（Dog）new Animal（）；强制类型转换

class Bird {}class Pigeon extends Bird{}public class Demo4 { public static void main(String[] args) { // TODO Auto-generated method stub Bird bird = new Pigeon();//某只鸽子是一只鸟 Pigeon pigeon = (Pigeon) bird;//某只鸟是一只鸽子（要进行强制类型转换） } }

向下转型

对象类型的转换

语法如下：对象名 instanceof 类名对象名 instanceof 类名判断对象是否属于该类或子类对象名 instanceof 类名判断对象是否属于该接口的实现类

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

重载：方法名相同，参数不同方法重载：让方法名相同而形参不同的构造方法同时存在。

与普调方法一样，构造方法也可以重载，在一个类中可以定又多小构遗方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以运过调用不同的构造方法来为不同的属性进行就值。

方法的重载

final修饰变量——不能被改变（常量） final关键字用于变量声明，一旦该变量被设定，就不可以在改变该变量的值，final关键字定义的变量必须在声明时对其进行赋值操作语法：Final double Pi=3.14；

final变量

可以防止子类修改父类的定义与现实方法，执行效率高于非final方法语法：private final void test（）{...//省略一些程序代码} final修饰方法—— 不能被重写

final方法

使用final类可以使该类不被任何类继承，并且不允许其他人对这个类进行任何改动语法：final 类名{} Final修饰类——不能被继承

final类

final关键字

在设计一个方法时，通常希望该方法具备一定的通用性。多态的前提是要有继承，要有方法的重写。我们可以把它理解为一个事物具备的多种形态，称之为多态。比如说一个人，在不同的时期和不同的环境下它所表现出来的状态，或者形态是不一样的。在同一个方法中，参数类型不同而导致出现的运行结果也不同，那就产生出这种多态的现象。在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。接口的引用等于它的一个实现类的对象，这个实现类是可以有不同的子类。它有利于我们程序的扩展性的出现。

多态的类型转换1、将子类对象当中父类对象类型使用的情况，这在Java语言环境中称为“向上转型”2、将子类对象当中父类对象使用时不需要任何显式的声明，需要注意的是，此时不能通过父类变量去调用子类中特有的方法

多态的好处对父类或者接口提供程序的扩展性，坏处能调用子父类的共有属性，不能调有子类的特有属性。

一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。抽象方法修饰符 abstract 返回参数方法名（传入参数）；注释：没有方法体，要用abstract来修饰public abstract void methodName（）；抽象类有抽象方法的类一定是抽象类修饰符 abstract class 类名{} 当父类为抽象类子类为普通类时，要继承父类必须重写父类中的所有方法，不然会报错，或者将子类改为抽象类

抽象类

接口：所有方法都是抽象方法且没有方法体 Java语言中每个类只能继承一个父类，但是每个类可以实现多个接口，所以出现了接口。修饰符 interface 接口名{} 实现 implements Java语言每个类可以实现多个接口修饰符 class 类名 implements 接口1，接口2，接口3，...{} 一个类继承一个父类的同时再实现一个接口：修饰符 class 类名 extends 父类名 implements 接口名{}注释：先继承再实现一个接口可以继承另一个接口：interface intf1{}interface intf2 extends intf1{}//接口继承接口

接口

抽象类与接口

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

编译器不会允许存在同名的类文件，解决这类问题的方法是将这两个类放置在不同的类包中。

类名冲突

1.进入Eclipse时复制文件储存路径，再打开文件管理器粘贴路径就可以之间进入Eclipse所保存文件的文件中。

2.随意点击一个文件，里面的src文件中的是Java文件，bin文件中是class文件

完整的类路径

1.新建一个项目，然后右击src，选择new、Package。

2.弹出“新建Java包”New Java Package对话框，在“名称”Name文本框中输入的包名Package1，然后点击完成Finish.

3.在eclipse中创建类时，可以在新建立的包上右击选择新建new命令，作业新建的类就会保存在该包中。另外还可以在新建类时同时修改包名，就可以创建两个不同的包和类.

创建包

import关键字的语法如下：import com.mr.*; //导入com.mr包中的所有类import com.mr.Math //导入com.mr包中的Math类在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用import关键字指定时在包指定后加上*，这表示可以在程序中使用该包中的所有类。 import关键字除了导入包外，还可以导入静态成员，导入静态成员可以使编程更为方便。

package com.mr;import static java.lang.Math.max;//导入静态成员方法import static java.lang.System.out;//导入静态成员变量public class Test3 { public static void main(String[] args) { // TODO Auto-generated method stub out.println(\"1和4的较大值为：\

导入包

Java类包

成员内部类的语法：class OuterClass{ //外部类 class InnerClass{ //内部类 }} 在成员内部类中可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private。内部类初始化方式与其他类的初始化方式相同，都是使用new关键字。

public class Car {//创建汽车类 private String brand;//汽车品牌 public Car(String brand) {//汽车类的构造方法，参数为汽车品牌 this.brand = brand;//给汽车品牌赋值 } class Engine{//发动机类（内部类） String model;//发动机型号 public Engine(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) { Car car=new Car(\"大众朗行\");//创建汽车类对象，并为汽车品牌赋值 car.start();//汽车类对象调用启动（汽车）方法 //常见发动机类（内部类）对象，并为发动机型号赋值 Car.Engine engine=car.new Engine(\"EA211\"); engine.ignite();//发动机类对象调用（发动机）点火方法 }}

成员内部类不止可以在外部类中使用，在其他类中也可以使用。在其他类中创建内部类对象的语法非常特殊，语法如下：外部类 outer = new 外部类();外部类.内部类 inner = outer.new 内部类();

成员内部类

匿名类是只在创建对象时才会编写类体的一种写法。匿名类的特点是”现用现写“，其语法如下：new 父类/父接口(){ 子类实现的内容};

abstract class Dog{ String Color; public abstract void move(); public abstract void call();}public class Demo { 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中，这种在程序运行时可能出现的一些错误称为异常。异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。

在程序运行的过程中，也会发生各种非正常状况，比如程序运行时磁盘空间不足、网络连接中断、被装载的类不存在等。针对这种情况，在Java语言中，引入了异常，以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理。

异常概述

异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整型。可以通过Integer类的 parseInt(方法来实现。但如果该字符串不是数字形式，parseInt)方法就会抛出异常，程序将在出现异常的位置终止，不再执行下面的语句。

抛出异常

Java语言的异常捕获结构有try、catch和finally3种部分组成。其中，try语句块存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。语法如下：try{ //程序代码块}catch(Exceptiontype1 e){ //对Exceptiontype1的处理}catch(Exceptiontype2 e){ //对Exceptiontype2的处理}...finally{ //程序代码块}

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

捕捉异常

异常地抛出与捕捉

在 Java中，提供了一些异常类用来描述经常发生的异常。其中，有的需要程序员进行捕获处理声明抛出，有的是由Java 虚拟机自动进行捕获处理。Java 中常见的异常类如表:

Java常见的异常类

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

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

如何创建自定义异常

自定义异常的抛出与捕捉

自定义异常

throws关键词通常被应用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号隔开。

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

使用throws关键字将异常抛给上一级后，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

在方法中抛出异常

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

1.编译时异常在Java中，Exception类中除了RuntimeException类及其子类都是编译时异常。编方译时异常的特点是Java编译器会对其进行检查，如果出现异常就必须对异常进行处理，否则程序无法通过编译。处理编译时期的异常有两种方式：使用try...catch语句对异常进行捕获使用throws关键字声明抛出异常，调用者对其处理。

2.运行时异常 RuntimeException类及其子类都是运行时异常。运行时异常的特点是Java编译器不会对其进行检查，也就是说，当程序中出现这类异常时，即使没有使用try..catch语句捕获或使用throws关键字声明抛出，程序也能编译通过。运行时异常一般是由程序中的逻辑错误引起的，在程序运行时无法恢复。比如通过数组的角标访问数组的元素时，如果超过了数组的最大角标，就会发生运行时异常，代码如下所示:int[] arr=new int[5]；System.out.println(arr[6]); 上面代码中，由于数组arr的length为5，最大角标应为4，当使用arr[6]访问数组中的元素就会发生数组角标越界的异常。

运行时异常

Java 异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时，可遵循以下几条原则:在当前方法声明中使用ty-catch语句捕获异常。一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。文章知识点与官方知识档案匹配，可进一步学习相关知识

异常的使用原则

异常处理

在Java语言中，字符串必须包含在一对双引号（\" \")之内。例如：\"23.23\"、\"ABCDE\"、\"您好\"可以通过以下语法格式来声明字符串变量：String str;String:指定该变量为字符串类型str：任意有效的标识符，表示字符串变量的名称声明字符串变量s，代码如下：String s;

声明字符串

在Java语言中，将字符串作为对象来处理，因此可以像创建其他类型对象一样来创建字符串对象。创建对象要使用类的构造方法。

创建字符串

String类

使用”+“运算符可实现连接多个字符串的功能。”+“运算符可以连接多个String对象并产生一个新的String对象。

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

连接多个字符串

字符串也可以同其他基本类型进行连接。如果将字符串同其他数据类型数据进行连接，会将其他数据类型的数据直接转换成字符串。

案例实现的是将字符串常量与整型变量booktime和浮点型变量practice相连后的结果输出。在这里booktime和practice都不是字符串，当它们与字符串相连时会自动调用tostring（）方法并转换成字符串形式，然后参与字符串连接。如果将上例中的输出语句修改为：System.out.println(\"我每天花费\"+booktime+\"小时看书;\"+(practice+booktime)+\"小时上机练习\"); 这是由于运算符是有优先级的，圆括号的优先级最高，所以先被执行，然后再将结果与字符串相连。

public class Test1{ public static void main(String args[]) { int booktime=4; float practice=2.5f; //将字符串与整型、浮点型变量相连接，并将结果输出 System.out.println(\"我每天花费\"+booktime+\"小时看书；\"+practice+\"小时上机练习\"); }}

连接其他数据类型

连接字符串

使用String类的length（）方法可获取声明的字符串对象的长度。语法如下：str.length();其中，str为字符串对象。获取字符串长度，代码如下：String str = \"We are students\";int size = str.length();上段代码是将字符串 sr 的长度值给 in 型变量 size，此时变量 size 的值为 15，这表示 ngth方法返回的字符串的长度(包括字符串中的空格)。

获取字符串长度

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置。

1. indexOf(substr) 该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用 String 类的indexOfr方法时，会从当前字符串的开始位置搜索 s 的位置。如果没有检索到字符串 s，该方法的返回值是-1.语法如下:indexOf(substr)str：任意字符串对象substr：要搜索的字符串查找字符a 在字符串 str 中的索引位置，代码如下:String str = \"We are students\";int size = str.indexOf(\"a\"); //变量 size 的值是3 理解字符串的索引位置，要对字符串的下标有所了解。在 Java 语言中，String 对象是用数组表示的。字符串的下标是0~length0-1。

public class Test1{ public static void main(String args[]) { 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的长度输出 }}

2. lastindexOf(String str)该方法用于返回指定字符中最后一次出现的索引位置。当调用 Sting 类的 lastindexOf0方法时，会从当前字符串的开始位置检索参数字符串，并将最后一次出现。的聚引位置运回。如果没有检索到字符巾 str，该方法返回-1。语法如下：str.lastIndexof(substr)str：任意字符串对象substr：要搜索的字符串

字符串查找

public class Test1{ public static void main(String args[]) { String str=\"hello world\";//定义字符串str char mychar=str.charAt(6);//将字符串str中索引位置是6的字符返回 System.out.println(\"字符串str中索引位置是6的字符为：\"+mychar);//输出信息 }}

使用charAt()方法可将指定索引处的字符返回。//获取指定索引号的字符char charAt=str.charAt(3);System.out.println(charAt);

获取指定索引位置的字符

获取字符串信息

通过String类的substring0方法可对字符串进行截取。substring0方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。

1. substring(int beginlndex)该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下.:str.substring(int beginlndex)其中，beginIndex 指定从某一索引处开始截取字符串。

public class Test1{ public static void main(String args[]) { String str=\"《将进酒》：李白（唐）\

获取子字符串

public class Test1{ public static void main(String args[]) { String str=\" Java class \";//定义字符串str System.out.println(\"字符串原来的长度：\"+str.length());//将str原来的长度输出 //将str去掉前导和尾部的空格后的长度输出 System.out.println(\"去掉空格后的长度：\"+str.trim().length()); }}

trim()方法返回字符串的副本，忽略前导空格和尾部空格，语法如下：str.trim()

去除空格

public class Test1{ public static void main(String args[]) { String str=\"address\";//定义字符串str String newstr=str.replace(\"a\

字符串替换

startsWit()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为 boolean类型。

1. startsWith()方法该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：str.startsWith(String prefix) prefix：作为前缀的字符串

public class Test1{ public static void main(String args[]) { String num1=\"22045612\";//定义字符串num1 String num2=\"21304578\";//定义字符串num2 boolean b=num1.startsWith(\"22\");//判断字符串num1是否以‘22’开头 boolean b1=num2.endsWith(\"78\");//判断字符串num1是否以‘78’结束 System.out.println(\"字符串num1是以‘22’开始的吗？\"+b); System.out.println(\"字符串num2以‘78’结束的吗？\"+b1);//输出信息 }}

2. endWith()方法该方法用于判断当前字符串是否为以给定的字符串结束。语法如下：str.endsWith(String suffix)suffix：作为后缀的字符串

判断字符串的开始与结尾

对字符对象进行不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回。要比较两个字符串内容是相同相等，应使用equals()方法和equalsIgnoreCase()方法。

1. equals()方法如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则false。语法如下：str.equlas(String otherstr)

public class Test1{ public static void main(String args[]) { String s1=new String(\"abc\");//创建字符串对象s1 String s2=new String(\"ABC\");//创建字符串对象s2 boolean b=s1.equals(s2);//使用equals()方法比较s1与s2 boolean b1=s1.equalsIgnoreCase(s2);//使用equalsIgnoreCase()方法比较s1与s2 System.out.println(s1+\"equals\"+s2+\":\"+b); System.out.println(s1+\"equalsIgnoreCase\"+s2+\":\"+b1); }}

2. equalslgnoreCase方法使用equlas（）方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍然为boolean类型。语法如下：str.equalsIgnoreCase(String otherstr)

判断字符串是否相等

public class Test1{ public static void main(String args[]) {//用于比较的3个字符串 String str=new String(\"b\"); String str2=new String(\"a\"); String str3=new String(\"c\"); System.out.println(str+\"compareTo\"+str2+\":\"+str.compareTo(str2));//将str与str2比较的结果输出 System.out.println(str+\"compareTo\"+str3+\":\"+str.compareTo(str3));//将str与str2比较的结果输出 }}

compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符串的Unicode值，按照字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。语法如下：str.compareTo(String otherstr)

按字典顺序比较两个字符串

String类的toLowerCase()方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改为大写字母。

1、toLowerCase()方法如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下：str.toLower()

public class Test1{ public static void main(String args[]) { String str=new String(\"oh My God\");//创建字符串str String newstr=str.toLowerCase();//使用toLowerCase()方法实行小写转换 String newstr2=str.toUpperCase();//使用toUpperCase()方法实行小写转换 System.out.println(newstr); System.out.println(newstr2); }}

2、 toUpperCase()方法如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换成大写，字符串长度不变，语法如下：str. toUpperCase()

字母大小写转换

使用split()方法可以使字符串按指定的分割线字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split（）方法提供了以下两种字符串分割形式。

1. split(String sign)该方法可根据给定的分隔符对字符串进行拆分。语法如下：str.split(String sign)

public class Test1{ public static void main(String args[]) { String str=\"192.168.0.1\"; String[]firstArray=str.split(\"\\\\.\");//按照”.“进行分割，使用转义字符串”\\\\.“ String[]secondArray=str.split(\"\\\\.\

字符串分割

字符串操作

在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式化，一般需要编写大量的代码、经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。

1. 日期格式化先来看一个例子。返回一个月中的天数，代码如下：Date date=new Date();//创建Date对象dateStirng s=String.format(\"%te\

2. 时间格式化使用format()方法不仅可以完成日期的格式化，也可以实现时间格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫。格式化时间的转换符如图所示

3. 格式化常见的日期时间组合格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常见的如图所示

日期和时间字符串格式化

常规类型格式化可应用于任何参数类型，如图所示：

常规类型格式化

格式化字符串

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一个格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的云字符。正则表达式元字符及其意义如图所示:

在正则表达式中，可以使用方括号括起着于个字符来表示一个元字符，该元字符可代表方精号中第任同一个字符。例如，B一“labc14\

使用正则表达式

public class Test2{ public static void main(String[] args) { 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);//将操作时间输出 } }

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+\"可达达到附近新字符或字符串的目的，但”+“会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复对字符串进行修改，将极大地增加系统开销。

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

字符串生成器

字符串

public class LntegerDemo { //创建类 public static void main(String[] args) { //主方法 int num = Integer.parseInt(\"456\"); //将字符串转换为int类型 Integer iNum = Integer.valueOf(\"456\"); //创建一个Integer对象 System.out.println(\"int数据与Integer对象的比较：\

java.lang包中的Integer类、Byte类、Short类和Long类，分别将基本数据类型int、byte、short和long封装成一个类，由于这些类都是Number类的子类，区别就是封装不通过的数据类型，其包含的方法基本相同。 Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段。此外，该类提供了多个方法，能在int类型和String类型之间互相转换，同时还提供了其他一些处理int类型时非常有用的常量和方法。Integer类的常用方法如下表：

public class LntegerDemo { //创建类 public static void main(String[] args) { //主方法 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); }}

Integer类提供了以下4个常量：MAX_VALUE：表示int类型可取的最大值，即MIN_VALUE：表示int类型可取的最小值，即SIZE：用来以二进制补码形式表示int值的位数TYPE：表示基本类型int的Class实例

Integer类

public class LntegerDemo { //创建类 public static void main(String[] args) { //主方法 Double dNum = Double.valueOf(\"3.14\"); //创建一个Double对象 //判断是否为非数字值 System.out.println(\"3.14是否为非数字值：\" + Double.isNaN(dNum.doubleValue())); System.out.println(\"3.14是否为非数字值：\" + dNum.intValue()); //判断大小 System.out.println(\"值为3.14的Double对象与3.14的比较结果：\" + dNum.equals(3.14)); //转换为十六进制 System.out.println(\"3.14的十六进制表示为：\" + Double.toHexString(dNum)); }}

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

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

Double类

public class LntegerDemo { //创建类 public static void main(String[] args) { //主方法 Boolean b1 = Boolean.valueOf(\"true\"); //创建Boolean对象 Boolean b2 = Boolean.valueOf(\"ok\"); System.out.println(\"b1:\" + b1.booleanValue()); //输出 System.out.println(\"b2:\" + b2.booleanValue()); }}

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

Boolean 提供了以下3个常量:TRUE:对应基值 true 的 Boolean 对象。FALSE:对应基值false的 Boolean 对象。TYPE:基本类型boolean的Class对象。

Boolean类

public class LntegerDemo { //创建类 public static void main(String[] args) { //主方法 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)); } } }

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

Character 类提供了大量表示特定字符的常量，例如:CONNECTOR_PUNCTUATION: 返回 byte 型值，表示 Unicode 规范中的常规类别“pe”。UNASSIGNED: 返回 byte型值，表示 Unicode 规范中的常规类别“Cn”。TITLECASE_LETTER:返回 byte 型值，表示Unicode 规范中的常规类别“Lt”。

Character类

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

Number 类的方法分别被其各子类所实现，也就是说，在 Number 类的所有子类中都包含以上这几种方法。

Number类

为了能将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本数据类型封装在包装类中，如int型的包装类Integer、boolean型的包装类Boolean等，这样便可以把这些基本数据类型转换为对象进行处理。Java中的包装类及其对应的基本数据类型如下表：

包装类

数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。在 Java 中使用 java.textDecimalFormat格式化数字。在 Java 中，没有格式化的数据遵循以下原则:如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在 Jav中，可以使用DecimalFormat类进行格式化操作。 DecimalFormat类是NumberFormat 的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一艘情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中applyPattern0方法来实现数字格式化。

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

数字格式化

Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取量大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便可以使用如下形式调用:Math. 数学方法在Math类中，除函数方法外还存在一些常用数字常量，如PI、E等。这些数学常量作为Math 关的成员变量出现，调用起来也很简单。可以使用如下形式调用:Math.PIMath.E Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数函数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。

1.三角函数方法Math 类中包含的三角函数方法如下: public static double sin(doublea):返回角的三角正弦。public static double cos(double a):返回角的三角余弦。public static double tan(double a):返回角的三角正切。public static double asin(doublea): 返回一个值的反正弦。public static double acos(doublea): 返回一个值的反余弦。public static double atan(doublea):返回一个值的反正切。public static double toRadians(double angdeg): 将角度转换为弧度。public static double toDegrees(double angrad): 将弧度转换为角度。以上每个方法的参数和返回值都是double型的。将这些方法的参数的值设置为 double 型是有一定道理的，参数以弧度代替角度来实现，其中1°等于 /180 弧度，所以 180°可以使用弧度来表示。除了可以获取角的正弦、余弦、正切、反正弦、反余弦、反正切，Math 类还提供了角度和弧度相互转换的方法 toRadians()和 toDegrees()。但需要注意的是，角度与弧度的转换通常是不精确的。

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

Math类

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

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

Random类

BigInteger 类的数字范围校 Integer类的数字范围要大得多。前文介绍计 Ineger 类是int的包装类，int的最大值为，如果要计算更大的数字，使用 Integer 类就无法实现了，所以Java中提供了BigInteger类来处理更大的数字。Biglnteger 类支持任意精度的整数，也就是说，在运算中BigInteger类可以准确地表示任何大小的整数值而不会丢失信息。在BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。使用BigInteger 类，可以实例化一个BigInteger 对象，并自动调用相应的构造函数。BigInteger 类具有很多构造函数，但是直接的一种方式是参数以字符串形式代表有处理的数字。例如，将 2 转换为 BigInteger 类型，可以使用以下语句进行初始化操作:Biginteger twolnstance = new Bigintegor(\"2\")；

一旦创建了对象实例，就可以调用 BigInteger 类中的一些方法进行运算操作，包括基本的数学运算和位运算以及一些取相反数、取绝对值等操作。下面列举了 Biglnteger类中常用的几种运算方法：public BigInteger add(BigInteger val): 做加法运算。public BigInteger subtract(BigInteger val): 做减法运算。public BigInteger multiply(BigInteger val): 做乘法运算。public BigInteger divide(BigInteger val): 做除法运算。public BigInteger remainder(BigInteger val): 做取余操作。public BigInteger[] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。public BigInteger pow(int exponent): 进行取参数的 exponent 次方操作。public BigInteger negate(): 取相反数。public BigInteger shifLeft(intn): 将数字左移n位，如果n为负数，做右移操作。public BigInteger shiftRight(int n): 将数字右移n 位，如果n为负数，做左移操作。public BigInteger and(BigInteger val): 做与操作。public BigInteger or(BigInteger val): 做或操作。public int compareTo(BigInteger val): 做数字比较操作。public boolean equals(Object x): 当参数是 BigInteger 类型的数字并且数值与对象实例的数值相等时，返回 true。public BigInteger min(BigInteger val): 返回较小的数值。public BigInteger max(BigInteger val): 返回较大的数值。

BigInteger类

BigDecimal 类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的。BigDecimal 实现的加、减、乘、除的方法如表下：

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

BigDecimal类

在 Java 语言中，提供了一个执行数学基本运算的 Math 类，该类包括常用的数学运算方法，如角函数方法、指数函数方法、对数函数方法、平方根函数方法等一些常用数学函数方法。除此之外还提供了一些常用的数学常量，如 PI、E 等。在实际开发中，随机数的使用是很普遍的，所以要掌握生成随机数的操作。在Java 中主要提供]两种生成随机数的方式，分别为调用 Math 类的random()方法生成随机数和调用 Random 类生成各种整据类型的随机数。在Java 中，还提供了大数字的操作类，即 java.math.BigInteger 类与java.math.BigDecimal类。这个类用于高精度计算，其中 BigInteger 类是针对大整数的处理类，而 BigDecimal类则是针对大小数的处理类。

数字处理

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

1.不会自动换行的print()方法print()方法的语法如下：System.out.print(\"Hello!\");此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello” 文字末尾，不会自动换行。

2.可以自动换行的println()方法printin()方法在 print 后面加上了“ln”后缀 (就是 line 的简写)，语法知下:System.out.println(\"书籍是人类进步的阶梯!\");此方法输出“书籍是人类进步的阶梯!”后会自动换行。光标停留在下一行的开头。println()方法与 println()方法输出的对比效果如表所示：

综上所述，Java 输出换行的方法有以下两种:System.out.print(\"\\");//利用换行符\实现换行System.out.printIn();//空参数即可实现换行

控制台输出字符

public class Test2{ public static void main(String[] args) { 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)+\"毫秒\"); } }

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

计时

system 类是JDK 中提供的系统类，该类是用 fmal 修饰的，所以不允许被继。 System 类提供了最多系统层面的操作方法，并且这些方法全部都是静态的。System 类提供的较常用方法如下表：

System 类

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

Scanner类

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

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

Date 类的常用方法及其说明如表所示。

Date类

使用 getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，使用getDateTimeInstance()方法可获取日期和时间格式。DateFormat 类的常用方法及其说明如表所示:

SimpleDateFormat 类提供了 19 个格式化字符，可以让开发者随意编写日期格式，这19 个格式化字符如表所示：

通常上一表中的字符出现的数量会影响数字的格式。例如，yyyy 表示 4 位年份，这样输入会示2021;yy 表示两位，这样输入就会显示为21;只有一个y的话，会按照 yyyy 显示;如果超过4个y，如yyyyyy，会在4位年份左侧补0，结果为02021。一些常用的日期时间格式如下表：

DateFormat 类提供的 Date parse(String source)方法可以将字符串转为其字面日期对应的 Date对象，整个过程相当于日期格式化的逆操作。例如，将“2021-02-19”这个字符串转成 Date 对象，可以使用如下代码:DateFormat sdf = new SimpleDateFormat(\"yyyy-MM-dd);.Date date = sdf.parse(\"2021-02-19\");

日期时间格式化

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

Calendar 类提供的常用字段及其说明如表所示:

Calendar 类提供的常用方法及其说明如表所示:

Calendar类

日期时间类

本地命令指的是操作系统的命令。例如，在 Linux 系统下就表示 shell 命令，在 Windows 系统下表示 cmd 命令。 Runtime 类提供 exec()方法让 Java 代码可以执行系统的命令，exec()方法有很多重载的形式，例如:Process exec(String command)Process exec(Stringl cmdarray)command:要执行的系统命令，字符串类型。cmdarray:要执行的命令和相应的命令参数，字符串数组类型。

其实这两个重载方式很类似，如执行“javac hello.java”这行命令，使用第一种重载方式的代码如下Runtime.getRuntime().exec(\"javac hello.java\");

使用第二种重载方式的代码如下:String command] = {\"javac\

Process类的常用方法如表所示，开发可以使用 getInputStream()方法获取进程返回的信息：

执行本地命令

public class CountDown { public static void main(String[] args) { Runtime r=Runtime.getRuntime();//获取本地Runtime对象 Integer ints[]=new Integer[10000];//创建长度为10000的整型数组 long before=r.freeMemory();//获取当前空闲内存数 System.out.println(\"赋值前空闲内存字节数：\