Java 语言基础

摘自 《永中 Office 二次开发编程手册》，

个人认为是非常到位的java基础语法手册

此外推荐大家了解网络化Office，关注中国的Office

http://www.evermoresw.com.cn/webch/macro/builtinBrowser.jsp

1.1java 的字符集

Java 的符号是构成程序的基本单位，java 采用的是 Unicode 字符集，从而可更好的提供多
语言的支持。
Unicode 是一种用以取代标准 ASCII 字符集的新的编码标准，这种标准把 ASCII 码的 8 位
字节扩展为 16 位的字节。Unicode 扩展了标准 ASCII 字符集，使之增加了许多非拉丁语字
符。
Java 编译器可以识别五种类型的符号：标识符、关键字、常量、运算符及分隔符。

1.1.1注释

Java 支持 3 种方式的注释。
方式 1. // 注释内容
从 // 起到行结束的所有字符均为注释因而被编译器忽略。
例如：//注释一行
方式 2. /*
* 注释内容
*/
/ * 和 */之间的所有字符均为注释，因而被编译器忽略。这些注释能扩展到多行，但
不能嵌套。
例如：/*注释一行或多行 */
方式 3. /**
* 注释内容
*/
这种注释方式主要是为了支持 JDK 工具 Javadoc 而引入的，Javadoc 能识别注释中用@
标识的一些变量，并把 doc 注释加入到它所生成的 HTML 文件中。这种注释出现在类型说
明前面。

1.1.2标识符

标识符是为了使变量，类，方法能被编译器识别而提供的具有唯一性的名字。Java的标识

符是字母数字的有限序列，它必须以字母，下划线或美元符开始，随后的字符还可以用数字
0~9。由于 Java 使用 Unicode 字符集，其字母不仅仅是 26 个字母，而且还可以是其他语言
中的文字，如汉字等。具体地说，它可以包括：
（1）大小写字母，即 ASCII 码中的 A～Z 或 a～z 之间的字符。
（2）数字 0～9 之间的数字。
（3）下划线（_）或美元符（$）。
（4）unicode 字符集中所有编码大于 0xc0 的字符，其中包括汉字。
说明：
a. Java 关键字不能作为普通标识符使用。
b. 标识符不宜过短，过短的标识符会导致程序的可读性差。但也不宜过长，否则将增加录
入工作量和出错的可能性。
c.为了增加程序的可读性，在 Java中，用户定义的标识符一般以小写字母开头，而系统
所定义的标识符如类名、接口名、方法名等大部分以大写字母开头，在使用中应加以注意。

1.1.3关键字

关键字是 Java 语言本身使用的标识符，又称保留字，不能另作它用。
Java 语言使用的全部关键字如下：
abstract
byvalue
continue
false
for
import
long
protected
static
this
true
boolean
case
default
final
goto
instanceof
native
public
super
threadsafe
try
break
cast
do
finally
if
int
package
return
switch
throw
void
byte
class const
double
float
implements
interface
private
short
synchronized
transient
while

1.1.4分隔符

在 Java 语言的规范中，分隔符则告诉编译器如何分隔和组合代码。
Java 中使用如下分隔符：
() {} [] ; '
空格、制标符、换行符以及注释符，是特殊的分隔符，用来分隔其他标记。

1.2java 数据类型

1.2.1常量

常量是不能被程序修改的固定值。常量是直接放入程序中的值，而变量代表存放信息的存储
单元。常量和变量一样都有数据类型，java常量包括整数、浮点、布尔、字符和字符串五
种，以下分别是 Java 常量的表示方法。
1.整数型常量
Java 的整数常数有三种形式：
第一：十进制整数。
例如： 123 ,－456 , 0
第二：八进制整数，以 0 开头。
例如：0123 表示十进制数 83。
第三：十六进制整数，以 0x 或 0X 开头。
例如：0x123 表示十进制数 291。
整数型常量在机器中占 32 位，具有 int 型的值，对于 long 型值，则要在数字后加 L 或 l。
例如：123L 表示一个长整数，它在机器中占 64 位。
2.浮点型常量
浮点数可用一般表示法或科学记数法表示。
一般表示法为：10 进制整数、小数点和 10 进制小数。
例如：3.14159。
科学记数法表示为：10 进制整数、小数点、10 进制小数、E 或 e、指数和正负号。
例如：1.235e5

Java 的浮点数常量在机器中有单精度和双精度之分。单精度以 32 位形式存放，书写时可用
f 或 F 标记；双精度则以 64 位形式存放，书写时可用 d 或 D 标记。
例如：3.1f 或 3.1F表示单精度浮点数常量。
例如：3.1d 或 3.1D 表示双精度浮点数常量。
若一个浮点数常量没有特别指定为双精度时，则它为单精度浮点数常量。
3.布尔常量
布尔常量用于表示真（true）和假（false）两种状态，在机器中的表示只有一位。
4.字符常量
Java 的字符常量是用单引号括起来的一个字符。
例如：'a'。
除了以上形式的字符常量外，Java 还充许使用一种特殊形式的字符常量，它以一个"\"开
头的字符序列，这种特殊字符称为转义字符。
常用转义字符表如下：
功能
回车
换行
水平制表
退格
字符形式
\r
\n
\t
\b

进纸
反斜线
单引号
双引号
八进制位模式
十六进制位模式
Unicode 字符

5.字符串常量
字符串常量是用双引号括起来的字符序列。
例如："Hello"。

1.2.2整数类型

\f
\\
\'
\"
\ddd
\Xdd
\Udddd

Java 取消了 unsigened（无符号数）的含义，java 的所有数字类型数都含有符号。因 java
缺少无符号类型，这样将整数类型限定为只有 4 种，它们分别为 byte、short、int、和 long，
所占字节数分别为 1、2、4 和 8。
1.byte（字节）
byte 是一个带符号的 8 位类型，范围从－128 到 127。
例如：byte a; //表示声明了变量 a。
byte d = 0x68; //表示声明了变量 d，并给 d 赋十六进制初值 0x68。
2.short（字）
short 是一个带符号的 16 位类型，范围从－32768 到 32767。
例如：short a;
short d = 0x68bb;
3.int（双字）
int是一个带符号的 32 位类型，范围从－2147483648 到 2147483647。int 类型是一种最丰
富最有效的类型。它最常用于计数、数组访问和整数运算。任何一个带有 byte、short、int
和常量的整数表达式中，在计算前 Java 都会提升成 int 型。
例如： short a;
short d = 0x68bb1111;
4. long（四字）
long 是一个带符号的 64 位类型。范围从－92233720368477808L 到 92233720368477807L。
例如：long a;
long d = 0x68bb111122223333

