Java语言程序设计(一)

第１章 java语言基础
1.1 java语言的特点
java语言最初的应用对象是消费性电子产品。最初的名字是oak语言。java语言是适用于分布式计算环境的面向对象编程语言，它虽类似于c和c++，但比c++简单，忽略了许多为提高计算效率但初学者较难掌握的程序语言特性。
java语言主要有以下特点：
①强类型。②编译和解释：java语言是一种高级编程语言，用java语言编写的源程序在计算机上运行需要经过编译和解释执行两个严格区分的阶段java的编译程序先将java的源程序翻译成与机器无关的字节码，不是通常的编译程序将源程序翻译成特定计算机的机器代码。运行时，java的运行系统装载和链接需要执行的类，并作必要的优化后，解释执行字节码程序。③自动无用内存回收功能，没有指针，数组元素都要检查下标是否越界。④面向对象。其特点：封装性、继承性、多态性。⑤与平台无关：在任何平台上，java源程序被java编译器译成虚拟机能够识别的字节码。这样，只要有java虚拟机的平台，就能解释执行java字节码程序，从而实现java程序与平台无关。
⑥安全性。⑦分布式计算。⑧多线程。
1.2 java应用程序和小应用程序
java程序可以是独立的应用程序，也可以是能在浏览器上执行的小应用程序(Applet)。两种java程序都由一个或多个扩展名为".class"的文件组成，而且都需要java虚拟机(jvm)载入并翻译。
两种程序的主要区别是：
①小应用程序只能在与java兼容的容器中运行，可以嵌入在html网页内，在网络上发布，当网页被浏览时，在浏览器中运行，小应用程序的运行还受到严格的安全限制，例如：它不能访问用户计算机上的文件。java应用程序没有这些限制，也不支持网页嵌入和下载运行。
②小应用程序和应用程序在代码编写上也有很大差异。一个小应用程序必须定义成一个Applet类的子类。应用程序可以是Applet类的子类，也可以不是。应用程序必须在一个类中定义一个main()方法，该方法代表应用程序的入口。而小应用程序不必定义main()方法，它的执行由Applet类中定义的多个方法控制。
java源程序命名受到严格的限制：java源程序的扩展名必须是"．java"，而源程序经过编译后得到的应用程序文件名（即字节码文件）的主文件名和源程序中的类名一样，而扩展名是".class"。如果源文件中多个类，那么最多只能有一个public类；如果源文件中有public类，那么源文件的名字必须与这个类的名字完全相同。如果源文件没有public类，那么源文件的名字只要和某一个类的名字相同即可。
java程序中经常会出现注释。注释是程序中的说明文字，用于帮助阅读程序，它不是语句

