Java从入门到精通

Java是一种通过解释方式来执行的语言，是一种跨平台的程序设计语言，用Java语言编写的程序，可以运行在任何平台和设备上。

什么是Java语言

Java的应用领域

Java的版本

怎么学好Java

JavaAPI文档

Java简介

简单

面向对象

分布性

可移植性

解释型

安全性

健壮性

多线程

高能行

动态

Java语言的特性

JDK下载

在Windows10系统下搭建JDK环境

搭建Java环境

初始Java

Eclipse简介

下载Eclipse

安装Eclipse的中文语言包

Eclipse的配置与启动

Eclipse工作台

透视图与视图

菜单栏

工具栏

“包资源管理器”视图

“控制台”视图

熟悉Eclipse

创建Java项目

创建Java类文件

使用编辑器编写程序代码

运行Java程序

使用Eclipse

程序调试

熟悉Eclipse开发工具

包声明

声明成员变量和局部变量

编写主方法

导入API类库

Java主类结构

int型、byte型、short型、long型

整数类型

单精度浮点类型（float)和双精度浮点类型（double)

浮点类型

char型

转义字符是一种特殊的字符变量它以”\\“开头，后跟一个或多个字符。转义字符具有特定的含义，不同于字符原有的意义。

字符类型

boolean型

布尔类型

基本数据类型

标识符是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。                                                                                                                      Java语言规定标识符由任意顺序的字母、下画线（_）、美元符号（$）和数字组成，并且第一字符不能是数字，不能是Java中的关键字（保留字）。

标识符

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

关键字

声明变量是告诉编译器这个变量的数据类型，在程序运行过程中，空间内的只是变化的，这个内存空间就称为变量，在声明变量时可以赋值，也可以直接赋给初值。

声明变量

在程序运行过程中一直不会改变的量称为常量，也称为“final变量”。常量在整个程序中只能被赋值一次。  在Java语言中声明一个常量，除了要指定数据类型，还需要通过final关键字进行限定。常量名通常是用大写字母，但这并不是必须的。 当变量被final关键字修饰时，该变量就变成了常量，必须在定义时就设定它的初值，否则将会产生编译错误。

声明常量

       在类体中所声明的变量被称为成员变量，成员变量在整个类中都有效。类的成员变量又可分为两种，即静态变量和实例变量。对于静态变量，除了能在声明它的类内存取，还能直接以“类名.静态变量”的方式在其他类内食用。

成员变量

       在类的方法体中声明的变量（方法内部定义，\"{\"与\"}\"之间的代码中声明的变量）称为局部变量。局部变量只在当前代码块中有效，也就是只能在\"{\"与\"}\"之内使用。在类的方法中声明，包括方法的参数，都属于局部变量。        局部变量可与成员变量的名字相同，此时成员变量将被隐藏，即这个成员变量在此方法中暂时失效。局部变量采取就近原则。

局部变量

变量的有效范围是指程序代码能够访问该变量的区域，若超出该区域，则在编译时会出现错误。在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

变量的有效范围

变量与常量

赋值运算符以符号”=“表示，其功能是将右方操作数所含的值赋给左方的操作数。使用赋值运算符同时为两个变量赋值：

赋值运算符

Java中的算术运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余）。使用算术运算符模拟计算器：

算术运算符

自增、自减运算符是单目运算符，符号在前，先运算后使用；符号在后，先使用后运算。++a(--a)        //先使a的值加（减）1，再使用变量aa++(a--)       //先使用变量a，再使a的值加（减）1

自增和自减运算符

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。

比较运算符

返回类型为布尔型的表达式，如比较运算，可以被组合在一起构成一个更复杂的表达式。这是通过逻辑运算符来实现的。逻辑运算符包括&（&&）（逻辑与）、||（逻辑或）、！（逻辑非）。逻辑与算符的操作元必须是boolean型数据。&&、&：两者为真，结果才为真||：只要有一者为真，结果才为真！：非真即假，非假即真

逻辑运算符

位运算符除\"按位与\"和\"按位或\"运算符外，其他只能用于处理整数的操作数，包括byte、short、chair、int和long等数据类型。位运算是完全针对位方面的操作。   ”按位与“运算：两者都为1，结果为1   ”按位或“运算：只要有一者为1，结果为1   ”按位取反“运算：0变1，1变0   ”按位异或“运算：两者相同为0，不同为1移位操作Java中的位移运算有三种：     1、<<:左移。（整体左移，空位补0，溢出去掉）     2、>>：右移。（整体右移，整数补0，负数补1，溢出去掉）     3、>>>:无符号右移。（整体右移，空位补0，溢出去掉）