1.2.3浮点数类型

浮点数也称为实数，它分为 float（单精度）和 double（双精度）两种。
1.float
float 是一个单精度 32 位的浮点数，其范围：3.4e－038 ～ 3.4e＋038。
例如：float a;

float d = 3.1418F;
2.double
double 是一个双精度 64 位的浮点数，其范围：1.7e－308～ 1.7e＋308。Java 的所有几
何函数如 sin、cos、sqrt 等都返回到双精度值。
例如：double a;
double d = 3.1418D;

1.2.4字符类型

char 是存储字符的数据类型，其宽度为 16 位，范围是 0～ 65535。char 类型用来表示在
Unicode 编码表中的字符。前缀\u 表示是一个 Unicode 值。
例如：char a = 's';
char d = '\u005c';

1.2.5布尔类型

Java 有一个简单的数据类型，即布尔类型叫做 boolean，其值有两个：true 和 false。
例如：boolean a = true;
boolean d = false;

1.2.6String 类

字符串是指字符的序列，例如"hello"。Java 没有内置的字符串类型。实际上，标准 Java
库中有一个叫做 String 的预先定义的类，每个被引号引起来的字符串都是 String 类的一个
实例。例如：
String he = "hello"; //这是一个包含"hello"元素的字符串
String empty = ""; //这是一个空字符中
String blank = " "; //这个字符串只包含一个空格字符
创建一个字符串
String 类用于表示在运行时长度固定不变的字符串。String 类重载了多个构造函数，以便
您有多种方式创建 String 对象。缺省状态下，构造函数没有参数。
String s1 = "hello"; //使用双引号之间指定的字符串直接值
String s2 = new String("hello"); //使用 new 操作符创建一个新对象
这两种方法都正确，并且编译生成的代码也一样，但第一行语句使用更普遍。因为 Java 平
台为它遇到的每个字符串直接值自动创建一个新的 String 对象。
注 意 ： 可 以 在 任 何 应 该 使 用 String 对 象 的 地 方 使 用 字 符 串 直 接 值 。 例 如 ，
System.out.println 接受一个 String 参数，所以可以在此处使用字符串直接值：
System.out.println ("Might I add that you look lovely today");
还可以直接从字符串直接值使用 String 类的方法，例如：
int len = "Goodbye cruel world".length ();
获得字符串的长度
用于获取关于对象的信息的方法称为访问器方法（accessor method）。可以通过访问器方法

length 方法得到字符串中包含的字符数。例如：
String str = "Java is a language.";
int len = str.length();
System.out.println("len = "+len);
执行此段代码后，在屏幕上打印结果为：len = 19
通过索引从字符串中得到字符或字符串
您可以使用 charAt 访问器方法得到字符串中某索引位置上的字符。每一个字符的索引为 0，
最后一个字符的索引为 length()-1。例如，下面的代码得到字符串中索引 11 位置上的字符：
String str = "Java is a language.";
Char c = str.charAt(11);
索引从 0 开始，所以索引 11 位置上的字符是"a"，见图 1-1：
012345678910 11 12 13 14 15 16 17 18
Java is a language.

charAt(0)

charAt(11)

charAt(length()-1)

图 1-1 使用 chatAt 方法得到某索引位置上的字符
此图还说明，要计算字符串的最后一个字符的索引，必须将 length 方法返回的值减 1。
如果要从字符串中得到多个字符，可以使用 substring 访问器方法。substring 方法的工作
原理是 Java 以特定的方式根据偏移量和计数值获得字符串中某些字符的拷贝。
String substring (int) 返回这个字符串指定位置后所有字符组成的子字符串。参数为子
字符串在字符串中的起始索引值。
String substring (int, int) 返回这个字符串指定区域内的所有字符组成的子字符串。第
一个参数为子字符串在字符串中的起始索引值，第二个参数为子字符串最后一个字符在字符
串中的下面的代码从字符串中提取索引为 10 到 18 的子字符串，即单词"language"，见图
1-2：

012345678910 11 12 13 14 15 16 17 18
Java is a
language.

substring (10, 18)
图 1-2 使用 substring 方法得到字符串中的一部分

在字符串中搜索字符或子字符串
String 类提供两个访问器方法 indexOf 和 lastIndexOf 用于返回特定的字符或子字符串首
字符在字符串中的位置。indexOf 方法从字符串的开头向前搜索，lastIndexOf 方法从字符
串的末尾向后搜索。如果在字符串中没有找到特定的字符或子字符串，则返回值为-1；如果
特定的字符或子字符串正好在字符串的起始位置，则返回值为 0；如果特定的字符或子字符
串在字符串的末尾，则返回值为 length () -1。这样，如果想知道特定的字符或子字符串
是否在字符串中只需判断返回值是否为-1 就可以了。见图 1-3：

012345678910 11 12 13 14 15 16 17 18
Java is a
language.

indexOf ('a')

indexOf ("language") lastIndexOf ('a')
图 1-3 使用 indexOf 方法搜索字符或子字符串

表 1-1 说明了 indexOf 和 lastIndexOf 方法的各种形式。

表 1-1 String 类中的 indexOf 和 lastIndexOf 方法
方法
int indexOf (int)

int lastIndexOf (int)

int indexOf (int, int)
int lastIndexOf (int, int)

int indexOf (String)
int lastIndexOf (String)

int indexOf (String, int)
说明
从字符串的开头向前（末尾向后）搜索字符并返回参数指
定的字符在字符串中的位置
注意：参数为此字符的 ASCⅡ码，以 16 进制表示，通常情
况下可以直接传一个 char 类型的字符，因为 Java 平台能
够将 char 与 int 值做自动转换

从字符串的指定索引位置起向前（向后）搜索字符并返回
参数指定的字符在字符串中的位置

从字符串的开头向前（末尾向后）搜索子字符串并返回参
数指定的子字符串在字符串中的位置