，不会影响程序的执行效率。
java语言的注释有三种形式：
①行注释(//)：用于简短地说明前面代码的意义或功能。注释内容到行末不能跨行。
②块注释（/*......*/）：是多行注释，用于说明下面程序段的算法、功能等，块注释不可嵌套使用。
③文档注释（/**......*/）：能被实用程序（命令）javadoc接受，由它能自动生成程序的html文档。
1.3 java程序的开发过程（以下以SUN公司的java JDK为例）
对于java应用程序，先编写java源程序，源程序经java编译器（javac.exe）编译后产生字节码文件，最后由java解释器（java.exe）解释执行字节码文件。
对于小应用程序，先编写java源程序，源程序经java编译器编译后产生字节码文件，最后由Web浏览器解释执行字节码文件。
编译器和解释器的使用格式是：
javac［选项］源文件（其中源文件是“．java文件）
java［选项］类名 ［参数］（类名指定的必须是含有main()方法的类，即是一个java应用程序）
通常情况下用的比较多的开发环境有 Eclipse，JBuilder等。
1.4 标识符和关键字
java语言使用Unicode字符集，共有65535个字符。
java标识符用于命名程序对象。
java语言的标识符可以按以下规则任意命名：① 由字母（包括英文字母、下划线字符、美元字符、文字字符）和数字组成。② 限定标识符的第一个字符不能是数字字符。
除了按上述规则命名标识符外，另外还有命名的习惯约定（行业习惯，不是规定）：一般变量名、方法名用小写英文字母开头，类名首字母用大写字母，若命名由若干个单词组成，后面的每个单词用大写开头；文字和常数全用大写字母命名；包名全部用小写字母。
java关键字：关键字是一些英文单词，在语言中，关键字已经被赋予特定的意义，不能用这些关键字作为标识符命名程序对象。关键字全部由小写字母组成。每个关键字在程序中出现，均有特定位置和特定使用方法的要求。
1.5 基本数据类型
java语言是强类型语言，每个变量和表达式都有确定的类型，在变量赋值时要进行类型兼容性检验。
数据类型可分为非基本数据类型和基本数据类型两大类。非基本类型也称为复合数据类型，是由基本类型组合的新类型。非基本数据类型分为：数组、字符串、类、接口。基本数据类型也称为原始数据类型，是系统预先规定的一些常用类型。它们是：整数类型、浮点数（实数）类型、字符（文字）类型、逻辑类型（布尔型）。
①逻辑类型用关键字boolean标识，所以也称为布尔型。逻辑类型只有真（true）和假（false）两个值。
②字符类型用关键字char标识。字符型数据是一个字符，内部表示是字符的Un

icode代码，共有65535个不同的字符。在java程序中，字符常量有普通字符常量（用单引号括住一个字符）和转义字符常量（用\开头后跟特定字符或字符串）两种。
③整数类型是指不带小数点和指数的数值数据。由于计算机只能表示整数的一个子集，表达更大范围内的整数需要更多的二进制位，java语言将整数数据按数值范围大小不同分成四种：基本型用关键字int标识,4个字节，32位，取值范围是-2^31~2^31-1；短整型用关键字short标识，2个字节，16位，取值范围是-2^15～2^15-1；字节型用关键字byte标识，1个字节，8位，取值范围是-2^7～2^7-1；长整型用关键字long标识（或者在常数后加L或l标识），8个字节，64位，取值范围是-2^63～2^63-1。每种整数类型处理不同范围的整数值，并且都是带符号的。
整型常量有十进制、八进制（以数字符0开头）和十六进制（以0x开头）三种写法。④浮点数类型也称为实型，浮点数是带小数点或指数的数值数据。java语言的浮点数有单精度和双精度两种。单精度型用关键字float标识，占4个字节，32位。Float型常量的书写方法是在实数之后加上字母F或f。双精度用关键字double标识，占8个字节，64位。double型常量的书写方法有两种：一种写法是直接写一个实数，或在实数后加字母D或d。另一种是科学计数法，用10的方幂（用字符e或E表示幂底10，另外e前后必须有数字）。
习题：一个小应用程序必须定义成一个（Applet类的子类）；基本数据类型：字符型、整型、浮点型、逻辑型；非基本数据类型：数组、字符串、类、接口；在java语言中，转义字符的表示：\字符、\八进制数字、\u十六进制数字；在java语言中，字节型byte在计算机内存中占有1个字节，其取值范围：-2^7~2^7-1；java源文件的命名规则：java源程序命名受到严格的限制，java源程序的扩展名必须是.java，如果源文件中多个类，则只能由一个public类，如果源文件中有public类，则源文件名字必须与这个类的名字完全相同，如果源文件没有public类，则源文件的名字只能和某一个类的名字相同即可。
第2章 运算和语句
2.1 数据运算
java语言的基本运算可分成以下几类：赋值运算、算术运算、自增和自减运算、关系运算、逻辑运算、条件运算和字符串连接运算等。
2.1.1 赋值运算
在java语言中符号“=”是赋值运算符不是“相等”运算符（相等运算符是“==”见关系运算符的叙述）赋值运算分为两类：一是简单赋值运算；二是复合赋值运算。
1、简单赋值运算 简单赋值运算的一般形式如下：变量　表达式，赋值运算的执行过程是：（1）计算赋值运算符右端的表达式。（2）当赋值运算两

侧的类型不一致时，将表达式值的类型自动转换成变量的类型。（3）将表达式的值赋值给变量，即存储到与变量对应的存储单元中。这里的类型转换是指数值数据的类型自动转换，这样的自动转换只能是简单类型向复杂类型转换，不能从复杂的转换成简单的。即如下所示的从左到右转换。byte→short→int→long→float→double java语言约定赋值运算也有值，它的值就是赋予变量的值，因此，赋值运算的结果可以继续赋值。
int j；
double y=2.0；
y=j=3；//j的值为3，y的值为3.0
赋值运算符结合性“自右至左”当连续有多个赋值运算时，是从右至左逐个赋值。
2、复合赋值运算，这类运算的特点是：变量即要参与运算，又要接受赋值。为避免对同一个变量的地址重复，计算引入复合赋值运算符。常用的复合赋值运算符有：+=、-=、=、/=、%=。
2.1.2 算术运算
算术运算要求运算分量的类型是数值类型的（整数类型和浮点数类型）。运算时，只需一个运算分量的是单目运算，需两个运算分量的是双目运算。特别的：（1）“/”为除法运算符，当除数和被除数均为整数类型数据时，则结果也是整数类型数据。例如7/4的结果为1。（2）“%”为求余数运算符，求余数运算所得结果的符号与被除数的符号相同。例如5%3的结果为2，-5%3的结果为的结果为-2。
2.1.3 自增和自减运算
自增运算符“++”和自减运算符“--”是单目运算符，要求运算分量是数值类型的变量，其作用是使变量的值增1或减1，这两个运算符与变量结合有以下四种可能形式：++i前缀形式，表示在引用变量i之前，先使i加1，以加1后的i值为运算结果。-i前缀形式，表示在引用变量i之前，先使i减1，以减1后的i值为运算结果。i++后缀形式，表示在引用变量i之后，才使i加1，即以增1前的i值为运算结果。i--后缀形式，表示在引用变量i之后，才使i减1，即以减1前的i值为运算结果。
例如：
i=4；j=++i；//i结果为5，j的结果为5
i=4；j=i++；//i结果为5，j的结果为4
i=4；j=--i；//i结果为3，j的结果为3
i=4；j=i--；//i结果为3，j的结果为4
上述例子说明，对变量采用自增（或自减），用前缀形式或用后缀形式，对变量本身来说，效果是相同的，但表达式的值不相同。前缀形式是变量运算之后的新值，后缀形式是变量运算之前的值．自增自减运算能使程序更为简洁和高效，但在使用时需注意“++”和“--”运算的运算对象只能是变量，不能是常量或表达式．例如，4++或（i+j）++都是不合法的．
2.1.4 关系运算
关系运算对左右两侧的值进行比较，如果比较运算的结果成立，则值为true，不成立为false。关系运算符的优先级别不

完全相同。<、<=、>、>=的优先级高于==、!=。关系运算符的优先级低于算术运算符的优先级。
2.1.5 逻辑运算
逻辑运算用来描述表达式，实现连续多个条件的逻辑与、逻辑或、逻辑否定的判定。有3个逻辑运算符：&&（逻辑与）、||（逻辑或）、!（逻辑否定）
其中：运算符&&和||是双目运算符，运算符!是单目运算符。逻辑运算的操作数必须是布尔型的，结果也是布尔型的。逻辑否定“!”的优先级高于算术运算符的优先级。逻辑与&&和逻辑或||的优先级低于关系运算符的优先级。需要特别指出的是，逻辑与和逻辑或运算符有以下性质，java语言利用这些性质，在进行连续的逻辑运算时，不分逻辑与和逻辑或的优先级进行计算，而是顺序进行逻辑与和逻辑或的计算，一旦逻辑子表达式或逻辑表达式能确定结果，就不再继续计算。
（1）对表达式a&&b，当a为false时，结果为false，不必再计算b；仅当a为true时，才需计算b。（2）对表达式a||b，当a为true时，结果为true，不必再计算b；仅当a为false时，才需计算b。
例如：设有a=b=c=1，计算++a>=1||==b<++c。从左到右顺序计算逻辑或表达式，先计算子表达式++a>=1，变量a的值变为2，++a>=1为true，整个逻辑表达式的值已经为true，不再计算右边的子表达式++b<==c。因而，变量b和变量c的值不变，仍为1。
2.1.6 条件运算（? :）
条件运算是一个三目运算符，一般形式为：逻辑表达式?表达式1:表达式2
2.1.7 其他运算
1、位运算
位运算的运算分量只能是整型数据，位运算把运算对象看作是由二进制位组成的位串，逐位完成指定的运算，得到一个新的位串。位运算符有4个，按优先级从高到低顺序，依次为：~(位反)、&(位与)、^(位异或)、|(位或)用位运算的组合可以用来描述各种特殊的位串运算。例如，位运算表达式((k-1)^k)&K 能取下非0的整型变量k的最右边为1的那一位。
2、移位运算
移位运算是将整数作为二进制位的位串向左或向右移动。移位运算符有三个，它们是：左移运算符（<<）、算术右移运算符(>>)、逻辑右移运算符(>> >)移位运算有两个运算分量，左运算分量为移位的数据对象，右运算分量的值为移位位数。移位运算符的优先级低于算术算符，高于关系运算符，它们的结合方向是自左至右。
java语言允许数值型数据混合运算，不同类型的数值数据混合运算时需要类型转换。对于数据表示字节数少的类型数据转换成数据表示字节数较多的类型数据，系统能自动实现转换。反之，例如，将一个long类数据转换成int型数型，这种数据类型转换必须采用类型强制转换。类型强制转换称作造型(cast)，书写格式为：(类型)表达式
2.2 语

句
在java语言中，语句分为基本语句、控制结构语句以及package语句和import语句等。其中控制结构语句包括复合语句、if语句、switch语句、循环语句和try...catch语句。其中循环语句有while语句、do...while语句、for语句三种。
2.2.1 基本语句
基本语句主要有表达式语句、空语句、break语句、continue语句、return语句等。
1、表达式语句
在赋值表达式、自增自减表达式和方法调用表达式之后加上分号即变成语句，称它们是表达式语句。另一个典型的表达式语句是方法调用表达式之后接上分号。
2、空语句
空语句是只有一个分号的语句，其形式为；实际上，空语句是什么也不做的语句。语言引入空语句是出于以下实用上的考虑。例如，循环控制结构的句法需要一个语句作为循环体，当要循环执行的动作由循环控制部分完成时，就不需要有一个实际意义的循环体，这时就需要用一个空语句作为循环体。另外，语言引入空语句使序列中连续出现多个分号不再是一种错误，编译系统遇到这种情况，就认为单独的分号是空语句。
3、break语句
4、continue语句
continue语句只能出现在循环结构中，continue语句的执行将忽略它所在的循环体中在它之后的语句。简单地说，continue语句提早结束当前轮次循环，进入下一轮次循环。
2.2.2 复合语句
在java语言中，用花括号括住一个顺序执行的计算步骤序列描述顺序结构，这样的顺序结构称作复合语句。复合语句中的每个计算步骤可以是单个语句，也可以是一个控制结构，特别情况也可以为空。
2.2.3 if语句
有两种选择控制结构：两路条件选择结构（用计语句描述）和多路按值选择结构。
2.2.4 switch语句
在java语言中，用switch语句描述多路按值选择结构。switch语句包含一个表达式，用于按表达式值的不同作相应选择。另外，还有一系列由case开头的子句和一个可选用的default开头的子句，每个子句有一个可能为空的语句序列。
正确编写switch语句有以下几个要求：（1）switch后面括号内的表达式的类型只限于char、int、short和byte。（2）所有case后的常量表达式的值互不相同，类型与switch后括号内的表达式类型一致。（3）语句序列由任意条合法的java语句构成，也可以没有语句。（4）default子句可以缺省，但至多出现一次，习惯总是将它写在所有case子句之后，如有必要也可写在某个case子句之前。（5）如果要使各种情况互相排斥，仅执行一个子句的语句序列，每个子句都需要以break语句结束。
2.2.5 try...catch语句
java语言提供了一种称为异常的机制协助程序报告和处理错误。程序不必用特别的语句对异常预先进行检测，而是当异常

真的发生时，系统会抛出一个异常。这时，程序的正常流程被中断，系统会自动进入程序预先设定的异常处理代码块执行。这个代码块或者能尝试从错误中恢复，或者输出必要的信息后终止程序，防止异常错误的影响进一步扩大。要使程序能完成异常处理，需要给出可能会产生异常的代码块，以及异常发生时处理这个异常的代码块。
在java语言中，用try...catch语句指定可能会发生异常的代码块和错误处理代码块。try...catch语句由try引导，由try标识一个可能会发生异常的语句块，用catch标识一个处理某种异常的语句块，如果发生这异常，中断程序正常的执行流程，直接执行处理异常的语句块。最后，为了适应各种可能，另用finally标识一个无论try块中语句异常是否发生都会执行的语句块。下面是try...catch语句的一般形式：try{语句块//执行该语句块，可能会发生异常}catch(异常类型e){异常发生时要执行的语句块}finally{无论异常发生与否，都要执行的语句块}
2.2.6 while语句
while语句用于描述while循环，while循环结构由一个循环条件和一个作为循环体的语句组成，while循环的语义是当条件成立时重复执行指定的循环体。
2.2.7 do...while语句
do...while语句用于描述do...while循环。do...while循环也由一个循环条件和一个循环体组成。do...while循环的语义是重复执行指定的循环体，直至条件不成立结束循环。注意，最后的分号是do...while循环结构的结束符，不能省略。
2.2.8 for语句
循环之前要为变量置初值，在循环过程中循环变量逐一变化的循环计算结构，称为for循环。for循环包含四部分，为循环有关变量赋初值的表达式1、控制循环条件的表达式2、实现循环计算的语句，称作循环体，以及循环体执行后为有关变量更新的表达式3，for循环控制结构用for语句描述，for语句的一般形式为for(表达式1；表达式2；表达式3)
2.2.9 嵌套的循环结构
当循环结构的循环体中又包含循环结构时，循环结构就呈嵌套的形式。
2.2.10 循环体中的continue语句和break语句
循环体中的continue语句和break语句用于改变循环原有语句执行流程。其中continue语句的作用是结束当前一轮循环（跳过本轮循环的剩余语句），直接进入下一轮循环。continue语句出现在for循环中，跳至表达式3的计算，更新循环变量。continue语句出现在while和do...while循环中，跳至循环条件的计算和测试。break语句的作用是从循环体内跳出至循环的后继语句，即强行中断当前循环。
2.2.11 package语句
在java语言中，程序包相当于其他语言的函数库。除了系统提供大量程序包外，程序员也可将自己编写的类组成程序包，以便以后像使

用系统程序包一样使用它们。程序包声明称为package语句，格式如下：package包名；package语句必须出现在源程序文件的起始行，表示出现在该文件中的所有类都属于这个程序包。如果有多个源程序的程序包声明使用相同的包名，则表示这些源程序文件中的全部类都属于这个程序包。包名是一个目录名，其中也可以有路径。如果源程序文件的首行没有package语句，则被默认为是无名包，存于当前目录中。
2.2.12 import语句
import语句用来引入所需要的类。import语句的格式为：import包名.类名；
import java.util.Date；//只是引入Date类,如果要从一个包中引入多个类，则可以用通配符“*”。例如，以下代码从java.awt包中引入awt目录层次的所有类。import java.awt.*；//从java.awt包中引入所有的类在一个java源程序中可以有多个import语句，它们必须出现在package语句之后，类的定义之前。
java API的类被组织成多个包，它们常被java程序引入使用：
java.applet 包含所有支持java applet的类
java.awt 包含抽象窗口工具集中的图形、文本、窗口GUI类
javax.swing 是java.awt包的扩充，包含更丰富的抽象窗口工具集
java.awt.image包含抽象窗口工具集中的图像处理类
https://www.sodocs.net/doc/d318509028.html,ng包含所有的基本语言类
java.io包含所有的输入输出类
https://www.sodocs.net/doc/d318509028.html,包含所有实现网络功能的类
java.util包含有用的实用库程序类
java.awt.peer平台无关的GUI工具集界面
习题：
按运算符操作数的数目划分，运算符？：的类型是（三目），分析,使用时需要有三个运算分量。一般形式是“逻辑表达式？ 表达式1：表达式2”；计算程序代码的输出结果，short i=10，j,k=20;j=k+i++;System.out.print(j)的结果是什么，结果是出错，分析，i++自动将short类型转换成int类型，最后等着k+i++是int类型，而j是short类型，所以，k+i++导致编译器无法把32位整数存储到只有16位长的变量中，导致输出结果出错。计算程序的输出结果，intx=100;System.out.println("5.5"+x%8);结果为5.54，分析“5.5”是字符型，x%8=4，所以字符串加整数结果相连了，结果是5.54。用一个java语句完成要求，先变量a与b的差赋值给变量c，再把变量b的值减1，语句为：c=a-b--或者c=a-（b--）。请写出表示条件“x=2与y=3至少有一个成立”的java表达式为：x==2&&y!=3||x!=2&&y==3||x==2&&y==3。请写出表示条件“x=2与y=3最多只有一个成立”的java表达式为：x==2&&y!=3||x!=2&&y==3||x!=2&&y!=3。
下列程序的输出结果是，int x=10;x=++5;System.out.pringln(x)的结果？结果是出错，分析，x=++5是错误的，++的运算对象只能是变量，不能是常量或表达式。程序代码的输出结果，已知，int x=10,y=20,z=30;x=(y+z)++;System.out.println(x)的结果是出错。分析，x=(y+z)++

,++运算的对象是表达式不符合要求。
（continue)语句的作用是结束当前一轮循环（跳过本论循环的剩余语句），直接进入下一轮循环.(break)语句的作用是从循环体内跳出至循环的后继语句，即强行中断当前循环。程序包声明语句必须出现在源程序文件的（起始行），表示出现在该文件中的所有类都属于这个程序包。
第3章 面向对象编程基础
3.1 面向对象的基本概念
1、抽象
抽象(Abstraction)是程序设计中最经常使用的技术之一，因为抽象是有效控制程序复杂性的重要手段。程序设计中利用抽象，在面向过程阶段，系统按函数和模块进行设计。在面向对象阶段，利用抽象按类设计。类是目前支持抽象的最好工具。
2、对象
在面向对象语言中，对象的名称用于程序引用对象，对象的成员变量，用于存储对象的状态信息，对象的方法用于描述对象的行为。
3、消息
在程序系统中，对象之间的交互通过相互发送消息(Message)实现。
4、类
统一给出同类对象的各项属性和提供的所有行为，避免程序逐一描述同类中的每个对象的所有属性及详细给出对象的每个方法的描述，把同一类对象的所有共同的属性和行为放在一起描述。这种声明对象共有属性和行为的机制称为类。类的声明定义了类的所有对象的共有属性和方法。类是对一组相同对象的描述，类概括了同类对象的共有性质：数据和方法。类的每个对象都有自己的标识，但它们具有相同的一组属性和提供相同的一组方法。
5、继承
除对象按类划分外，不是同一类的对象可能会在某些相似性。继承（Inheritance)就是在已有类的基础上，扩充属性，或扩充与改写其某些方法，生成新的类，这个方式称为继承。继承定义的类称为子类，被继承的类称为超类（父类），子类自动含有父类具有的属性和方法。继承具有传递性。超类声明定义共同的特征，子类继承超类的共有特性，还可增加某些特殊性，并可扩充和修正部分行为。采用继承声明定义的子类可以有父类的属性和方法，也可以增加新的属性和方法，并可以对父类的某些方法给出新的定义。继承的最大好处是对象能按层次划分，并在子类中，与父类相同的属性和方法可以不再重复声明。继承体现了面向对象方法与现实世界中人们的抽象思维方式保持一致。
6、多态性
多态性(Polymorphism)有多种表现形式，这里所说的多态性是指类型适应性多态性，这来自继承，不同继承层次的对象同样的方法有不同的实现。类型适应性多态要求能自动按对象的实际类型正确调用它的方法。类型适应性的多态性需要采用动态联编(DynamicBinding)技术实现。联编是将发送