位运算符

三元运算符的使用格式：条件式？值：值2 三元运算符的运算规则为：若条件式的值为true，则整个表达式取值1，否则取2。例如：boolean b=20<45?true:false;

三元运算符

运算符的优先级决定了表达式中运算执行的先后顺序，优先级由高到低的顺序依次是：增量和减量运算、算术运算、比较运算、逻辑运算、赋值运算

运算符优先级

运算符

从低级类型向高级类型的转换，一定不会丢失数据，系统将自动执行，称为隐式类型转换。从低到高排列的顺序为byte<short<int<long<float<double。

隐式类型转换

从高级类型向低级类型的转换，有可能会丢失数据，称为显式类型转换（又称为强制类型转换）

显式类型转换

数据类型转换

“//”为单行注释标记，从符号“//”开始直到换行为止的所有内容均为注释而被编译器忽略。

单行注释

”/**/“为多行注释标记，符号”/*“与”*/“之间的所有内容均为注释内容。注释中的内容可以换行。

多行注释

”/***/“为文档注释记。符号”/**“与”*/“之间的内容均为文档注释内容。

文档注释

编码规范

代码注释与编码规范

Java语言基础

Java语言的复合语句是以整个块区为单位的语句，所以又称块语句。复合语句又开括号”{“开始，闭括号”}“结束。

复合语句

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

if....else if语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。

if....else if语句多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件，就进行某种处理，否则如果满足另一种条件则执行另一种处理”。

if条件语句

在编程中，一个常见的问题就是检测一个变量是否符合某个条件，如果不符合，在用另一个值来检测，以此类推。当然，这种问题使用if语句也可以完成。

switch多分支语句

条件语句

while 语句也称条件判断语句 ，它的循环方式为利用一个条件来控制是否继续反复执行这个语句。

流程图：

while循环语句

do...while循环语句与while语句类似，他们之间的区别是while语句为先判断条件是否成立再执行循环体，而do...while循环语句先执行一次循环后，再判断条件是否成立。do...while循环语句“{}”中的程序段至少要被执行一次。

do...while循环语句

for循环是Java程序设计中最有用的循环语句之一。一个for循环可以用来重复执行某条语句，知道某个条件得到满足。

for循环语句

循环语句

使用break语句可以跳出switch结构。在循环结构中，可用break语句跳出当前循环，从而终端当前循环。

break语句

continue语句是针对break语句的充分。continue不是立即跳出循环体，而是跳过本次循环，回到循环的条件测试部分，重新开始执行循环。

continue语句

循环控制

流程控制

数组是具有相同数据类型的一组数据的集合。数组中的每个元素具有相同的数据类型。在Java中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。在程序设计中引入数组可以更有效地管理和处理数据。

数组概述

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。1、先声明，再用new关键字进行内存分配声明一维数组两种方式：数组元素类型  数组名字[];数组元素类型[]  数组名字；2、为数组分配内存同时设置初始值数组元素的类型 数组名=new数组元素类型[数组元素的个数]{值1，值2...};

创建一维数组

初始化一维数组

使用一维数组

一维数组

创建二维数组

初始化二维数组