从字符串的指定索引位置起向前（向后）搜索子字符串并
intlastIndexOf(String, 返回参数指定的子字符串在字符串中的位置
int)
比较字符串和和部分字符串
如果想判断两个字符串中的内容是否相同，首先想到的是使用= =号来判断两个字符串。
String s1 = "abc";
String s2 = "abc";
if (s1= =s2)
{
System.out.println ("s1 与 s2 的内容相同");
}
else
{
System.out.println ("s1 与 s2 的内容不同");
}
结果屏幕打印出的内容大失所望，为"s1 与 s2 的内容不同"。两个内容完全相同的字符串
为什么判断出不相等呢？纠其原因是，初始化变量 s1，s2 时 Java 平台给其在内存中分配了
两个存储空间，所以这两个变量分别指向不同的存储空间。= =号的作用是判断两个变量指
向的存储空间地址是否相同，即两个变量是否指向同一个存储空间。显然，这两个变量指向
不同的存储空间，所以最后两个变量不相等，但是这两个变量的内容应该是相同的。那用什
么办法来判断两个字符串的内容相同？很简单，String 类已经提供了 equals 方法供您调用。

boolean equals (Object) 如果这个字符串包含与参数一样的字符序列，那么返回 true，
否则返回 false。注意：在进行比较前 Object 参数会被转换为字符串。实际上，每个对象
都提供了一个 equals 方法用来比较对象是否相同，因为所有的对象都是从超类 Object 中继
承而来的，而 Object 类已经默认提供了这个方法，其它的子类可以重载这个方法以适应用
户的需要。
这样我们可以改写上面的程序：
String s1 = "abc";
String s2 = "abc";
if (s1.equals(s2))
{
System.out.println ("s1 与 s2 的内容相同");
}
else
{
System.out.println ("s1 与 s2 的内容不同");
}
结果屏幕打印的内容正如我们要求的那样，为"s1 与 s2 的内容相同"。
boolean equalsIgnoreCase (String) 此方法与 equals 方法的区别是，前者在比较两个字
符序列时可忽略大小写，而后者需两字符序列完全相等时才返回 true。
如 果 希 望 知道 特 定 字 符或 子 字 符 串是 否 在 字 符串 的 开 头 或末 尾 可 以 通过 访 问 器 方法
startsWith 和 endsWith 来判断。
boolean startsWith (String) 如果参数指定子字符串的首字符位于字符串的起始位置，则
返回 true。
boolean endsWith (String) 如果参数指定子字符串的尾字符位于字符串的结束位置，则返
回 true。
例如：
String s1 = "Evermore is software company.";
String s2 = "Evermore";
String s3 = "is";
String s4 = "company";
System.out.println ("s2 startsWith s1 = "+s1.startsWith (s2));
System.out.println ("s3 startsWith s1 = "+s1.startsWith (s3));
System.out.println ("s4 startsWith s1 = "+s1.startsWith (s4));
屏幕打印的内容分别为：s2 startsWith s1 = true
s3 startsWith s1 = false
s4 startsWith s1 = false
第三个结果为 false 是因为字符串的结尾是句号"."，如果 s4 替换为"company."则返回
true。
表 1-2 说明了字符串比较的其它方法。
表 1-2 String 类中用于比较字符串的方法
方法
boolean endsWith (String)
boolean startsWith (String)
boolean startsWith (String, int)
说明
如果此字符串是以方法参数指定的子字符串开头
或结尾的，那么返回 true。整数参数（如果存在
的话）表示在原始字符串中开始查看的偏移量

int compareTo (String)
int compareTo (Object)
int compareToIgnoreCase (String)

boolean equals (Object)
boolean equalsIgnoreCase (String)

按字典编排次序比较两个字符串，并返回一个值
表示此字符串是大于（结果大于 0）、等于（结果
等于 0）、小于（结果小于 0）参数。在进行比较
前Object参 数 被 转 换 为 字 符 串 。
compareToIgnoreCase 方法忽略大小写；所以"a"
和"A"被认为是相等的

如果这个字符串包含与参数一样的字符序列，那
么返回 true。在进行比较前 Object 参数被转换
为字符串。equalsIgnoreCase 方法忽略大小写；
所以"a"和"A"被认为是相等的

boolean regionMatches (int, String, 检查这个字符串的指定部分是否匹配 String 参
int, int)
数的指定部分。布尔参数指出是否应该忽略大小
boolean regionMatches (boolean, int, 写；如果是 true，那么在比较字符时忽略大小写
String, int, int)
字符串的连接
字符串不能被修改，但是可以通过多个原字符串创建一个新的字符串。像大多数程序设计语
言一样，Java 允许使用符号"+"把两个字符串连接起来。例如：
String s1 = "Good Morning,";
String s2 = "How are you";
String s3 = s1 + s2;
上述代码将使字符串变量 s3 的值为"Good Morning,How are you"，注意：在单词间没有空
格，符号"+"把两个字符串按给定的顺序连接在一起，并且是完全按照给定的形式。
当使一个字符串和一个不是字符串的值相连接时，后者将转换成字符串（每个 Java 对象都
可以转换成字符串，因为 Object 类是所有的 Java 对象的超类，Object 类中定义了 toString
方法，作用是打印出当前对象的内容）。例如：
int time = 13;
String message = "It is "+ time + "o'clock";
上述代码的作用是将字符串"It is 13 o'clock"赋给变量 message。这样我们知道在同
一表达式中符号"+"可以同时连接多个字符串。
其它字符串的操作
String 类有几个方法看起来可以修改字符串。当然，字符串是不能被修改的，所以这些方
法实际上是创建并返回包含结果的第二个字符串，见表 1-3：
表 1-3 String 类中用于操作字符串的方法
方法
String concat (String)
说明
将 String 参数连接到这个字符串的末尾。如果参数的长
度为 0，那么返回原始字符串对象

String replace (char, char) 将第一个参数指定的字符替换为第二个参数指定的字
符。如果不需要进行替换，那么返回原始字符串对象

String trim ()

删除这个字符串两端的空格后返回这个对象

String toLowerCase ()
String toUpperCase ()

1.3数组

分别将这个字符串转换为小写或大写。如果不需要进行
转换，那么返回原始字符串