给对象的消息与含执行该消息方法的对象连接起来。当联编在编译和连接阶段实现时，这样的联编过程称为静态联编；当联编推迟至运行时间实现时，该联编过程称为动态联编。动态联编是面向对象语言必须具有的一种能力，是实现上述多态性的技术基础。
3.2 java的类和对象
3.2.1 类
类是一种类型，类封装对象的属性和方法，是同一类对象的模板。java程序的主要部分是描述类。
1、类的声明
声明一个新类的基本格式如下：class类名//声明新类的基本格式｛类体｝,其中关键字class引导一个类的声明，类名是一个标识符。类体给出类的成员变量定义和方法定义，类体中不能有独立的执行代码，所有的执行代码只能出现在方法中。
2、成员变量
成员变量定义的一般形式为：［修饰字］　类型　变量名；其中，修饰字可以空缺，修饰字用于对成员变量限制其访问权限，成员的访问权限有4种，private、protected、public和友好的，变量的类型可以是任何数据类型，变量的名字是一个标识符。java中成员变量的名字可以与类的方法的名字相同。成员变量对类内定义的方法都有效。类的方法也可定义变量，这种变量称为局部变量，局部变量只在定义它的方法中有效。
3、方法
方法给出对象的行为，方法声明的一般形式如下：返回值类型　方法名（类型 参数名，．．．，类型 参数名）｛方法体｝返回值类型声明方法返回值的数据类型。如果方法无返回值，就用void关键字。方法可以没有参数，多个参数用逗号分隔，参数类型可以是任何数据类型。如果某方法中的参数名或局部变量名与类的成变量名相同，则成员变量在这个方法内暂时被隐藏。如果成员变量在方法内被隐藏，又在方法中要引用成员变量，必须使用this，this表示调用该方法的当前对象。在java程序中，类的方法可以重载。方法重载是指在一个类中定义多个有相同名字的方法，但这些方法的参数个数不同或者按顺序参数的类型不同。
4、构造方法
构造方法是一种特殊的方法，这种方法的名与它的类名相同，并且不返回结果，也不写上void关键字。构造方法的作用是创建类的对象，并给对象初始化。构造方法是公共方法，但程序不能显式调用构造方法。程序运行时，当有对象要创建时，由系统自动调用构造方法。如果类的声明没有定义构造方法，系统就增补一个没有参数的默认构造方法。
3.2.2 对象
类被声明后，就可用类创建对象，被创建的对象称为类的实例。程序使用对象需依次经历4个步骤：声明对象、创建对象、使用对象和撤销对象。
1、声明对象
由于类是一种引用类型，声明对象只