输出一个3行4列且所有元素都为0的矩阵，代码如下：public class Hello{//创建类 public static void main(String[] args) {//主方法  int a[][]=new int[3][4];//定义二维数组  for(int i=0;i<a.length;i++) {   for(int j=0;j<a[i].length;j++) {//for循环遍历数组中的每个元素   System.out.print(a[i][j]);//将数组中的元素输出  }  System.out.println();//输出空格 }}}运行结果：

二维数组

遍历数组

数组中的元素定义完成后。可通过Arrays类的静态方法fill（）来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。

填充替换数组元素

通过Arrays类的静态方法sort（）可以实现对数的排序。sort（）方法提供了多种重载形式，可以对任意类型的数组进行升序排序。

对数组进行排序

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。复制数组元素：空位补0，溢出去掉复制数组部分元素：前在后不在

复制数组

Arrays类的binarySearch()方法，可使用二分法搜索指定数组，以获得指定对象。该方法返回要搜索要搜索的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。查询数组元素：先排序在查询，前含后不含

查询数组

数组的基本操作

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

冒泡数组

直接选择排序的基本思想是将指定排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。       注意这里与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置元素交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，直至整个数组都变成已排序好的格式。

直接选择排序

把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以从类推 ，直接把所有数组元素反转替换。

反转排序

数组排序算法

数组

对象是事物存在的实体，世间万物皆对象。对象分为两个部分，即静态部分与动态对象部分静态部分：不能动的部分，称为“属性\"动态部分：对象可执行的动作，称为“行为”

对象

类是统一事物的统称，如果将现实世界中的一事物抽象成对象，类就是这类对象的统称。 类是对象的设计图；类是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。

类

面向对象程序设计具有以下特点：封装性、继承性和多态性。      封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。      采用封装的思想保证了类内部数据结构的完整性，提高了程序的可维护性。

封装

类与类之间同样具有关系，这种关系被称为关联。两个类之间的关系有很多种，继承是关联中的一种。设计软件时，使用继承思想可以缩短软件开发的周期，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的概率。

继承

将父类对象应用与子类的特征就是多态。

多态

面向对象概述

  在Java中，对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均为成员变量作用范围。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语言中，使用成员方法对应于类对象的行为。

成员方法

权限修饰符

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

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

局部变量的有效范围

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

this关键字

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

在构造方法中可以为成员变量赋值，这样当实例化一个本类对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。

类的构造方法

由static修饰的变量和方法被称为静态变量和动态方法。被声明为static的变量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和”.“运算符调用静态成员。语法如下：类名.静态类成员

静态变量与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等。尽管使用这种方式调用静态成员比较方便，但静态成员同样遵循修饰符的约束。                                                                                                                                                                                                                                 总结以下使用static关键字要注意的几点：1、在静态方法中不可使用this关键字。2、在静态方法中不可以直接调用非静态方法。3、局部变量不可以使用static关键字声明。4、主方法必须用static声明。5、只有内部类可以使用static关键字声明。

静态变量和静态方法

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

类的主方法

对象可以认为是在一类事物中抽象出某一个特例，可以通过这个特例来处理这类事物出现的问题。在Java语言中，通过new操作符来创建对象。前文在讲解构造方法时介绍过，每实例一个对象就会自动调用一次构造用一次构造方法，实质上这个过程就是创建对象的过程。      准确地说，可以在Java语言中使用new操作符调用构造方法创建对象。语法如下：Test test=new Test();Test test=new Test(\"a\");

对象的创建

访问对象的属性和行为

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

对象引用

      每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收。在其他语言中，需要用户手动回收废弃的对象。Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源。      但是垃圾回收器只能回收那些有new操作符创建的对象。某些不是对象不是通过new操作符在内存中获取存储空间的，这种对象无法被垃圾回收机制所识别。在Java中提供了一个finalize()方法。

对象的销毁

类和对象

继承在程序中复用一些已经定义完善的类，不仅可以减少软件开发周期，也可以提高软件的可维护性和可扩展性。     子类重写父类的方法：返回参数相同，方法名相同，传入参数相同，只有方法体不同，前提是具有父子关系。     所有类的构造方法 ，第一行都有一个隐藏的“super();\

类的继承

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

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

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

在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中所有的类都直接或间接继承了java.lang.Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。

Object类

子类转父类，即子类赋值给父类，用自动类型转换Bird bird=new Pigeon();      //用向上转换，借助自动类型转换，将鸽子类转换为鸟类，告诉编译器：“某只鸽子是一只鸟”

向上转换

父类转子类 ，即父类赋值给子类，用强制类型转换。语法如下：子类类型  子类对象=（子类类型）父类对象；

向下转换

对象类型的转换

当在程序中执行向下转型操作时，如果父类的象不是子类对象的实例，就会发生ClassCastExeption异常，所以在执行向下转换之前需要，判断父类对象是否为子类对象的实例。这个判断通常使用instanceof关键字来完成。使用instanceof关键字判断是否一个类实现了某个接口，也可以用来判断一个实例对象是否属于一个类。语法如下：(myobject:某类的对象引用）myobject  instanceof  ExampleClass 使用instanceof关键字的表达式返回值为布尔值。

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

方法的重载是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。        方法名相同，参数类型（返回参数、传入参数）不同，参数个数不同，参数顺序不同，都能构成重载。                                                                           在谈到参数个数可以确定两个方法是否具有重载关系时，会想到定义不定义长参数方法。不定长方法的语法如下：返回值  方法名（参数数据类型...参数名称）

方法的重载

final关键字可用于变量声明，一旦该变量被设定，就不可以在改变该变量的值。final关键字定义的变量必须在声明时对其进行赋值操作。final关键字还可以修饰对象引用。用final修饰方法的不能被重写，否则会报错。

final变量

用final修饰变量不能被改变      将方法定义为final类型，可以防止子类修改父类的定义与现实方式，同时定义为final的方法的执行效果要高于非final方法。

final方法

用final修饰类不能被继承如果将某个设置为final类，则该类中所有方法都被隐藏式设置为final方法，但是final类中的成员变量可以被定义为final或非final形式。

final类

final关键字

利用 多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。子类对象可以作为父类的对象实例使用，这种将子类对象视为父类的做法称为“向上转型”。

有抽象方法的类一定是抽象类。     父类有抽象方法，子类没有抽象方法，子类继承父类要重写父类的抽象方法。抽象类的方法格式：修饰符  abstract  class  类名{}

抽象类

接口是抽象类的延伸，接口的所有方法都是抽象方法，接口的所有方法都没有方法体。接口的语法：修饰符  interface  接口名{}Java语言每个类可以实现多个接口。实现多个接口的语法：修饰符 class  类名  implements  接口1，接口2...接口n{}

接口

抽象类与接口

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

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

类名冲突

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

完整的类路径

类中定义包名的语法如下：                                                                                                                                                                                                           package  包名

创建包

      import关键字除导入包外，还可以导入静态成员。导入静态成员可以使编程更为方便，                                                                             使用import导入静态成员的语法如下：import  static  静态成员

导入包

Java类包

在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。成员内部类的语法如下：class OuterClass{                //外部类       class InnerClass{           //内部类}}                                                                                                                                                                                                                                           成员内部类不止可以在外部类中使用，其他类中也可以使用。在其他类中创建内部类对象的语法非常特殊，语法如下：外部类  outer=new   外部类（）；外部类.内部类 inner=outer.new   内部类（）；使用this关键字获取内部类与外部类的引用如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。

成员内部类

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

匿名内部类

内部类

包和内部类

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

异常概述

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

异常的捕捉                                                                                                                                                                                                                               Java语言的异常捕获结构由try、catch和finally三部分组成。try语句块存放的是可能发生异常的Java语句；catch语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。语法如下：try{//程序代码块}catch（Exceptiontype1 e){//对Exceptiontype1的处理}catch（Exceptiontype2 e){//对Exceptiontype2的处理}...finally{//程序代码块}      完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论 之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。以下4种特殊情况下，finally块不会被执行：1、在finally语句块中发生了异常2、在前面的代码中使用了System.exit()退出程序3、程序所在的线程死亡4、关闭CPU

异常的抛出与捕捉

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

Java常见的异常类

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

自定义异常

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

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

在方法中抛出异常

RuntimeException异常是程序运行过程中抛出的异常。Java类库的每个包中都定义了异常类，所有这些类都是Throwable类的子类。 Throwable类派生了两个子类，分别是Exception类和Error类。Error类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这些错误比较严重。Exception类又根据错误发生的原因分为RuntimeException异常和除RuntimeException之外的异常。

运行时异常

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

异常的使用原则

异常处理

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

声明字符串

创建字符串

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输出 }}运算结果：

连接多个字符串

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

连接其他数据类型

连接字符串

使用String类的length（）方法可获取声明的字符串对象的长度。语法如下：str.length();

获取字符串长度

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置。1、indexOf(String s)      该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置。       //查找字符串里第一次出现该元素的位置str.indexOf(\"1\")int indexof=str.indexOf(\"1\");System.out.println(indexof);2、lastIndexOf(String str)      该方法用于返回指定字符串最后一次出现的索引位置。当调用String类的lastIndexOf()方法时，或从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。       //查找字符串里最后一次出现该元素的位置str.lastIndexOfint lastIndexOf=str.lastIndexOf(\"1\");System.out.println(lastIndexOf);

字符串查找

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

获取指定索引位置的字符

获取字符串信息

获取子字符串

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

去除空格

字符串替换

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

判断字符串的开始与结尾

对字符对象进行不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回。       要比较两个字符串内容是相同相等，应使用equals()方法和equalsIgnoreCase()方法 。1、equals()方法        如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则false。语法如下：str.equlas(String  otherstr)2、equalsIgnoreCase()方法       使用equlas（）方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍然为boolean类型。语法如下：str.equalsIgnoreCase(String otherstr)

判断字符串是否相等

  compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符串的Unicode值，按照字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。语法如下：str.compareTo(String otherstr)判断字母b的位置。代码如下：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比较的结果输出 }}运行结果：

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

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

字符串大小转换

字符串分割

字符串操作

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

3、格式化常见的日期时间组合按照格式输出当下的年、月、日。代码如下：import java.util.Date;//导入java.util.Date类public class Test1{ public static void main(String args[]) {  Date date=new Date();//创建Date对象date  String time=String.format(\"%tc\

日期和时间字符串格式化

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

常规类型格式化 

格式化字符串 

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

使用正则表达式

       创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+\

字符串生成器

字符串

Java是一种面向对象语言，但在Java中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本数据类型封装在包装类中。包装类及其对应的基本数据类型如表所示：包装类         对应基本数据类型  包装类   对应基本数据类型Byte            byte                      Short        shortInteger       int                         Long         longFloat           float                     Double      doubleCharacter   char                      Boolean     boolean

Integer类

Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段。此外，该类提供了多个方法，能在int类型和String类型之间相互转换，同时还提供了其他一些处理int类型时非常有用的常量和方法。

Double类

   Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段。此外，此类还为boolean类型和String类型的相互转换提供了许多方法，并提供了处理boolean类型时非常有用的其他一些常量和方法。Boolean类的常用方法。代码如下：public class Test2{ 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类

Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别（小写字母、数字），并可以很方便地将字符从大写转换成小写，反之亦然。Character类的常用方法 。代码如下：public class Test2{ 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类

对于数值型的包装类，他们有一个共同的父类—— Number类，该类是一个抽象类，它是Byte、Integer、Short、Long、Float和Double类的父类，其子类必须提供将表示的数值转换为byte、int、short、long、float、和double的方法。

Number类

包装类

     数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字。数字格式化操作主要针对的是浮点型数据，包括double型和float型数据。在Java中使用java.text.DecimalFormat格式化数字。 在Java中，没有格式化的数据遵循以下原则:1、如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。2、如果数据绝对值小于0.001并且大于10000000，使用科学记数法表示。

数字格式化

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

Math类

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

Random类

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

BigInteger类

       BigDecimal类和BigInteger类都能实现大数字的运算，不同的是BigDecimal类加入了小鼠的概念。一般的float型和double型数据只可以用来做科学计算或工程计算，但由于在商业计算重要计算中要求数字精度比较高，所以要用到BigDecimal类。BigDecimal类支持任何精度的定点数，可以用来精度计算货币值。

BigDecimal类

数字处理

System类提供了标准输入、标准输出和错误输出流，也就是说，System类提供了3个静态对象:n、out和err。本书中的代码多次使用了这些对象，最常见的就是 out 对象。java输出换行的方法有以下两种：System.out.print(\"\\");System.out.println();

控制台输出字符

System.currentTimeMillis()方法可以获取自1970年1月1日零点至今的毫秒数。该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。查看执行一万次字符串所有拼接所消耗的时间。代码如下：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类

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY OF MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected.Calendar 提供了一个类方法 getInstance0，以获得此类型的一个通用的对象。

Scanner类

Date类

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种。                DateFormat类的常用方法及其说明方法                                 说明format(Date date)           将一个Date对象实例格式化为日期/时间字符串getCalendar()                  获取与此日期/时间格式器关联的日历getDatelnstance()           获取日期格式器，该格式器具有默认语言环境的默认格式化风格getDateTimeInstance()   获取日期/时间格式器，该格式器具有默认语言环境的默认格式化风格getInstance0)                  获取为日期和时间使用SHORT风格的默认日期/时间格式器getTimeInstance()           获取时间格式器，该格式器具有默认语言环境的默认格式化风格parse(String source)        将字符串解析成一个日期，并返回这个日期的Date对象                                                                                                                                          常用时间格式  日期时间                        对应的格式2023/10/25                   yyyy/MM/dd2023.10.25                    yyyy.MM.dd2023-09-15                   yyyy-MM-dd2023年10月24日           10时25分07秒  星期二 yyyy年MM月dd日 HH时mm分ss秒 EEE下午5时                          ah时今天已经过去了297天    今天已经过去了D天

日期时间格式化

日期和时间类

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

执行本地命令

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

查看内存

\\

Runtime类

常用类库

Java从入门到精通