数组是一种数据结构，它用来存储具有相同类型的一组数据。通过一个整数下标（index）
可以访问其中的每一个值。例如，假设 array 是一个整数数组，那么 array [i]则是此数组
中的第 i 个数据。
通过指定数组类型可以声明一个数组变量。指定数组类型时，先写上元素的数据类型，紧接
着是[ ]，最后是数组变量的名字。例如，下面是对整数数组 array 的声明：
int [] array;
你也可以将数组声明写成下面这样：
int array [];
但是，不鼓励使用这种形式，因为方括号标识数组类型，它们应该与类型说明放在一起，而
不是与数组名放在一起。
然而，上述语句只是声明了变量 array，它没有把 array 初始化为一个真正的数组。与其他
类型的变量声明一样，数组变量的声明并不创建数组，也不为包含数组元素而分配任何内存。
代码必须显示地创建数组并将它赋值给数组名 array。你可以使用 new 运算符创建数组：
int []array = new int [100];
此语句创建了一个可以存储 100 个整数的数组。数组下标从 0 到 99（而不是从 1 到 100）。
一旦创建了数组，就可以给数组的每一个元素赋值。例如，通过一个循环进行赋值：
int [] array = new int [100];
for (int i=0; i<100; i++)
{
array [i] = i;
}
数组元素是数组包含的值之一，一个数组中包含多个数组元素，可以按它在数组中的位置（索
引）访问它。数组索引从 0 开始，直到数组长度减 1。如：array [i]就表示数组 array 中
第 i 个索引位置中存储的数据，它是一个数组元素。
注意：如果创建了一个具有 100 个元素的数组，而试图访问元素 array [100]（或任何在范
围 0...99 之外的下标）时，程序会以"array index out of bounds"异常而终止。
如何得到一个数组的长度？利用 arrayName.length 可以知道一个数组的长度。注意：不熟
悉 Java 编程语言的程序员会在 length 后面加一对空的圆括号，这是不对的，因为 length
不是一个方法，而是 Java 平台为所有数组提供的一个属性。例如：
for (int i=0; i< array.length; i++)
{
System.out.println (array [i]);
}
上述代码将打印数组 array 中的各个数组元素的值。其中 array 为数组的名字，它指向了这
个数组在内存中的实际位置，相当于一个对象的对象名，以后在使用中只要通过数组名就能
对数组进行各种操作。
注意：数组一旦被创建，它的大小是不可改变了（尽管可以改变其数组元素）。

1.3.1数组初始化和匿名数组

Java 中有一个创建数组对象并同时对其初始化的简写方式，下面是关于其语法的一个例子：
int [] smallPrimes = {2, 3, 5, 7, 11, 13};
注意在此语法中并没有使用 new 运算符。甚至可以寝化一个匿名数组：
new int [] { 17, 29, 23, 29, 31, 33};
这个表达式分配了一个新的数组，并通过花括号中的数据对其赋值。它会计算初始化值的数
量并设值与其相应的数组大小。可以利用此语法重新初始化一个数组而不必创建一个新的变
量。例如：
smallPrimes = new int []{ 17, 29, 23, 29, 31, 33};
这是对下面语句的简写形式：
int [] anonymous = { 17, 29, 23, 29, 31, 33};
smallPrimes = anonymous;
注意：长度为 0 的数组是合法的。这种数组适用于以下情况：当编写一个方法以计算数组结
果时，其结果碰巧为空。可以按照下面的语法创建长度为 0 的数组：
smallPrimes = new elementType [0];
长度为 0 的数组与 null 是不同的。
对象数组
数组用来存储具有相同类型的一组数据，这个类型除了 int、float、boolean 等基本数据类
型外，还可以是任何一种对象类型，即数组的数据类型可以是任意一个类，这种存储对象类
型的数组就称为对象数组。声明对象数组与声明普通数组一样，只是元素类型改为对象类型。
下面这个小程序创建一个包含三个字符串对象的数组。然后它以小写字母输出这些字符串：
public class ArrayOfStringsDemo
{
public static void main (String [] args)
{
String [] anArray = { "StringOne", "StringTwo", "StringThree"};
for ( int i = 0; i < anArray.length; i++ )
{
System.out.println (anArray[i].toLowerCase ());;
}
}
}
此程序的输出是：
StringOne
StringTwo
StringThree

此程序使用一个数组初始化顺在单个语句中创建和填充数组。下一个程序用 Integer 对象填
充数组。注意，在 for 循环的每次抚今追昔中，程序创建一个 Integer 对象并将它放到数组
中：
public class ArrayOfIntegersDemo
{

}

public static void main (String [] args)
{
Integer [] anArray = new Integer [5];
for ( int i = 0; i < anArray.length; i++ )
{
anArray [i] = new Integer (i);
System.out.println (anArray [i]);
}
}
此程序的输出是：
0
1
2
3
4
5
6

请注意：上面程序中的以下代码行创建一个数组，但没有在其中放任何元素：
Integer [] anArray = new Integer [5];
在使用包含对象的数组时，这常常给新程序员带来困惑。前面的代码行执行之后，称为
anArray 的数组已经存在，并具有足以容纳 5 个整数对象的内存空间。但是，此数组还不包
含任何对象，它是空的。程序必须显式地创建对象并将它们放在数组中。这看起来很明显，
但许多初学者认为前面的代码行创建一个数组并在其中创建 5 个空对象。所以，他们会写下
面这样的代码，此代码将产生一个 NullPointerException（空指针）异常：
Integer [] anArray = new Integer [5];
for ( int i = 0; i < anArray.length; i++)
{
//注意：此行代码将产生 NullPointerException 异常
System.out.println (anArray [i]);
}
上述程序的第一行是声明一个对象数组。默认情况下（没有进行初始化），对象数组的数组
元素为空对象。所以，在程序中的其他地方使用数组时必须格外小心，很可能出现空指针问
题。

1.3.2多维数组

多维数组其实就是数组的数组。例如，一个二维数组类似于具有行和列的表格。然而，在
Java 中，行的长度并不会完全一样，这一点与其它编程语言提供的多维数组不一样，这使
得数组在运行期间构造具有很大的优越性。
用多个空方括号可以声明一个多维数组。例如：
double trouble [] []；