是命名一个变量，这个变量能引用类的对象。由于对象还没有创建，所以也暂不要为对象分配内存。
2、创建对象
创建对象就是为对象分配内存，为对象分配内存也称类的实例化。一般形式为：new构造方法（[参数表])对象创建的两个步骤也可一起完成，一般格式为：类名　对象名＝new构造方法([参数表])
3、对象的内存模型
java语言将类型分成基本类型和引用类型两种。第2章介绍的整型、浮点型、字符型等是基本类型，程序引用这种类型的变量，采用直接访问形式。在java语言中，数组类型和类类型是引用类型。程序访问引用类型的变量采用间接访问方式。程序使用对象有多种情况：或为对象设置状态、或获取对象的状态、或改变对象的状态、或应用对象的某种方法。前三种需要访问对象的成员变量，最后一种要调用对象的方法。程序通过操作符“.”对某对象的成员变量进行访问和方法调用。一般形式为：对象名.成员变量对象名.方法([参数表])
3.2.3 实例变量和类变量
类的成员变量又分为实例变量和类变量。在定义成员变量时，用关键字static修饰的是类变量，定义时未用static修饰的是实例变量。类变量是类的所有对象共享的成员变量，一个类变量在类中只有一个，它属于整个类，而不属于类的某个对象。引用类变量途径有两条，或通过类，或通过对象，格式如下：类名.类变量名　或　对象名.类变量名,不同对象的实例变量将被分配不同的内存空间。改变类的某一个对象的实例变量值不会影响其他对象的实例变量。类变量的内存只有一处，让类的所有对象共享。从类的任一对象改变类变量，类的其他对象都能发现这个改变。
3.2.4 实例方法和类方法
如同类的成员变量有实例变量和类变量两种一样，类的方法也有两种：实例方法和类方法。在方法定义时，冠以修饰字static的方法称为类方法，没有冠以static修饰字的方法是实例方法。类中的实例方法可以互相调用，并可调用类方法。类方法也能相互调用。但不能直接调用实例方法，除非类方法引入局部对象，然后通过局部对象调用实例方法。另外，类方法能直接引用类变量，不能引用实例变量。实例方法可引用实例变量，也可引用类变量。实例方法可以访问类变量和当前对象的实例变量。实例方法必须通过对象调用，不能通过类名调用。类方法只能访问类变量，不能够访问实例变量。类方法除了可以通过实例对象调用之外，还可以通过类名调用。
3.2.5 访问权限
访问权限实现访问控制。在类的成员中引入访问
权限控制，保护类的成员不在非期望的情况下被引用。
在类的声明中，除了