它声明 trouble 是具有浮点 double 值的二维数组的引用。用下面的语句可在运行期间定义
该数组的空间大小，它创建一个 10×10 的 double 型数组：
trouble = new double [10] [10];
这两个值也可以不同：
这就创建了一个具有 10 行，每行 20 个值的数组。注意：方括号中的数字必须是一整形值，
表示数组的大小。这里第一个整形值相当于表的行数，第二个整形值相当于表的列数。在运
行期间仅第一个值必须指定（但它可以是变量）。例如，前面的语句相当于下面的代码：
trouble = new double [10] [ ];
for ( int i = 0; i < trouble.length; i++)
{
trouble [i] = new double [20];
}
这段语句首先定义一个用于 double 值的 10 个元素数组的空间，并用 trouble 来引用这空间，
然后一个 for 循环创建了 20 个元素的数组，并赋给 trouble 的每个元素。注意：表达式
trouble[i]的数据类型本来就是一个数组 double[ ]，它是具有 double 值的数组的一个引
用。
下面这个小程序显示了如何创建一个二维数组的全过程：
public class ArrayOfArrays
{
public static void main (String [ ] args)
{
// 声明一个二维数组，第一个值必须指定，第二个值可有可无
int [ ][ ] matrix = new int [4][ ];
// 初始化这个二维数组，初始化赋值时从二维数组的行开始遍历，先将第一行数
组的各列按顺序赋值，然后再将第二行，第三行，以此类推直至最后一行（当前
程序是第四行，i = 3，因为数组的标号都是从 0 开始的）分别赋值
for ( int i = 0; i < matrix.length; i++ )
{
matrix [i] = new int [5];
for ( int j = 0; j < matrix[i].length; j++)
{
matrix [i][j] = i + j;
}
}
// 下面的程序用来打印这个二维数组的内容
for ( int i = 0; i < matrix.length; i++ )
{
for ( int j = 0; j < matrix[i].length; j++)
{
System.out.print ( matrix [i][j] + " ")
}
System.out.println ();
}
}

}
此程序的输出是：
01 2 3 4
12 3 4 5
23 4 5 6
34 5 6 7

以上程序显示了创建一个 4×5 的二维数组，相当于下面这张 4 行 5 列的二维表格：

0 1 2 3 4
0 01 2 3 4
1 12 3 4 5
2 23 4 5 6
3 34 5 6 7

多维数组可以是一个超出两维的数组。例如下面的语句：
double fifthDimension [ ][ ][ ][ ][ ];
它定义 fifthDimension 为一个具有 double 值五维数组，这并没有太多的实际价值，因为很
少使用超出三维的数组。尽管 Java 并未限制维数的多少，但如果数组的维数太大将极大地
占 用 大 量 的 内 存 空 间 ， 最 终 占 用 我 的 计 算 机 的 所 有 内 存 和 磁 盘 空 间 ， 并 出 现
OutOfMemoryError 异常。

1.3.3数组异常

NegativeArraySizeException：假设语句用负的标号值构造一数组结构，将出现这个异
常。 这在用整形变量来指定数组大小时容易出现这个异常。
ArrayIndexOutOfBoundsException：假设语句试图用一个小于零或大于数组长度的标号
值来访问数组元素将出现这个异常。
ArrayStorExcception：假设数组将错误类型的数据对象存入数组中将出现这个异常。

1.4变量

变量是一个用来存取某种类型值的存储单元，其中存储的值可以在程序的执行过程中修改。
每个变量都有相应的类型，变量的类型即可以是基本类型，也可以是引用类型，变量中包含
的值必须与它的类型相适应。

1.4.1变量定义

在 Java 中，要求对所有用到的变量必须先定义后使用。对变量的定义就是给变量分配相
应类型的存储空间。定义变量的一般形式为：
变量类型变量名称 ;

当要定义多个变量时，各变量之间用逗号隔开，变量名必须是合法的 Java 标识符。
变量名称是程序引用变量值的手段。Java中的变量名除符合标识符的条件之外还必须满
足下列约定：
1. 变量名不能与关键字相同。
2. 在同一个作用域内不允许出现声明相同的变量名。
例如： String name;

1.4.2类型转换

将某些类型的值按另一种类型保存到变量中，需要类型的强制转换。Java中的类型转换有
两种形式。
1.自动类型转换
有些类型的值可以不用转换就能保存到另一种类型变量中，这种形式叫自动类型转换。
在 Java 中，只有编译器知道目的变量有足够精度存放源变量时才允许自动类型转换。
2.强制类型转换
在 Java 中，强制类型转换常被用于一个较大类型的值存入到较小类型的变量中，这种方
式称为"压缩"方式。
强制类型转换的格式为：
（type）value
例如：
int a = 200;
byte b = (byte) a;
注意：
（1）如果 byte、short 和 int 类型的变量出现在表达式中，为防止溢出，其结果肯
定提升为 int 类型。如果用到了 long 类型，则整个表达式的类型为 long 类型。凡整数常
量后未加 L 或 l 时一律按 int 类型处理。
（2）如果表达式含有 float 类型，那么整个表达式提升为 float 类型。如果有 double 操作数，
其结果肯定为 double 类型。缺省情况下，所有的浮点数常量值均为 double 类型。

1.5运算符与表达式

1.5.1运算符与表达式

Java 运算符是一种特殊字符，它指明用户想对操作数进行的某种操作，由编译器进行解释。
操作指令由运算符指出，而操作数由变量、表达式或常量组成。Java 内部有 44 个运算符。
表达式是运算符、常量和变量的组合。
Java运算符根据功能可分为：赋值运算符、算术运算符、关系运算符、位运算符和布尔运
算符。

1.5.2赋值运算符

（1）赋值符号"＝"就是赋值运算符，它的作用是将一个数据赋给一个变量。
例如：x = 18 ;
（2）如果赋值运算符两侧的类型不一致，在赋值时要进行类型转换。

1.5.3算术运算符

算术运算符用于算术运算。算术运算符有单目运算符和双目运算符两种。Java的单目运算
符包括单目减（－）、递增（＋＋）和递减（--）三种情况。单目减只改变某数的正负号，
而不改变该数的绝对值。递增、递减是使某变量的值增 1 或减 1。
Java 算术运算符如下：
运算符
+
-
*
/
%
++
--
+=
-=
*=
/=
%=

说明：
功能
加
减（可作单目减运算）
乘
除
取模（返回除法的余数）
递增（单目运算）
递减（单目运算）
相加并赋值
相减并赋值
相乘并赋值
相除并赋值
取模并赋值
（1）出现在算术表达式中的操作数必须是数字类型，不能对 boolean 类型使用这些运算符，
但 char 类型是个例外，因为在 Java 中，char 类型是 int 类型的子集。
（2）取模运算"％"返回的是除法的余数
（3）算术赋值运算符是一组特殊的运算符，它把算术运算符与赋值运算符组合在一起。其
运算规则是先进行算术运算后赋值。在使用算术赋值运算符时，必须理解为将运算符左边的
变量与右边的表达式进行运算之后，再将结果赋给左边的变量。
（4）递增、递减运算符的作用是使变量的值增 1 或减 1。

1.5.4关系运算符

关系运算是逻辑运算中比较简单的一种。所谓"关系运算"实际上是"比较运算"，也就是
将两个值进行比较，判断比较的结果是否符合给定的条件。这样，就引入了关系运算符。因
此关系表达式的值：如果条件满足，值为"真"（即true）；如果条件不满足，值为"假"，
（false）。
Java 关系运算符如下：
运算符
==
名称
等于

!=
>
<
>=
<=

不等于
大于
小于
大于或等于
小于或等于
关系表达式：是指用关系运算符将两个表达式（可以是算术表达式、赋值表达式、字符表达
式）连接起来的式子，称为关系表达式。

1.5.5逻辑运算符

Java 提供的逻辑运算符如下：
运算符
&
|
^
&&
||
!
名称
逻辑与
逻辑或
逻辑异或
快速逻辑与
快速逻辑或
逻辑非（单目）
逻辑运算符涉及的操作数只能是布尔类型。!是单目运算符，只要求有一个布尔类型的操作
数。
逻辑表达式：用逻辑运算符将关系表达式或布尔（boolean）量连接起来的式子称为逻辑表
达式。逻辑表达式的值是个布尔量"true"或"false"。

1.5.6位运算符

位运算符用来对整型（long、int、short、char 和 byte）数中的位进行测试、置位或移位处
理。
Java 的全部位运算符如下：
运算符
~
&
|
^
<<
>>
>>>
&=
|=
^=
<<=
>>=
>>>=
含义
位非（单目）
位与
位或
位异或
左移
右移
右移，0 填充高位
位与并赋值
位或并赋值
位异或并赋值
左移并赋值
右移并赋值
右移填 0 并赋值

位运算符与算术运算符不同：算术运算符不关心值的内部表示，而位运算符则处理值中的每
一位。
1. 非运算符 ~
单目非运算符：将一个操作数按位取反，即 0 变成 1，1 变成 0。
例如： ~ (11110000) = 00001111
2. 按位与运算符 &
按位与运算符：将两个操作数的每一位进行&操作，即两个操作数的位均为 1 时才产生
1，其他情况均为 0。
例如： (00001111) & (11110000) = 00000000
3. 按位或运算符 |
按位或运算符：将两个操作数的每一位进行或操作，两个操作数中只要其中一位为 1，
结果就为 1。
例如： (11110000) | (00001111) = 11111111
4. 按位异或运算符 ^
按位异或运算符：将两个操作数的每一位进行比较，值不同时为 1，否则为 0。
例如： (00110001) ^ (11000001) = 11110000
5. 左移运算符 <<
左移运算符：将其左边的操作数按其右操作数指定的位数全部左移。移动时最高位移
出，最低位补 0。
例如： (00001111) << 2 = 00111100
注意：用左移运算可将一个整数乘 2（每左移一位相当于乘 2）。
6. 右移运算符 >>
右移运算符：将其左边操作数按其右操作数指定的位数全部右移。右移使最低位移出，
最高位保持不变，并将该值填入到次高位中，其他位逐位向右移动。
例如： (00001111) >> 2 = 00000011
注意：操作数每右移一位相当于除 2 并丢掉余数。
7. 无符合右移运算符 >>>
无符合右移运算符：移动时以 0 填充高位。
例如： (10001111) >> 2 = 00100011
8. 位赋值运算符（<<= 或 >>=）
位赋值运算符：是先将某变量的内容按指定的位数进行左（右）移动之后，再将结果
存入到该变量中。
例如： d <<= 2 相当于 d = d << 2

1.5.7其他运算符

Java 语言的运算符除了前面介绍的之外，还有?、[]、()、instanceof、字符串连接+运算符。
1. 条件运算符 ?
条件运算符要求有三个操作对象，称三目运算符。条件表达式的一般形式为：
表达式 1？表达式 2 : 表达式 3
条件运算符执行顺序：先求解表达式 1，若为真（true）则求解表达式 2，此时表达式 2 的
值就作为整个条件表达式的值。若表达式 1 的值为假（false），则求解表达式 3，表达式 3

的值就作为整个条件表达式的值。
例如： x = (3 > 2) ? 8 : 9 表达式可以得到 x 的值为 8。
2. ( )和[ ]运算符
在 Java语言中，为了增强运算符的优先级，可用括号"（）"运算符来提高某些运算符
的级别。
方括号"[ ]"是数组运算符。在定义数组大小或使用数组元素时，用方括号内的表达式
确定数组的长度（大小）或确定数组的下标值。
例如： int a [] = new int[5];
a[0] = 8;

3. 对象运算符 instanceof
对象运算符：是用来判断一个指定的对象是否是指定类（或它的子类）的实例，若是则返回
true，否则返回 false。其表达式如下：
if （对象名 instanceof类名）
{ ......
}
例如： String str = "888";
if ( str instanceof String )
{
System.out.println(str);
}

4. 字符串连接运算符＋
Java 语言的字符串是用字符串对象（String）实现的。"＋"运算符将 2 个字符串连接
成一个字符串。
例如： String s = "ab" + "cd" ; // 变量 s 中的值为"abcd"。

1.5.8运算符的优先级

在 Java 程序设计语言中，使用圆括号来指示运算的执行顺序。运算符的优先级别如下：
运算符
[] . () (方法调用)
! ~ ++ -- + (一元的) - (一元的) () (造型)
new
* / %
+ -
<< >> >>>
< <= > >= instanceof
== !=
&
^
|
&&
结合性
从左到右
从右到左

从左到右
从左到右
从左到右
从左到右
从左到右
从左到右
从左到右
从左到右
从左到右

||
?:
= += -= *= /= %= &= |= ^= <<= >>=
>>>=

从左到右
从左到右
从右到左
如果不使用圆括号，则按上表中所示的优先级别进行运算。同一级别的运算符从左到右进行
计算，而右结合的运算符除外。

1.6 Java 语言控制语句
程序设计语言使用控制语句，根据数据的状态控制程序的执行流程。即决定跳转或分支还是
顺序执行。Java 的控制语句可以分为 3 种类型：选择、矢代（循环）和跳转。Java 不再提
供 goto 语句，Java 增强了 break 和 continue 的能力，凡是使用 goto 的地方一般都可以通
过 break 和 continue 结合其他控制语句来实现。

1.6java 语言控制语句