类中方法总能访问类的成员变量
外，java语言为其他类的方法访问本类成员变量和方
法，提供以下4种访问权限：
public:设置没有限制的访问权限，其他类的方法都能访问。private:设置最强的访问权限，其他类的方法都不能访问。protected:只限子类或者同一包中的类的方法能访问。:(无修饰，友好的)只允许同一包中的类的方法访问。
1、public（共有）
类的成员变量被设置成public访问权限，则类外的任何方法都能访问它。
2、private（私有）
类的成员变量被设置成private访问权限，则类外的任何方法都不能访问它。
3、protected（受保护）
受保护访问权限是一种公有权限和私有权限之间的访问权限。若在类A的声明中，成员x被定义成是受保护的，则类A的子类和与类Ａ同一包中的别的类可以访问类A的受保护成员x；但对于不是类A的子类且与类A不在同一包中别的类来说，不可访问受保护成员x。
4、友好变量和友好方法
没有修饰的成员变量和方法称为友好变量和友好方法。与保护访问权限比较，如果只允许同一包中的相关类的方法访问，不让类的子类和其他类的方法访问时，可设置成友好变量和友好方法。
3.2.6、继承
继承是面向对象语言的重要机制。借助继承，可以扩展原有的代码，应用到其他程序中，而不必重新编写这些代码。在java语言中，继承是通过扩展原有的类，声明新类来实现的。扩展声明的新类称为子类，原有的类称为超类（父类）。继承机制规定，子类可以拥有超类的所有属性和方法，也可以扩展定义自己特有的属性，增加新方法和重新定义超类的方法。java语言不支持多重继承，限定一个类只能有一个超类。在子类声明中加入extends子句来指定超类。类声明时，如果缺省extends子句，未指定超类，则该类的超类是系统声明的类https://www.sodocs.net/doc/d318509028.html,ng.Object.子类对父类的继承性，java语言作以下规定：子类自然地继承其父类中不是private的成员变量作为自己的成员变量，并且自然地继承父类中不是private的方法作为自己的方法。超类方法在子类中隐藏称为重写，或置换。当子类中定义的成员变量和超类中的成员变量同名时，超类的成员变量同样会在子类中被隐藏。子类对成员变量的隐藏和方法的重写可以把超类的状态和行为改变为自身的状态和行为。对于子类对象，如果子类重写了超类的方法，则子类对象调用这个方法时，调用子类方法。如果子类继承了超类的方法（未重写），则会调用超类方法。
1、多态性
面向对象语言规定，子类对象也是超类对象，凡超类对象可以应用的地方，子类对象也适用。编译时暂不绑定调用哪个方法，必须