1.6.1if 语句

if语句是 Java 的条件分支语句，它控制程序以 2 条路径执行。一般有 3 种形式：
形式 1：if 语句的一般形式。
if ( condition ) statement1 ; [ else statement2 ;]
例如： int a = 7;
int b = 8;
if ( a > b)
System.out.println(a);
else
System.out.println(b);
执行结果为：
8
说明：
（1）condition 是返回一个 boolean 类型值的任何表达式，如果表达式的值是 true，则执行
statement1，如果表达式的值是 false，则执行 statement2。
（2）每个 statement 可以是单条语句，也可以是复合语句。
形式 2：if 语句的嵌套。
在 if 语句中又包含一个或多个 if 语句称为 if 语句的嵌套。
if ( condition )
if ( condition ) statement1;
else statement2;
else
if ( condition ) statement1;
else statement2;

形式 3：if－else－if 阶梯。

if－else－if 阶梯是基于一系列嵌套 if 的一种通常的编程结构，其结构如下：
if ( condition ) statement;
else if ( condition ) statement;
else if ( condition ) statement;
......
else statement;
if语句从上往下执行，当某个if的条件为真时，只执行与之相关的语句，而剩下的语句被
跳过。如果没有一个条件为真，执行最后一个 else 语句。如果没有最后一个 else，并且其
他条件都为假，就不再进行任何操作。

1.6.2switch 语句

switch 语句是多分支选择语句。if 语句只有两个分支可供选择，而实际问题中常常需要用到
多分支的选择，这样可以用 switch 语句来表达。
switch ( expression )
{ case value1 : 语句序列 1
break;
case value2 : 语句序列 2
break;
......
case valuen : 语句序列 n
break;
default : 语句序列 n + 1
}
例如： int x = 8;
switch (x)
{
case 1 : System.out.println(1); break;
case 8 : System.out.println(8); break;
case 5 : System.out.println(5); break;
}
执行结果为：
8

说明：
（1）expression 是一个表达式，value 是一个常量值。表达式的类型常量的类型必须是一个
相容的类型，它们只能是 char、byte、short 或 int 中的任何一种类型值。每个 value 必须是
唯一的常量。
（2）switch 语句将 expression 的值与 case 的每个常量相比较，如果相等就执行该 case 语
句后的代码。如果没有一个 case 值与 expression 的值相等，则执行 default 语句。default
语句是可选的。使用 switch 结构比 if－else 结构要快得多。
（3）break 语句将执行流程跳转到 switch 语句得末尾，即 switch 语句的下一条语句。
（4）多个 case 语句可以共用一组执行语句。

1.6.3while 语句

循环的意思是指不断重复地执行同一块代码直到满足结束条件。任何循环都由四部分组成：
循环地初始状态、循环体、矢代因子（常用来递增或递减的计数器或下标）、控制表达式。
while 循环语句是 Java 的基本的循环语句。当控制表达式为真时，一直重复执行循环体。
其一般表达式如下：
while ( condition )
{ // 循环体
break;
continue;
return;
}
例如： int x = 0;
while ( x < 8 )
{
System.out.println(x);
x = x + 1;
}
执行结果为：
0
1
2
3
4
5
6
7

说明：
（1）condition 可以是任何的布尔表达式，while 语句先判断布尔表达式，后执行循环体。
当布尔表达式的初始值为假时，循环体将一次都不执行。
（2）return 语句用来使程序从方法中返回调用者。
（3）break 语句用于循环语句中，强迫退出循环。使程序跳转到循环语句的下一条语句。
（4）continue 语句的功能是结束本次的循环，即跳过循环体中下面尚未执行的语句，使程
序转移到循环的开始。在 while 语句中，continue 语句使得控制直接转移到条件判断部分。

1.6.4do-while 语句

在布尔表达式的初始值为假，而循环体至少要执行一次才能结束循环的情况下，将用do－
while 语句来实现这样的循环。它的特点是：先执行循环体，后判断布尔表达式。不管布尔
表达式的值为真还是为假，循环体至少要执行一次。其一般形式如下：
do {
// 循环体

} while ( condition )
例如： int x=0;
do {
x = x + 1;
System.out.println(x);
} while ( x < 8)
执行结果为：
1
2
3
4
5
6
7
8

1.6.5for 语句

for 语句是 Java 中最有效、最灵活的循环结构。它的一般形式如下：
for ( initialization ; condition ; increment )
{
// 循环体
}
例如： for (int x = 0 ; x < 8 ; x++)
{
System.out.println(x);
}
执行结果为：
0
1
2
3
4
5
6
7

说明：
（1）initialization 是 for 循环的初始化部分，用它设置控制循环变量的初值。
（2）condition 是条件判断部分，它可以是任何布尔表达式。当条件为真时执行循环体，否
则执行 for 语句的下一条语句。
（3）increment是矢代因子，它控制循环变量是递增还是递减。只有靠矢代因子的变化才
能改变条件判断部分的状态。

（4）for 语句的执行过程：先执行 initialization 部分，在执行 condition 条件判断部分，若
其返回值为真（true），则执行循环体，然后在执行 increment 部分，接着在执行 condition
部分；若返回值为假（false），则结束循环，执行 for 语句的下一条语句。

1.7面向对象编程的基础

要了解面向对象编程（OOP）的基本概念，需要理解 OOP 的三个主要概念，它们撑起
了整个 OOP 的框架。这三个概念是：封装、继承性和多态性。除此以外，还需了解对象、
类、消息、接口、及抽象等概念。

2.2.1

对象

现实世界中的对象具两个特征：状态和行为。例如：自行车有状态（传动装置、步度、
两个车轮和齿轮的数目等）和行为（刹车、加速、减速和换档等）。
其次，我们再来看看软件对象。软件对象是现实世界对象的模式化产物，他们也有状态
和行为。软件对象把状态用数据表示并存放在变量里，而行为则用方法实现。实际上，软件
对象还包括了数据结构和使用这些数据结构的代码。因此也可以说：软件对象是现实世界客
观事务的软件化模拟，是变量（数据和数据结构）和相关方法（对数据操作和对象管理的程
序）的软件组合。
在面向对象的程序设计中，你可以用软件对象表示现实世界的对象，而这些软件对象和
现实世界对象是相对应的。例如：如果你正在建立一个帐户管理系统，那么你的对象就是帐
户、欠款、信用卡、月收入、贷款、交易等等。如果你设计一个电子实习交通工具系统，那
么你的对象就是汽车、摩托车、自行车等等。就自行车的软件对象而言，表示该对象的状态
和行为应为与变量和方法相对应。自行车的状态：数度是 10mp（每小时 10 米），步度是 90rpm
（每分钟 90 转），当前传动装置是第 5 个齿轮。再面向对象的程序设计中，这些数据应放在
变量中。自行车的行为：刹车，改变步度和换档。在面向对象的程序设计中，这些行为用方
法实现。
在 OOP 技术中，对象充当了一个很重要的角色。对象的数据是组成对象的核心，而方法
则环绕这个核心并隐藏在对象之中。