在运行时才绑定调用方法的技术称为动态联编。而代码根据执行时实际对象的类型不同，调用同名的不同方法，是面向对象语言的一种多态性。解决这种多态性必须采用动态联编技术。重载能由调用时提供的参数个数和参数的类型顺序，在编译时就能确定被调用的方法，这种多态性不需要动态联编技术的支持。
2、多层继承
继承声明的新类，又可被其他类再继承，从而构成多层继承。
3、多层继承中构造方法的调用顺序与类的继承顺序一致，从最高层次的超类开始，按继承顺序调用各类的构造方法。如果子类的构造方法要调用超类的构造方法，给从超类继承的成员变量初始化，用代码super（参数）
3.2.7 java面向对象的其他机制
1、final类、final方法和final变量
final的意义是最终的，用于修饰类、方法和变量，其意思是“不能改变”。禁止改变可能是考虑到“设计”和“效率”两个方面。在类声明之前用final修饰，声明类是final类，final类是不能被再继承的类，即它不能再有子类。用final修饰方法，声明该方法不能被子类的方法覆盖。或是为了给方法“上锁”，防止任何子类改变它的本来含义；或是为了提高执行效率，编译器可以将这个方法的所有调用都能用“嵌入代码”实现，即用方法体代码的副本来替换方法调用。用final修饰变量，声明该变量的值不能被改变。不能被改变的变量相当于一个常量。final变量主要用于以下两个方面：或是一个编译期的常数，它永远不会改变；或在初始化后，不希望它现改变。final局部变量在定义时可以暂不设定初值，但是一经初始化，以后就不能再改变。常用final声明常量，常量名习惯全部用大写字母命名。
2、abstract类和abstract方法
abstract类称为抽象类。抽象类只声明一种模板，没有具体实现代码的类。只有它的子类才可能是有实际意义的类。所以，抽象类不可能有实例。abstract方法称为抽象方法。抽象方法只能出现在抽象类 ，抽象方法没有实现的代码。如果一个类是抽象类的子类，则必须具体实现超类的抽象方法。抽象类可以没有抽象方法但有抽象方法的类一定是抽象类。
3、关键字super
子类隐藏了超类的成员变量或者覆盖了超类方法后，利用关键字super，子类方法可以引用超类的成员变量和被覆盖的方法。使用super有3种情况：使用super调用超类的构造方法，使用super调用超类被子类覆盖的方法；使用super访问超类被子类隐藏的成员变量。
4、关键字this
关键字this用来指对象自己。this的作用有多种，例如，将对象自己作为参数，调用别的方法；当方法的局部变量隐藏成员变量时，利用this引用成员变

量；构成函数内调用另一构造函数等。
5、类之间的is-a和has－a关系
在两个相关的类之间，例如，类A和类B，可能会有is-a和has-a关系。类A是继承扩展类B，则子类A和超类B之间是is-a关系，类B的所有成员类A也有，类A也是一个类B。如果类A的某个成员变量的类型是B，则类A和类B之间是has-a关系，即类A包含有类B。类A中成员变量的类型是B。
6、内部类（innerclass）
java语言也允许在类声明内部嵌套类声明。嵌套的类可以是静态的或者是非静态的。静态类不能直接引用其包含类的成员，必须实例化，所以不经常使用。非静态的嵌套类，需要进行事件处理，非常流行。
3.3 接口
java程序中的类只能继承一个类，这种继承称为单继承。java语言虽不允许一个类继承多个类，但允许一个类实现多个接口。接口（Interface）有与类相似的基本形式。接口有常量定义和方法定义，但没有方法的实现代码。可以将接口想象为一个“纯”抽象类。接口给出每个方法的规范：方法的名称、返回值类型、参数个数与参数类型。类除了能继承一个类之外，还可实现多个接口。这样，对有继承并实现接口的类来说，实际上有了多个超类，实现有控制的多重继承。接口是一种只由常量定义和抽象方法组成的特殊类。用public修饰的接口是公共接口，可被所有的类和接口使用；而没有public修饰的接口只能被同一个包中的其他类和接口使用。接口体中的内容是一系列常量定义和方法定义。其中方法定义是一种方法声明，不提供方法的实现（没有方法体），用分号“；”结尾。方法的实现在“使用”这个接口的各个类中，故称使用接口的类为接口的实现。接口的所有变量都默认为是final static属性；所有的方法都默认为是public abstract属性。一个类通过使用关键字implements声明自己使用一个或多个接口。实现多个接口时，接口名之间用逗号隔开。如果一个类要实现某个接口，那么这个类必须实现该接口的所有方法，为这些方法提供实现的方法体。在实现接口的方法时，方法的名字、返回值类型、参数个数及类型必须与接口中定义的方法完全一致，并一定要用public修饰。
3.4 基本类
java语言为一些基本类型设有对应的基本类，如下表所示。
基本类型 对应的基本类 基本类型 对应的基本类
boolean Boolean int Integer
char Character long Long
byte Byte float Float
short Short double Double
基本类型值与对应基本类对象能相互转换。可以利用以下形式的基本类构造方法，由基本类型值得到对应基本类对象：
public基本类（基本类型v）例如，以下代码得到一个Integer对

象，其值是123。Integer n=new Integer（123）；
也可以由基本类对象得到基本类型值。实现方法如以下例子所示：设有 Double类对象dObj，Boolean类对象bObj，代码：doubled=dObj.doubleValue()使得dObj对象的值赋值给double类型变量d。代码：boolean b＝bObj.booleanValue()bObj对象的值赋值给boolean类型变量b。类似的代码可以用于其他基本类对象与对应的基本类型变量。
3.5、java小应用程序基础
java小应用程序即javaApplet，是嵌入在Web页上供浏览器运行的程序，可放在服务器上供客户端下载使用。小应用程序的主要功能是显示图形、动画、播放声音、响应用户事件等。每个小应用程序都得继承java.applet.Applet类。为了系统的安全，对小应用程序有一定限制：不能调用本地的应用程序和运行时的动态连接库；不能访问本地文件，如读、写文件；除原小应用程序所在的位置（站点）外，不能再做网络连接与 www 建立联系，不能获得任何有关系统设置的信息。
1、小应用程序的建立和运行一个小应用程序从建立到运行需经历4个步骤：
（1）用java语言编写小应用程序的源程序。小应用程序由若干类组成，在源程序中必须有一个类继承java.applet.Applet类，这个类是小应用程序的主类。小应用程序的主类，用public关键字修饰。小应用程序的源文件名必须与它的主类名完全相同。
（2）把小应用程序的源程序编译成字节码.class文件。如果源文件有多个类，那么经编译后将生成多个.class文件。
（3）将小应用程序的字节码文件嵌入在 Web页中，设计一个指定小应用程序的HTML文件.html。
（4）在支持java的浏览器上运行。或用观察器appletviewer，或用浏览器Netscape、Hot java、IE等。如果采用某个java开发环境，也可在开发环境下执行小应用程序。
2、Applet类的基本方法
（1）init()方法：初始化，由浏览器载入内存时调用init（）方法，该方法只运行一次。其用途是创建所需要的对象、设置初始状态、装载图像、设置参数等。
（2）start()方法：初始化后，紧接着调用start（）方法，启动小应用程序主线程，或当用户从小应用程序所在的 Web页面转到其他页面，然后又返回时，start()方法将再次被调用。
（3）stop()方法：当浏览器离开小应用程序所在的页面转到其他页面时，调用stop()方法，挂起小应用程序的执行。
（4）destroy()方法：当关闭浏览器时，系统调用destroy()方法，结束小应用程序的生命，关闭线程序释放对象资源。
（5）paint(Graphicsg)方法：该方法用于在屏幕窗口上显示某些信息。如文字、色彩、背景和图像等。当小应用程序启动时，浏览器产生一个Griaphics类的对象，供小应用程序使用，并

以参数g传递给方法paint()。小应用程序可以把g理解为一支画笔。
（6）repaint()方法：为在java页面上显示动态效果，需要repaint()方法，该方法先清除paint()方法以前所画的内容，然后再调用paint()方法。
（7）update()方法：调用repaint()方法时，系统会自动调用update()方法。update(Graphics g)方法是从父类 Applet继承来的，该方法的功能是清除paint()方法以前所画的内容，然后再调用paint()方法。小应用程序重写update()方法，可以达到特定的要求。
3、小应用程序的生命周期（执行过程）
（1）下载并实例化小应用程序，系统调用init()方法。
（2）启动，系统调用start()方法。
（3）小应用程序暂停执行，或因Browser转向其他网面，或小应用程序调用stop()方法，或小应用程序执行paint(Graphics g)方法。
（4）重新启动，或重新进入小应用程序所在页面，重新激活小应用程序，或小应用程序执行paint(Graphics g)方法完成。
（5）终止，或退出浏览器，或执行destroy()消亡方法。
4、小应用程序数据输入输出,小应用程序的数据输入有多种方式。从图形界面的文本框、文本区中输入；也可以采用系统标准输入；还可以由HTML文件中的参数导入。
练习：在java中，能实现多重继承效果的方式是（接口）。分析，java允许一个类实现多个接口，这样对有继承并实现接口的类来说，实际上有了多个超类，实现有控制的多重继承。
类是对一组相同对象的描述，类概括了同类对象的共有性质：（数据和方法）。在已有类的基础上，扩充属性或扩充与改写某些方法，生成新的类，这个方式称为（继承）。（联编）是将发送给对象的消息与含执行该消息的对象连接起来。java语言将类型分为基本类型和（引用）类型两种。一个类通过使用关键字（implements）声明自己使用一个或多个接口，实现多个接口时，接口名之间用逗号隔开。
接口有与类相似的基本形式，接口有常量定义和方法定义，但没有方法的实现代码，接口中给出某种特定功能的一组方法的规范，方法的规范主要包括哪些，主要包括（方法的名称、方法的返回值类型、方法的参数个数与参数类型）
在类D中有定义static int x，请写出在类D的方法中使用x有哪三种不同形式？答案：1、x；2、this.x；3、D.x
在java中使用super有3种情况，请写出这三种情况。答案：1、使用super调用超类的构造方法；2、使用super调用超类被子类覆盖的方法；3、使用super访问超类被子类隐藏的成员变量。
填空题：1、（抽象）是程序设计中最经常使用的技术之一，因为它是有效控制程序复杂性的重要手段。2、在面向对象语言中，对象的名称用于（程序引用

对象），对象的成员变量用于（存储对象的状态信息），对象的方法用于（描述对象的行为）。3、在程序系统中，对象之间的交互通过相互（发送消息）来实现。4、类型适应性多态要求能自动按对象的实际类型正确调用它的方法，类型适应性的多态性需要采用（动态联编）技术来实现。5、如果成员变量x在方法内被隐藏，又要在方法中引用这个成员变量，必须使用（this.x)形式。6、在java程序中，（方法重载）是指在一个类中定义多个有相同名字的方法，但这些方法或者参数个数不同或者按顺序参数的类型不同。7、类是一种（引用）类型，声明对象只是命名一个变量，由于对象还没有创建，所以也暂不要为对象分配内存。
8、类被声明后，就可用类创建对象，被创建的对象称为类的（实例）。9、创建对象就是为对象分配内存，为对象分配内存也称类的（实例化）。10、类声明时，如果缺省extends子句，未指定超类，则该类的超类是系统声明的（https://www.sodocs.net/doc/d318509028.html,ng.Object)类。11、如果子类的构造方法要调用超类的构造方法，给从超类继承的成员变量初始化，用（super(参数))方法。12、多层继承中构造方法的调用顺序与类的继承顺序一致，从（最高层次超类）开始，按继承顺序调用各类的构造方法。13、接口体中的方法定义是一种方法声明，不提供方法的实现，用（分号）结尾。14、如果一个类要实现某个接口，那么这个类必须实现该接口的（所有方法），为其提供实现的方法体。15、在实现接口的方法时，方法的名字、返回值类型、参数个数及类型必须与接口中定义的方法完全一致，并一定要用（public）修饰。
16、基本类型char所对应的基本类为（character），基本类型int所对应的基本类为（Integer）。17、每个小应用程序都必须继承（java.applet.Applet)类。18、当小应用程序启动时，浏览器产生一个Graphics类的对象，供小应用程序使用，并以参数g传递给方法（paint（））。
简答题：1、联编：是将发送给对象的消息与含执行该消息方法的对象连接起来。静态联编：当联编在编译和连接阶段实现时，这样的联编过程称静态联编。动态联编：当联编推迟到运行时间实现时，该联编成为动态联编。2、java构造方法有什么特点？答案：构造方法是一种特殊的方法，方法的名与类名相同，不返回结果，也不写void关键字。其作用是创建类的对象，并给对象初始化，构造方法是公共方法，但程序不能显式调用构造方法。程序运行时，当有对象创建，由系统自动调用构造方法。3、程序使用对象有哪几种情况？其中哪些情况是需要访问对象的成员变量？哪些情况需要调用对象的

方法？答案：使用对象有四种情况，或为对象设置状态、或获取对象的状态、或改变对象的状态或应用对象的某种方法。前三种需要访问对象的成员变量，后一种要调用对象的方法。
4、接口应给出的每个方法的规范有哪些？答案：方法的名称、返回值类型、参数的个数与参数类型。5、如何定义一个逻辑类型变量b并使其对应的基本类对象bObj的值？答案：boolean b=bObj.booleanValue（）；6、为了保证系统的安全，java语言对小应用程序有哪些限制？答案：不能调用本地的应用程序和运行时的动态链接库；不能访问本地文件，如读写文件；除原小应用程序所在的位置外，不能再做网络连接于www建立联系，不能获得任何有关的设置信息。7、子类能继承超类的哪些成员变量和方法？答案：子类能继承超类中不是private的成员变量做为自己的成员变量，自然继承父类中不是private的方法作为自己的方法。
第4章 数组和字符串
4.1 数组
数组是将一组相同类型的数据顺序存储，组成一种复合数据类型。数组的特点主要是：一个数组中的所有元素的数据类型相同，数组中的元素连续顺序存储，数组中每个元素按存储顺序对应一个下标，下标从0开始顺序编号，引用数组元素通过数组名和它的下标确定。数组有一维数组和多维数组之分，数组元素的下标个数确定数组的维数。
4.1.1 一维数组
数组元素只有一个下标的数组是一维数组。
1、声明一维数组
在java语言中，数组是一种引用类型，数组名如同对象名一样，是一种引用。声明数组是声明一个标识符能引用数组，只要指定数组元素的类型。声明一维数组有两种格式：数组元素类型　数组名[]；或者　数组元素类型 []数组名；其中数组元素类型可以是任意的java数据类型（包括类）。
2、创建一维数组
创建数组就是为数组分配存储空间，需指定数组长度。数组创建后，数组名就标识用于存储数组元素的存储空间。创建一维数组的方法有3种：
（1）先声明后创建
创建数组代码的一般形式为,数组名字＝new 数组元素类型[元素个数]；例如，代码：int intArray []；//声明数组intArray,intArray=new int[5]；//创建数组intArray有5个元素，元素下标自0`4
（2）在声明时创建
把声明数组和创建数组的代码结合在一起。例如，代码：int intArray []＝new int[5]；
（3）直接赋值创建
在声明数组时，直接给出数组的初值。例如代码：int []intArray＝{1，2，3，4，5}；
直接赋值创建数组的方法也称为数组初始化。前两种方法创建数组时，系统会给数组元素提供默认初始值：数值型数组元素的默认初值是0；char类型数组元素的默认初值是全0代