2.2.2

封装

"封装"是 OOP 语言的优点之一。把一个对象的数据加以包装并置于其方法的保护之下
称为封装。所谓封装就是对数据的隐藏。封装实现了把数据和操作这些数据的代码包装成为
一个对象（即离散的部件），而数据和操作细节（方法）隐藏起来。如果增加某些限制，使
得对数据的访问可按照统一的方式进行，那些能比较容易地产生更为强壮的代码。
OOP 语言提出一种（或称为协议），以保证对数据进行统一的操作。通常的做法是：程
序和对象数据的交互作用通过一个公开的接口进行，而不直接进行操作。由于把数据封装在
对象中，所以，访问对象中的数据只有一种途径，那就是利用一个公开的接口。
实际上，封装在程序和数据之间设置了一道栅栏，它可以阻止一部分的设计错误，不至
于涉足应用程序其他部分的数据。

2.2.3

消息

一个单独的对象一般不十分有用，而作为一员出现在包含有许多其他对象的大程序或应
用程序之中，通过这些对象的相互作用，程序员可实现高层次的操作和更负责的功能。某此
对象通过向其他对象发送消息与其他对象进行交互作用和通信。
消息是以参数的形式传递给某方法的。一个消息通常由三部分组成：
1.消息传送到对象的名称。
2.要执行的方法的名称。
3.方法需要的任意参数。

2.2.4

类

类是一个蓝图或样板，定义了某种类型的所有对象的变量和方法。
在 java 语言中，Java程序的基本单位是类，也就是说：一个 Java 程序是由多个类组成
的。定义一个类与定义一个数据类型是有区别的。在程序设计语言中，把定义数据类型的能
力作为一种很重要的能力来对待。在面向对象的语言中，类的功能更强大，这是因为类不仅
含有定义数据类型的功能，而且还包含了对方法的定义。
对象实际是类中的一个实例。生成实例的过程叫做把"一个对象实例化"。一个实例化
的对象实际上是由若干个实例变量和实例方法组成的。当你创建出一个类的实例时，系统将
为实例变量指定内存，然后你就可以利用实例方法去做某些事情。

2.2.5

继承

继承是指建立子类的能力。子类继承了父亲的特征和功能。类的层次结构类似于一棵数
的结构，也像一个家庭谱系。它显示了根和它的导出类之间的关系。
子类从它先辈类那里继承了代码和数据，这样，它就可以执行先辈类的功能和访问先辈
类的数据。一个纯面向对象程序设计的语言将具有严格的继承性。
通过对象、类，我们实现了封装，通过子类我们可以实现继承。例如，公共汽车、出租
车、货车等都是汽车，但它们是不同的汽车，除了具有汽车的共性外，它们还具有自己的特
点(如不同的操作方法，不同的用途等)。这时我们可以把它们作为汽车的子类来实现，它们
继承父类(汽车)的所有状态和行为，同时增加自己的状态和行为。通过父类和子类，我们实
现了类的的层次，可以从最一般的类开始，逐步特殊化，定义一系列的子类。同时，通过继
承也实现了代码的复用，使程序的复杂性线性地增长，而不是呈几何级数增长。

2.2.6

抽象

面向对象的程序设计系统鼓励充分利用"抽象"。在现实世界中，人们正是通过抽象来
理解复杂的事务。例如：人们并没有把汽车当作成百上千的零件组成来认识，而是把它当作
具有自己特定行为的对象。人们可以忽略发动机、液压传输、刹车系统等如何工作的细节，
而习惯于把汽车当作一个整体来认识。
包含通用对象类的库叫作类库。

2.2.7

多态型

面向对象程序的最后一个概念是多态性。凭借多态性，你可以创建一个新的对象，它具
有与基对象相同的功能，但是这些功能中的一个或多个是通过不同的方式完成的。例如：在
Java 中你可以凭借多态性，通过一个画圆的对象，来创建一个画椭圆或矩形的对象。不管是
画圆，画椭圆还是画矩形的方法，它们都有一个相同的方法名，但以不同的方式完成他们的
画圆的功能。

1.8类和对象

1.8.1类

类是组成 Java 程序的基本要素。它封装了一类对象的状态和方法，是这一类对象的
原型。定义一个类，实际上就是指定该类所包含的数据和对数据进行操作的代码。
类通过关键字 class 来定义，一般格式为：
【类说明修饰符】class 类名【extends子句】【implements 子句】
type instance-varable1;
type instance-varable2;
type instance-varable3;
the methodname1(parameter-list){method-body;}
the methodname2(parameter-list){method-body;}
the methodnameN (parameter-list){method-body;}
下面将类定义格式的项目说明如下：
（1）class 是类说明关键字。
（2） 类名是由程序员自己定义的 Java 标识符，每个类说明必须有 class 和类名。
（3） 类说明修饰符包括：
abstract 说明一个类为抽象类，抽象类是指不能直接实例化对象的类。
final说明一个类为最终类，即改类不能再有子类。
public 说明类为公共类，该类可以被当前包以外的类和对象使用。
private说明类为私有类。
（4）extends 子句用于说明类的直接超类。
（5）implements 子句用于说明类中将实现哪些接口，接口是 Java 的一种引用类
型。
（6） 类体包含了变量和方法。在类体中定义的数据、变量和方法称为类的成员，
或称为实例变量和实例方法。
（7） 例如：
下例定义了一个 Point 类 ,并且声明了它的两个变量 x、y 坐标 ,同时实现 init()方法
对 x、y 赋初值。
class Ponit {
int x,y;
void init(int ix, int iy){
x=ix;
y=iy;

}
}
类中所定义的变量和方法都是类的成员。对类的成员可以设定访问权限，来限定
其它对象对它的访问，访问权限所以有以下几种:private, protected, public, friendly。

1.8.2对象</