码字符；布尔类型数组元素的默认初值是false。在java语言中，所有数组都有一个成员length，程序可以访问它，获得数组的元素个数，但不能改变它。
3、引用一维数组元素
引用一维数组元素代码的一般形式为 数组名［下标］　//引用一维数组元素,数组下标可以是整型常数，或者是整型表达式。数组下标范围是0到数组名.length-1。为了确保程序安全性，java运行系统会对数组下标自动进行范围越界检查。如果发现下标越界，系统将发生异常。
4、数组是一种引用类型
数组也是一种引用类型，一个数组名在不同时间可引用不同的数组。
4.1.2 多维数组
数组元素有多个下标的数组就是多维数组。
1、声明二维数组
声明二维数组的一般形式有以下3种：数型　数组名 [][]；数型 [][] 数组名；类型 [] 数组名 []
2、创建二维数组
创建二维数组对象的方法有多种：
（1）直接分配（平衡二维数组---矩阵）。例如，以下代码创建一个3行5列的矩阵：int myTowArray[][]＝new int[5][5]；
（2）从最高维开始，分别对每一维分配不等长的空间（非平衡的数组）。int a[][]＝new int[3][]；//创建第一维，确定有3个子数组,a[0]＝new int[4]；//第一个子数组有4个元素,a[1]＝new int[5]；//第2个子数组有5个元素,a[2]＝new int[2]；//第3个子数组有2个元素。
（3）直接赋值创建,声明二维数组，同时直接给出各子数组的元素。如果子数组的元素个数不同，则创建的是一个非平衡的二维数组。
3、引用二维数组
二维数组元素的引用方法是：数组名[下标1][下标2]
4、使用二维数组要注意的问题
对于二维数组，要注意以下两点：
（1）二维数组名.length和二维数组名[下标1].length的区别。二维数组名.length是二维数组的子数组个数；二维数组名[下标1].length是指定子数组的元素个数。
（2）二维数组名[下标]是一维数组。
4.2 字符串
字符串是由0个或多个字符组成的序列，java语言提供两个用于处理字符串的类：String类用于处理不可改变的字符串。StringBuffer类用于处理可改变的字符串。
4.2.1 字符串常量
字符串常量是用双引号括起来的一个字符串。在java语言中，字符串常量是匿名的String对象。
4.2.2 字符串声明和创建
如同一般用类声明和创建对象一样，可用String类
声明和创建字符串。
利用String类的构造方法可以创建字符串对象，
String类的构造方法有：
（1）String()，创建一个空字符串对象。例如：ｓ＝new String()；
（2）String(String str)，根据给定的字符串str创建符串对象。例如：利用字符串常量创建字符串：s＝new String(I am a student)；或简写成：ｓ=I am a student；字符串声明和创建也可一起完成：

String s＝new String(I am a student)；以下代码用字符串对象创建新字符串：String newStr=new String(s)；上述代码使字符串newStr与字符串s的内容相同，但是，它们是两个字符串。
（3）String(char a[]），根据字符数组a创建一个字符串。
（4）String(char a[]，intstartIndex,intcharNum)，
根据字符数组的起始下标位置以及字符个数创建字符串。例如，以下代码输出3456。char a[]={1,2，3，4，5，6，7}；String a＝new String(a,2,4)；System.out.pringln(s)；
4.2.3 字符串基本操作
java语言为便于程序使用字符串，为字符串提供非常丰富的操作。
（1）字符串连接
字符串有一个连接运算符＋，得到连接两个字符串的结果；一个连接方法concat(String s)，实现复制参数s字符串的内容，连接在字符串对象之后，得到一个新的字符串。
（2）获取字符串的长度
length()方法可以获取一个字符串的长度。字符串常量也可以使用length()方法获得长度。
（3）字符串前缀或后缀的比较
用boolean starsWith(String s)方法判断一个字符串的前缀是否为字符串s。用boolean endsWith(String s)方法判断一个字符串的后缀是否为字符串s。
（4）比较两个字符串是否相同
用boolean equals(String s)方法比较某字符串是否与字符串s相同。
注意两字符串比较与两个字符串引用对象比较的区别。比如，表达式str1.equals(str2)与表达式str1==str2的差异。前者表示所引用的两个字符串的内容是否相同，后者表示str1与str2是否引用同一个对象。
用boolean equalsIgnoreCase(String s)方法，忽略大小写比较某字符串是否与字符串s相同。用int compareTo(String another)方法按字典顺序与参数another字符串比较大小。用int compareToIgnoreCase(String s)方法，忽略大小写，按字典顺序与参数s字符串比较大小。
（5）字符串检索
用String类中的方法int indexOf(String s)或int indexOf(String s,int startport)实现字符串检索。前一个方法是从指定字符串的头开始检索参数字符串s，返回字符串s首次出现的位置。后一个方法则在指定字符串中从某个位置开始检索参数字符串s，返回字符串s首次出现的位置。如果没有检索到，则返回-1。
（6）取字符串的子串
使用string类中的方法：String substring(int startpoint)，String substring(int startpoint,int end)；其中startpoint是字符串的开始下标，end是截止下标。子串是从开始下标开始，至截止下标的前一个下标为止范围内的子串。
（7）替换字符串中的某字符得到一个新字符串
使用String类中的方法String replace(char oldChar,char newChar)用参数newChar指定的字符替换s中由oldChar指定的所有字符，产生一个新的字符串。
（8）去掉前后空格得到一个新字符串方法trim()可以去掉字符