返回
第 3章 数据成员设计
本章介绍 Java语言中一些与数据成员
有关的基础知识,
数据的描述方式 —— 标识符、关键
字、数据类型、字面量等；
数据类型转换（主要针对基本数据
类型）；
系统提供的数据结构 —— 数组；
大小可自由伸缩的“数组” —— 向
量。
数据成员设计
1 数据描述
2 数组
3 向量
数据描述
标识符与关键字
数据类型
数据类型转换
字面量
变量的作用域与生存期
标识符与关键字
程序员对程序中的各个元素（如变量、方法、类
或标号等）加以命名时使用的命名记号称为 标识
符（ identifier） 。 Java语言中，标识符是一个字
符序列，在语法上有如下使用限制,
（ 1）必须要以字母，下划线（ _）或美元符 ($)开
头，后面可以跟字母，下划线，美元符或数字；
（ 2） Java是区分字母的大小写的，如 name和
Name表示的就代表两个不同的标识符；
（ 3）不可以单独将 关键字 (Keywords)和保留字作
为标识符
关键字 (Keywords)和保留字
abstract const * final instanceof private switch void
boolean continu
e
finally int protected synchronized volatile
break default float interface public this while
byte do for long return throw
case double goto * native short throws
catch else if new static transient
char extends implements null** strictfp true**
class false** import package super try
数据类型
Java中的数据类型（ Data Types）可分为两大类
一类称为基本数据类型（ Primitive Data Types）
另一类则是复合数据类型（ Reference Data
Types，又称引用数据类型）
基本数据类型是指一些不可再分割的简单数据
类型，如整数、浮点数、布尔及字符等，复合
数据类型是指那些由基本数据类型组合成的较
复杂的数据类型
数据类型的分类表
数据类型
基本数据类型
整 型
浮点型
字符型
布尔型
复合数据类型
数组
类
接口
数据类型的意义
对数据进行规范化地存储，即将数据按不同的存储规格划分有限等级种类，减少存储的复杂性；
确定数据值的范围，以作为数据有效性检查的一
个项目；
确定数据的表示精度，以满足不同的需求；
确定数据可以进行的运算种类，以检查运算的合法性和数据的完整性，如 0不可作除数等
Java中的基本数据类型
数据类型名 占用内 存空间 数值范围 说明
整数 byte 1字节 -27~27-1 有符号数，
二进制
补码形
式表示
short 2字节 -215~215-1
int 4字节 -231~231-1
long 8字节 -263~263-1
实数 float 4字节 (± 3.4028235E+38f)～ (± 1.40239846E-45f) 遵循 IEEE
754规范 double 8字节 (± 1.79769313486231570E+308)～(± 4.94065645841246544E-324)
其他 char 2字节 \u0000～ \uffff Unicode字符
boolean 1位 true或 false 布尔型
整数类型
整数类型指的是没有小数部分的数
值,Java提供了 4种整数类型 ——
byte,short,int和 long，它们分别具
有 8位,16位,32位及 64位的宽度，
并且均是有符号的。其中 int型是最
实用的,byte和 short型主要应用于一
些特殊的情况
浮点类型
浮点类型指的是包含小数部分
的数值,Java提供了两种浮点类
型 — float型和 double型。 float代
表的是单精度的浮点数（ 6~7个
有效的十进制数位），而 double
代表的是双精度的浮点数（ 15个
有效的十进制数位）
字符类型
字符类型表示 Unicode编码方案中的单个字
符。 Unicode编码方案将各个主要字符集的
字符统一编码于一个体系。
每个 Unicode字符占用 2个字节（ 16位）的
存储空间，通常用十六进制编码表示，范
围在‘ \u0000’到‘ \uFFFF’之间。 \u前缀标
志着这是一个 Unicode值，而 4个十六进制
数位代表实际的 Unicode字符编码
布尔类型
布尔类型只有两种可能的取值：
true（代表“真”）
false（代表“假”）
它主要进行逻辑测试
复合数据类型
复合数据类型包括数组、类
（ class）和接口（ interface），
这些内容将在后继章节中详细进
行介绍
数据类型转换
数据类型转换就是改变数据的类型，它
可以隐式地（即由系统主动）或显式地
（即根据用户明确的要求）进行
Java的数据类型转换有严格的规定：凡是
将数据从占用内存较少的短数据类型转
换为占用内存较多的长数据类型时，可
以不做显式的类型转换说明；反之则必
须做显式（强制）类型转换
自动类型转换（ conversion）
整型、实型、字符型数据可以混
合运算。运算过程中，不同类型
的数据会自动转换为同一类型，
然后进行运算
自动类型转换按低级类型数据转
换成高级类型数据的规则进行
类型级别图
char
short
int long float double
byte
基本数据类型的自动类型转换会在下面三种情形下发生
（ 1）赋值
（ 2）方法调用
（ 3）算术提升此时又分两种情况,
（ a）对一元运算符（除了 ++和 --运算符不进行自动
类型转换之外）来说，假设操作数的类型为 byte,short或
char，都将自动转换为 int型；
（ b）对二元运算符来说，假设有一个操作数类型为
double，其它操作数就自动转换为 double型；否则假设有
一个操作数类型为 float，其它操作数就自动转换为 float型；
否则假设有一个操作数类型为 long，其它操作数就自动
转换为 long型；否则两个操作数都会自动转换为 int型。
自动类型转换的例子
public class Promotion{
public static void main(String args[ ]){
byte b = 18;
char c = 'a';
int i = 20;
long l = 555l;
float f = 3.5f;
double d = 1.88;
float f1 = f * b; //float*byte->float
int i1 = c + i; //char+int->int
long l1 = l + i1; //long+int->long
double d1 = f1 / i1 - d; //float/int->float,float-double->double
System.out.println("f1="+f1);
System.out.println("i1="+i1);
System.out.println("l1=" + l1);
System.out.println("d1=" + d1);
}
}
运行结果
f1=63.0
i1=117
l1=672
d1=-1.3415384340286254
强制类型转换（ casting）
将占用内存较多的数据类型转换成
占用内存较少的数据类型时，必须
用到强制类型转换
其一般形式为,
（ 类型名 ）（ 表达式 ）
其中类型名是你希望将表达式转换
成的结果类型的名称
强制类型转换的例子
public class Casting{
public static void main(String args[ ]){
int i;
byte b;
i = 356;
b =(byte)i; // 强制转换后丢失一部分数据，使得 b的值为 100
System.out.println("i="+i);
System.out.println("b="+b);
byte b2=++b;
System.out.println("b2="+b2);
byte b3=(byte)(b+b2);
//此处的强制类型转换上必须的，因为两个 byte型数据相
//加的结果是 int型。
System.out.println("b3="+b3);
}
}
运行结果
i=356
b=100
b2=101
b3=-54
字面量
字面量（ Literals）是某些类型的
基本表述，它在源程序中定义，
可以出现在赋值运算的右边或方
法调用中，但不能出现在赋值运
算的左边，也就是说，不能为字
面量分配值。
整型字面量
整型字面量有三种表达形式：十
进制、八进制和十六进制
其中十进制是默认的表达形式，
它的第一个数字不能是 0。用八
进制表达的时候应加上前缀, 0”，
用十六进制表达的时候则应加上
前缀, 0x”或, 0X”
浮点型字面量
一个浮点型字面量描述了一个浮点
数，它有两种表示形式,
（ 1）一般表示法 由数字和小数点
组成，且必须有小数点
（ 2）指数表示法 如 123e3,123E3
或 1.23e3，其中 e或 E之前必须有数字，
且 e或 E后面的指数必须为整数
字符型字面量
字符型字面量常用一对单引号括起来的
单个字符表示，这个字符可以是能直接从键盘输入的字符，如’ A’、’ 0’
或’！’
可以是要表示的字符所对应的八进制数
（此时只能表示’ \000’~’\377’范围内的
字符，即 Unicode字符集中的 ASCII码部
分）或 Unicode字符
还可以是换码序列（用来表示特殊字符）
特殊字符
换码序列 名称 Unicode值
\b 退格 \u0008
\t Tab（制表） \u0009
\n 换行 \u000a
\f 走纸换页 \u000c
\r 硬回车 \u000d
\” 双引号 \u0022
\’ 单引号 \u0027
\\ 反斜杠 \u005c
布尔型字面量
有效的布尔型字面量只有两个：
true和 false，分别代表了“真”
和“假”，它们不对应于任何整
数值
字符串字面量
字符串字面量是用一对双引号括
起来的 0个或多个字符的序列，
在 Java中每个字符串字面量都被
看作是一个字符串对象而并非是
一个字符数组
变量的作用域与生存期
变量（ variables）记录了对象的
状态，它用来存放指定类型的数
据，其值在程序运行过程中是可
变的
变量的三要素
变量具有三要素：名称、类型和作用域
变量名 是用来标识该变量的，存取变量
的内容（变量的值）都是通过变量名来
实现的
变量的 数据类型 决定了该变量可能的取
值范围和允许对这些值进行哪些操作，
以及这些操作的意义是什么
每个变量都有一定的使用范围，变量的
使用范围又称为变量的 作用域
变量的声明
在使用 Java中的每个变量之前，
都必须对它进行声明。变量的声
明形式如下,
变量类型 变量名 [,变量名 …] ；
变量的类别
变量可归纳为以下 4种类别,
成员变量（ member variables）
局部变量（ Local variables）
方法参数（ method parameter）
异常处理参数（ exception-handler
parameter）
成员变量 是类或对象的成员，它是在类
中、但不是在类的某个方法中声明的变
量。成员变量的作用域是整个类，在类的方法中也可使用它们
局部变量 是在一个语句块（由一对花括
号括起）中声明的，并且不能被该块外
的代码使用。例如，任何在方法中定义
的变量就是一个局部变量，它只能在声明它的方法中使用
方法参数 是方法（或构造方法）的变元，
用于将相应的数据传递给方法（或构造
方法）。方法参数的作用域是它作为参
数的整个方法（或构造方法）
异常处理参数 是异常处理代码（而不是
方法或构造方法）的变元，用于将相应
的数据传递给异常处理代码。异常处理
参数的作用域是相应的 catch语句块
具体用法将在第 5章中进行介绍。
变量的作用域
演示不同种类变量的作用域例子
class MethodDemo6{
float xxx; //类的成员变量 xxx
float aaa(float x,float y){ //x和 y是 aaa的方法参数，作用域是方法 aaa
float xxx; /*在 aaa方法中声明了与类的成员变量 xxx
同名的局部变量 xxx,则在 aaa的方法体中,xxx指的是局部变量 */
xxx =x + y; //此处的 xxx指的是方法 aaa的局部变量
return xxx;
}
void bbb(float x){ //x是 bbb的方法参数，作用域是方法 bbb
xxx =x; //此处的 xxx指的是类的成员变量
}
}
class TryMethodDemo6{ //主类
public static void main(String args[ ]){
MethodDemo6 a = new MethodDemo6();
System.out.println("方法 aaa中局部变量 xxx的值为：
"+a.aaa(5,8));
System.out.println("执行方法 aaa后，类的成员变量
a.xxx="+a.xxx);
a.bbb(8);
System.out.println("执行方法 bbb后，类的成员变量
a.xxx="+a.xxx);
}
}
运行结果
方法 aaa中局部变量 xxx的值为,13.0
执行方法 aaa后，类的成员变量 a.xxx=0.0
执行方法 bbb后，类的成员变量 a.xxx=8.0
最终变量
最终变量 （ final variables）是指在程
序运行过程中其值不变的量，它就
类似于一些程序设计语言中的“常
量”。定义最终变量的方式有两种,
（ 1）在声明变量的类型前面加 final
关键字，并同时进行初始化
（ 2）在声明变量的类型前面加 final
关键字，在必要时再进行初始化
数组
前面介绍的变量是用一个名字（变量名）
来标识一个基本数据类型的数据，而在现实问题中，经常会要求处理一组数据
使用数组则可以用一个名字标识一组数
据
数组是相同类型的数据元素按顺序组成
的一种复合数据类型，元素在数组中的
相对位置由下标来指明
几个术语
⑴ 数组名
数组名应该符合 Java语言标识符的命名规则
⑵ 数组的类型
因为数组是用来存储相同类型的数据，因此数
组的类型就是其所存储的元素的数据类型
⑶ 数组的长度
数组的长度指的是数组中可以容纳的元素的个
数，而不是数组所占用的字节数
数组作为数据类型的特点
一个数组中所有的元素应该是同
一类型
数组中的元素是有顺序的
数组中的一个元素通过数组名和
数组下标来确定
一维数组
一维数组的声明（ declaration）与
创建（ creating）
一维数组的初始化（ initializtion）
一维数组元素的使用
一维数组的声明
数组声明的格式为,
类型 数组名 [ ]；
其中类型指出了数组中各元素的数
据类型，包括基本类型和复合类型。
数组名为一个标识符。,[ ]”部分指
明该变量是一个数组类型变量
数组的创建
为数组元素分配存储空间，同时
对数组元素进行初始化。 new语
句指明了分配类型以及由一个正
整数表示的数组长度，其格式如
下,
数组名 = new 数组元素类型 [数组长度 ]；
一维数组的初始化
数组初始化 就是为数组元素指定初始值
通常在创建数组时,Java会根据数组
类型使每个数组元素初始化为一个
默认值，但在许多情况下，并不希
望数组的初值为默认值，此时，就
需要由用户根据实际情况来对数组进行初始化
数组的初始化方式
像初始化简单类型一样自动初始化数组，
即在声明数组的同时进行初始化
例如,int a[]={1,2,3,4,5};
在声明之后再创建数组，然后为每个元
素赋值
例如,int a[ ]=new int[2];
a[0]=1;
a[1]=2;
一维数组元素的使用
声明了一个数组，并用 new语句为它
分配了内存空间后，就可以在程序
中像使用任何变量一样来使用数组
元素，即可以在任何允许使用变量
的地方使用数组元素。
数组元素的标识方式为,
数组名 [下标 ]
注意点
1）其中下标为非负的整型常数
或表达式
2）数据类型只能为 byte,short，
int，而不能为 long
3）下标的取值范围从 0开始，一
直到数组的长度减 1
给数组中元素赋值，逆序输出
public class ArrayTest{
public static void main( String args[ ] ){
int i;
int a[ ] = new int[5];
System.out.println("该数组的长度为,"+a.length);
for(i=0; i < a.length; i++ ) //对数组中的每个元素赋值
a[i] = i;
for(i = a.length-1; i>=0; i- - ) //按逆序输出
System.out.println("a["+i+"] = "+a[i]);
}
}
冒泡排序法对一维数组按值排序
public class BubbleSort{
public static void main(String args[ ]){
int i,j;
int intArray[ ] ={28,6,-9,72,-18};
int len =intArray.length; //取得数组长度，放在变量 len中
for(i=1; i<len; i++) //共比较 len-1趟
for(j=0; j<=len-i-1; j++)
if(intArray[j]>intArray[j+1]){
int t = intArray[j];
intArray[j] = intArray[j+1];
intArray[j+1] = t;
}
System.out.println("排序后的结果为,");
for(i=0; i<len; i++) //输出结果
System.out.println(intArray[i]+" ");
}
}
多维数组（ multi-dimensional
arrays）
在 Java中并不直接支持多维数组，
所以，多维数组的声明是通过对
一维数组的嵌套式声明来实现的，
即用,数组的数组,来声明多维
数组。
二维数组的声明与创建
二维数组声明的格式为,
类型 数组名 [ ] [ ]；
分配内存空间有下面几种方法
⑴直接为每一维分配空间
⑵从最高维开始，分别为每一维
分配空间
二维数组元素的初始化
直接对每个元素进行赋值
在声明数组的同时进行初始化
二维数组元素的引用
对二维数组中每个元素，其引用
方式为,
数组名 [下标 1] [下标 2]
其中下标 1、下标 2为非负的整型
常数或表达式。
一个二维数组中所有元素的和，
并找出最大、最小元素 (值以及其
所在的行号和列号 )
class Matrix2{
public static void main(String args[ ]){
int m[ ][ ]={{6,2,24},{-5,8,7,6},{-3,-18,-4,1,66}};
int row = 0;
int col = 0; //放最大元素的行号和列号
int row2 = 0;
int col2 = 0; //放最小元素的行号和列号
int max,min,sum = 0;
max = m[ 0 ][ 0 ];
min = m[ 0 ][ 0 ];
System.out.println("该二维数组中的最高维数为,"+m.length);
System.out.println("该二维数组中的元素有,");
for (int i=0;i<m.length;i++){ //输出该二维数组中的所有元素
for (int j=0;j<m[i].length;j++)
System.out.print(m[i][j]+"\t");
System.out.println();
}
System.out.println();
for (int i=0;i<m.length;i++){
for (int j=0;j<m[i].length;j++){
sum+=m[i][j];
if (m[ i ][ j ]>max){
max = m[ i ][ j ];
row = i;
col = j;
}
if (m[ i ][ j ]<min){
min = m[ i ][ j ];
row2 = i;
col2 = j;
}
}
}
System.out.println(" 所有元素的和为," + sum);
System.out.println(" 最大的元素的值为," + max);
System.out.println(" 该元素的位置在," + row + "行," + col + "列 ");
System.out.println(" 最小的元素的值为,"+min);
System.out.println(" 该元素的位置在,"+ row2 +"行," + col2 + "列 ");
}
}
不对称数组的例子
public class arrayPins{
static public void main(String args[ ]){
boolean pins[ ][ ]=new boolean [ 4 ][ ]; // 仅声明第
一维
for (int i=0; i<pins.length; i++)
pins[i]=new boolean [ i+1 ]; // 建立第二维
for (int i=0; i<pins.length; i++){ // 输出结果
for (int k=0; k<pins[i].length; k++)
System.out.print(pins[ i ][ k ]+" ");
System.out.println("");
}
}
}
数组的应用
数组元素的排序和搜索
数组的复制
数组元素的排序和搜索
Arrays类中包含了许多处理数组
的方法。例如，它提供了 sort( )
方法可以对数组元素进行排序，
提供了 binarySearch( )方法可以在
一个指定的数组中查找一个指定
的值
正确地使用方法，需含如下步骤
使用 import java.util.*;语句，可以让
java.util包中的所有的类在程序中都
可以使用（ Arrays类就在 util包中）
创建一个数组
使用 util包中 Arrays类的方法来重新
调整一个数组的数据
sort( )方法来对一个字符串数组进
行排序
import java.util.*; //让 java.util包中的所有的类在程序中都可以使用
class SortName{
public static void main(String args[ ]){
String names[ ]={"Tom","Merry","Peter","Jack","Rose"};
System.out.println("数组元素原来的顺序是,");
for (int i=0;i<names.length;i++)
System.out.println(i+","+names[i]);
Arrays.sort(names); //使用 Arrays类的 sort()方法为数组 names排序
System.out.println("数组元素现在的顺序是,");
for (int i=0; i<names.length; i++)
System.out.println(i+","+names[i]);
}
}
数组的复制
如果要将一个数组的内容复制到
另一个数组中，就需要采用 Java
提供的 System类中的 arraycopy( )
方法
其语法形式
public static void arraycopy(Object src,int
src_position,Object dst,int dst_position,int length)
其中，参数 src表示源数组
参数 dst表示目标数组
参数 src_position表示源数组的起始位置
参数 dst_position表示目标数组的起始拷贝位置
参数 length表示拷贝数组元素的个数
它从源数组 src的指定位置 src_position开始，拷
贝到目标数组 dst的指定位置 dst_position
向量
向量对象可以看作是一个大小可自由伸
缩的数组，当其中的元素个数大于默认
值的时候，其容量的大小会自动增加
与数组类似的是，向量对象同样可以通
过下标来取出其中的元素，而且它的下
标值也是从 0开始
Java在 java.util包中专门提供了一个类 —
Vector类来实现向量。
三种常用的构造方法
public Vector()
public Vector(int initialCapacity)
public Vector(int initialCapacity,
int capacityIncrement)
Vector类的常用方法及其说明
方法 说明
public boolean add(Object o) 将指定对象追加到当前 Vector对象的末尾。
public void add(int index,Object element) 将指定对象 element插入到当前 Vector对象的指定位置处。
public int capacity( ) 返回 Vector对象的当前容量。
public void clear( ) 将所有的元素从当前 Vector对象中移去。
public boolean contains(Object elem) 测试当前 Vector对象中是否包含指定的对象。
public void copyInto(Object[ ] anArray) 将当前 Vector对象中的每一个元素复制到指定的数组中去。
public Object firstElement( ) 返回当前 Vector对象中的第一个元素（其下标值为 0）。
public Object lastElement( ) 返回当前 Vector对象中的最后一个元素。
public Object get(int index) 返回当前 Vector对象中指定位置上的元素。
public int indexOf(Object elem) 返回当前 Vector对象中指定对象 elem首次出现的位置，找不到则返回 -1。
public boolean isEmpty( ) 测试当前 Vector对象是否为空。
public Object remove(int index) 将指定位置的元素从当前 Vector对象中移去。
public boolean remove(Object o) 删除当前 Vector对象中首次出现的指定对象，若当前 Vector对象包含该指定对象则返
回 true。
protected void removeRange(int fromIndex,
int toIndex)
删除当前 Vector对象中从 fromIndex位置开始，到 toIndex-1位置的所有元素。
public void removeAllElements() 删除 Vector对象中的所有元素，并将其大小重置为 0。
public Object set(int index,Object element) 将 Vector对象中指定位置上的元素置换为指定对象 element。
public int size() 返回 Vector对象中元素的数目。
public void trimToSize( ) 将当前 Vector对象的容量调整为与其元素个数相同。
第 3章 数据成员设计
本章介绍 Java语言中一些与数据成员
有关的基础知识,
数据的描述方式 —— 标识符、关键
字、数据类型、字面量等；
数据类型转换（主要针对基本数据
类型）；
系统提供的数据结构 —— 数组；
大小可自由伸缩的“数组” —— 向
量。
数据成员设计
1 数据描述
2 数组
3 向量
数据描述
标识符与关键字
数据类型
数据类型转换
字面量
变量的作用域与生存期
标识符与关键字
程序员对程序中的各个元素（如变量、方法、类
或标号等）加以命名时使用的命名记号称为 标识
符（ identifier） 。 Java语言中，标识符是一个字
符序列，在语法上有如下使用限制,
（ 1）必须要以字母，下划线（ _）或美元符 ($)开
头，后面可以跟字母，下划线，美元符或数字；
（ 2） Java是区分字母的大小写的，如 name和
Name表示的就代表两个不同的标识符；
（ 3）不可以单独将 关键字 (Keywords)和保留字作
为标识符
关键字 (Keywords)和保留字
abstract const * final instanceof private switch void
boolean continu
e
finally int protected synchronized volatile
break default float interface public this while
byte do for long return throw
case double goto * native short throws
catch else if new static transient
char extends implements null** strictfp true**
class false** import package super try
数据类型
Java中的数据类型（ Data Types）可分为两大类
一类称为基本数据类型（ Primitive Data Types）
另一类则是复合数据类型（ Reference Data
Types，又称引用数据类型）
基本数据类型是指一些不可再分割的简单数据
类型，如整数、浮点数、布尔及字符等，复合
数据类型是指那些由基本数据类型组合成的较
复杂的数据类型
数据类型的分类表
数据类型
基本数据类型
整 型
浮点型
字符型
布尔型
复合数据类型
数组
类
接口
数据类型的意义
对数据进行规范化地存储，即将数据按不同的存储规格划分有限等级种类，减少存储的复杂性；
确定数据值的范围，以作为数据有效性检查的一
个项目；
确定数据的表示精度，以满足不同的需求；
确定数据可以进行的运算种类，以检查运算的合法性和数据的完整性，如 0不可作除数等
Java中的基本数据类型
数据类型名 占用内 存空间 数值范围 说明
整数 byte 1字节 -27~27-1 有符号数，
二进制
补码形
式表示
short 2字节 -215~215-1
int 4字节 -231~231-1
long 8字节 -263~263-1
实数 float 4字节 (± 3.4028235E+38f)～ (± 1.40239846E-45f) 遵循 IEEE
754规范 double 8字节 (± 1.79769313486231570E+308)～(± 4.94065645841246544E-324)
其他 char 2字节 \u0000～ \uffff Unicode字符
boolean 1位 true或 false 布尔型
整数类型
整数类型指的是没有小数部分的数
值,Java提供了 4种整数类型 ——
byte,short,int和 long，它们分别具
有 8位,16位,32位及 64位的宽度，
并且均是有符号的。其中 int型是最
实用的,byte和 short型主要应用于一
些特殊的情况
浮点类型
浮点类型指的是包含小数部分
的数值,Java提供了两种浮点类
型 — float型和 double型。 float代
表的是单精度的浮点数（ 6~7个
有效的十进制数位），而 double
代表的是双精度的浮点数（ 15个
有效的十进制数位）
字符类型
字符类型表示 Unicode编码方案中的单个字
符。 Unicode编码方案将各个主要字符集的
字符统一编码于一个体系。
每个 Unicode字符占用 2个字节（ 16位）的
存储空间，通常用十六进制编码表示，范
围在‘ \u0000’到‘ \uFFFF’之间。 \u前缀标
志着这是一个 Unicode值，而 4个十六进制
数位代表实际的 Unicode字符编码
布尔类型
布尔类型只有两种可能的取值：
true（代表“真”）
false（代表“假”）
它主要进行逻辑测试
复合数据类型
复合数据类型包括数组、类
（ class）和接口（ interface），
这些内容将在后继章节中详细进
行介绍
数据类型转换
数据类型转换就是改变数据的类型，它
可以隐式地（即由系统主动）或显式地
（即根据用户明确的要求）进行
Java的数据类型转换有严格的规定：凡是
将数据从占用内存较少的短数据类型转
换为占用内存较多的长数据类型时，可
以不做显式的类型转换说明；反之则必
须做显式（强制）类型转换
自动类型转换（ conversion）
整型、实型、字符型数据可以混
合运算。运算过程中，不同类型
的数据会自动转换为同一类型，
然后进行运算
自动类型转换按低级类型数据转
换成高级类型数据的规则进行
类型级别图
char
short
int long float double
byte
基本数据类型的自动类型转换会在下面三种情形下发生
（ 1）赋值
（ 2）方法调用
（ 3）算术提升此时又分两种情况,
（ a）对一元运算符（除了 ++和 --运算符不进行自动
类型转换之外）来说，假设操作数的类型为 byte,short或
char，都将自动转换为 int型；
（ b）对二元运算符来说，假设有一个操作数类型为
double，其它操作数就自动转换为 double型；否则假设有
一个操作数类型为 float，其它操作数就自动转换为 float型；
否则假设有一个操作数类型为 long，其它操作数就自动
转换为 long型；否则两个操作数都会自动转换为 int型。
自动类型转换的例子
public class Promotion{
public static void main(String args[ ]){
byte b = 18;
char c = 'a';
int i = 20;
long l = 555l;
float f = 3.5f;
double d = 1.88;
float f1 = f * b; //float*byte->float
int i1 = c + i; //char+int->int
long l1 = l + i1; //long+int->long
double d1 = f1 / i1 - d; //float/int->float,float-double->double
System.out.println("f1="+f1);
System.out.println("i1="+i1);
System.out.println("l1=" + l1);
System.out.println("d1=" + d1);
}
}
运行结果
f1=63.0
i1=117
l1=672
d1=-1.3415384340286254
强制类型转换（ casting）
将占用内存较多的数据类型转换成
占用内存较少的数据类型时，必须
用到强制类型转换
其一般形式为,
（ 类型名 ）（ 表达式 ）
其中类型名是你希望将表达式转换
成的结果类型的名称
强制类型转换的例子
public class Casting{
public static void main(String args[ ]){
int i;
byte b;
i = 356;
b =(byte)i; // 强制转换后丢失一部分数据，使得 b的值为 100
System.out.println("i="+i);
System.out.println("b="+b);
byte b2=++b;
System.out.println("b2="+b2);
byte b3=(byte)(b+b2);
//此处的强制类型转换上必须的，因为两个 byte型数据相
//加的结果是 int型。
System.out.println("b3="+b3);
}
}
运行结果
i=356
b=100
b2=101
b3=-54
字面量
字面量（ Literals）是某些类型的
基本表述，它在源程序中定义，
可以出现在赋值运算的右边或方
法调用中，但不能出现在赋值运
算的左边，也就是说，不能为字
面量分配值。
整型字面量
整型字面量有三种表达形式：十
进制、八进制和十六进制
其中十进制是默认的表达形式，
它的第一个数字不能是 0。用八
进制表达的时候应加上前缀, 0”，
用十六进制表达的时候则应加上
前缀, 0x”或, 0X”
浮点型字面量
一个浮点型字面量描述了一个浮点
数，它有两种表示形式,
（ 1）一般表示法 由数字和小数点
组成，且必须有小数点
（ 2）指数表示法 如 123e3,123E3
或 1.23e3，其中 e或 E之前必须有数字，
且 e或 E后面的指数必须为整数
字符型字面量
字符型字面量常用一对单引号括起来的
单个字符表示，这个字符可以是能直接从键盘输入的字符，如’ A’、’ 0’
或’！’
可以是要表示的字符所对应的八进制数
（此时只能表示’ \000’~’\377’范围内的
字符，即 Unicode字符集中的 ASCII码部
分）或 Unicode字符
还可以是换码序列（用来表示特殊字符）
特殊字符
换码序列 名称 Unicode值
\b 退格 \u0008
\t Tab（制表） \u0009
\n 换行 \u000a
\f 走纸换页 \u000c
\r 硬回车 \u000d
\” 双引号 \u0022
\’ 单引号 \u0027
\\ 反斜杠 \u005c
布尔型字面量
有效的布尔型字面量只有两个：
true和 false，分别代表了“真”
和“假”，它们不对应于任何整
数值
字符串字面量
字符串字面量是用一对双引号括
起来的 0个或多个字符的序列，
在 Java中每个字符串字面量都被
看作是一个字符串对象而并非是
一个字符数组
变量的作用域与生存期
变量（ variables）记录了对象的
状态，它用来存放指定类型的数
据，其值在程序运行过程中是可
变的
变量的三要素
变量具有三要素：名称、类型和作用域
变量名 是用来标识该变量的，存取变量
的内容（变量的值）都是通过变量名来
实现的
变量的 数据类型 决定了该变量可能的取
值范围和允许对这些值进行哪些操作，
以及这些操作的意义是什么
每个变量都有一定的使用范围，变量的
使用范围又称为变量的 作用域
变量的声明
在使用 Java中的每个变量之前，
都必须对它进行声明。变量的声
明形式如下,
变量类型 变量名 [,变量名 …] ；
变量的类别
变量可归纳为以下 4种类别,
成员变量（ member variables）
局部变量（ Local variables）
方法参数（ method parameter）
异常处理参数（ exception-handler
parameter）
成员变量 是类或对象的成员，它是在类
中、但不是在类的某个方法中声明的变
量。成员变量的作用域是整个类，在类的方法中也可使用它们
局部变量 是在一个语句块（由一对花括
号括起）中声明的，并且不能被该块外
的代码使用。例如，任何在方法中定义
的变量就是一个局部变量，它只能在声明它的方法中使用
方法参数 是方法（或构造方法）的变元，
用于将相应的数据传递给方法（或构造
方法）。方法参数的作用域是它作为参
数的整个方法（或构造方法）
异常处理参数 是异常处理代码（而不是
方法或构造方法）的变元，用于将相应
的数据传递给异常处理代码。异常处理
参数的作用域是相应的 catch语句块
具体用法将在第 5章中进行介绍。
变量的作用域
演示不同种类变量的作用域例子
class MethodDemo6{
float xxx; //类的成员变量 xxx
float aaa(float x,float y){ //x和 y是 aaa的方法参数，作用域是方法 aaa
float xxx; /*在 aaa方法中声明了与类的成员变量 xxx
同名的局部变量 xxx,则在 aaa的方法体中,xxx指的是局部变量 */
xxx =x + y; //此处的 xxx指的是方法 aaa的局部变量
return xxx;
}
void bbb(float x){ //x是 bbb的方法参数，作用域是方法 bbb
xxx =x; //此处的 xxx指的是类的成员变量
}
}
class TryMethodDemo6{ //主类
public static void main(String args[ ]){
MethodDemo6 a = new MethodDemo6();
System.out.println("方法 aaa中局部变量 xxx的值为：
"+a.aaa(5,8));
System.out.println("执行方法 aaa后，类的成员变量
a.xxx="+a.xxx);
a.bbb(8);
System.out.println("执行方法 bbb后，类的成员变量
a.xxx="+a.xxx);
}
}
运行结果
方法 aaa中局部变量 xxx的值为,13.0
执行方法 aaa后，类的成员变量 a.xxx=0.0
执行方法 bbb后，类的成员变量 a.xxx=8.0
最终变量
最终变量 （ final variables）是指在程
序运行过程中其值不变的量，它就
类似于一些程序设计语言中的“常
量”。定义最终变量的方式有两种,
（ 1）在声明变量的类型前面加 final
关键字，并同时进行初始化
（ 2）在声明变量的类型前面加 final
关键字，在必要时再进行初始化
数组
前面介绍的变量是用一个名字（变量名）
来标识一个基本数据类型的数据，而在现实问题中，经常会要求处理一组数据
使用数组则可以用一个名字标识一组数
据
数组是相同类型的数据元素按顺序组成
的一种复合数据类型，元素在数组中的
相对位置由下标来指明
几个术语
⑴ 数组名
数组名应该符合 Java语言标识符的命名规则
⑵ 数组的类型
因为数组是用来存储相同类型的数据，因此数
组的类型就是其所存储的元素的数据类型
⑶ 数组的长度
数组的长度指的是数组中可以容纳的元素的个
数，而不是数组所占用的字节数
数组作为数据类型的特点
一个数组中所有的元素应该是同
一类型
数组中的元素是有顺序的
数组中的一个元素通过数组名和
数组下标来确定
一维数组
一维数组的声明（ declaration）与
创建（ creating）
一维数组的初始化（ initializtion）
一维数组元素的使用
一维数组的声明
数组声明的格式为,
类型 数组名 [ ]；
其中类型指出了数组中各元素的数
据类型，包括基本类型和复合类型。
数组名为一个标识符。,[ ]”部分指
明该变量是一个数组类型变量
数组的创建
为数组元素分配存储空间，同时
对数组元素进行初始化。 new语
句指明了分配类型以及由一个正
整数表示的数组长度，其格式如
下,
数组名 = new 数组元素类型 [数组长度 ]；
一维数组的初始化
数组初始化 就是为数组元素指定初始值
通常在创建数组时,Java会根据数组
类型使每个数组元素初始化为一个
默认值，但在许多情况下，并不希
望数组的初值为默认值，此时，就
需要由用户根据实际情况来对数组进行初始化
数组的初始化方式
像初始化简单类型一样自动初始化数组，
即在声明数组的同时进行初始化
例如,int a[]={1,2,3,4,5};
在声明之后再创建数组，然后为每个元
素赋值
例如,int a[ ]=new int[2];
a[0]=1;
a[1]=2;
一维数组元素的使用
声明了一个数组，并用 new语句为它
分配了内存空间后，就可以在程序
中像使用任何变量一样来使用数组
元素，即可以在任何允许使用变量
的地方使用数组元素。
数组元素的标识方式为,
数组名 [下标 ]
注意点
1）其中下标为非负的整型常数
或表达式
2）数据类型只能为 byte,short，
int，而不能为 long
3）下标的取值范围从 0开始，一
直到数组的长度减 1
给数组中元素赋值，逆序输出
public class ArrayTest{
public static void main( String args[ ] ){
int i;
int a[ ] = new int[5];
System.out.println("该数组的长度为,"+a.length);
for(i=0; i < a.length; i++ ) //对数组中的每个元素赋值
a[i] = i;
for(i = a.length-1; i>=0; i- - ) //按逆序输出
System.out.println("a["+i+"] = "+a[i]);
}
}
冒泡排序法对一维数组按值排序
public class BubbleSort{
public static void main(String args[ ]){
int i,j;
int intArray[ ] ={28,6,-9,72,-18};
int len =intArray.length; //取得数组长度，放在变量 len中
for(i=1; i<len; i++) //共比较 len-1趟
for(j=0; j<=len-i-1; j++)
if(intArray[j]>intArray[j+1]){
int t = intArray[j];
intArray[j] = intArray[j+1];
intArray[j+1] = t;
}
System.out.println("排序后的结果为,");
for(i=0; i<len; i++) //输出结果
System.out.println(intArray[i]+" ");
}
}
多维数组（ multi-dimensional
arrays）
在 Java中并不直接支持多维数组，
所以，多维数组的声明是通过对
一维数组的嵌套式声明来实现的，
即用,数组的数组,来声明多维
数组。
二维数组的声明与创建
二维数组声明的格式为,
类型 数组名 [ ] [ ]；
分配内存空间有下面几种方法
⑴直接为每一维分配空间
⑵从最高维开始，分别为每一维
分配空间
二维数组元素的初始化
直接对每个元素进行赋值
在声明数组的同时进行初始化
二维数组元素的引用
对二维数组中每个元素，其引用
方式为,
数组名 [下标 1] [下标 2]
其中下标 1、下标 2为非负的整型
常数或表达式。
一个二维数组中所有元素的和，
并找出最大、最小元素 (值以及其
所在的行号和列号 )
class Matrix2{
public static void main(String args[ ]){
int m[ ][ ]={{6,2,24},{-5,8,7,6},{-3,-18,-4,1,66}};
int row = 0;
int col = 0; //放最大元素的行号和列号
int row2 = 0;
int col2 = 0; //放最小元素的行号和列号
int max,min,sum = 0;
max = m[ 0 ][ 0 ];
min = m[ 0 ][ 0 ];
System.out.println("该二维数组中的最高维数为,"+m.length);
System.out.println("该二维数组中的元素有,");
for (int i=0;i<m.length;i++){ //输出该二维数组中的所有元素
for (int j=0;j<m[i].length;j++)
System.out.print(m[i][j]+"\t");
System.out.println();
}
System.out.println();
for (int i=0;i<m.length;i++){
for (int j=0;j<m[i].length;j++){
sum+=m[i][j];
if (m[ i ][ j ]>max){
max = m[ i ][ j ];
row = i;
col = j;
}
if (m[ i ][ j ]<min){
min = m[ i ][ j ];
row2 = i;
col2 = j;
}
}
}
System.out.println(" 所有元素的和为," + sum);
System.out.println(" 最大的元素的值为," + max);
System.out.println(" 该元素的位置在," + row + "行," + col + "列 ");
System.out.println(" 最小的元素的值为,"+min);
System.out.println(" 该元素的位置在,"+ row2 +"行," + col2 + "列 ");
}
}
不对称数组的例子
public class arrayPins{
static public void main(String args[ ]){
boolean pins[ ][ ]=new boolean [ 4 ][ ]; // 仅声明第
一维
for (int i=0; i<pins.length; i++)
pins[i]=new boolean [ i+1 ]; // 建立第二维
for (int i=0; i<pins.length; i++){ // 输出结果
for (int k=0; k<pins[i].length; k++)
System.out.print(pins[ i ][ k ]+" ");
System.out.println("");
}
}
}
数组的应用
数组元素的排序和搜索
数组的复制
数组元素的排序和搜索
Arrays类中包含了许多处理数组
的方法。例如，它提供了 sort( )
方法可以对数组元素进行排序，
提供了 binarySearch( )方法可以在
一个指定的数组中查找一个指定
的值
正确地使用方法，需含如下步骤
使用 import java.util.*;语句，可以让
java.util包中的所有的类在程序中都
可以使用（ Arrays类就在 util包中）
创建一个数组
使用 util包中 Arrays类的方法来重新
调整一个数组的数据
sort( )方法来对一个字符串数组进
行排序
import java.util.*; //让 java.util包中的所有的类在程序中都可以使用
class SortName{
public static void main(String args[ ]){
String names[ ]={"Tom","Merry","Peter","Jack","Rose"};
System.out.println("数组元素原来的顺序是,");
for (int i=0;i<names.length;i++)
System.out.println(i+","+names[i]);
Arrays.sort(names); //使用 Arrays类的 sort()方法为数组 names排序
System.out.println("数组元素现在的顺序是,");
for (int i=0; i<names.length; i++)
System.out.println(i+","+names[i]);
}
}
数组的复制
如果要将一个数组的内容复制到
另一个数组中，就需要采用 Java
提供的 System类中的 arraycopy( )
方法
其语法形式
public static void arraycopy(Object src,int
src_position,Object dst,int dst_position,int length)
其中，参数 src表示源数组
参数 dst表示目标数组
参数 src_position表示源数组的起始位置
参数 dst_position表示目标数组的起始拷贝位置
参数 length表示拷贝数组元素的个数
它从源数组 src的指定位置 src_position开始，拷
贝到目标数组 dst的指定位置 dst_position
向量
向量对象可以看作是一个大小可自由伸
缩的数组，当其中的元素个数大于默认
值的时候，其容量的大小会自动增加
与数组类似的是，向量对象同样可以通
过下标来取出其中的元素，而且它的下
标值也是从 0开始
Java在 java.util包中专门提供了一个类 —
Vector类来实现向量。
三种常用的构造方法
public Vector()
public Vector(int initialCapacity)
public Vector(int initialCapacity,
int capacityIncrement)
Vector类的常用方法及其说明
方法 说明
public boolean add(Object o) 将指定对象追加到当前 Vector对象的末尾。
public void add(int index,Object element) 将指定对象 element插入到当前 Vector对象的指定位置处。
public int capacity( ) 返回 Vector对象的当前容量。
public void clear( ) 将所有的元素从当前 Vector对象中移去。
public boolean contains(Object elem) 测试当前 Vector对象中是否包含指定的对象。
public void copyInto(Object[ ] anArray) 将当前 Vector对象中的每一个元素复制到指定的数组中去。
public Object firstElement( ) 返回当前 Vector对象中的第一个元素（其下标值为 0）。
public Object lastElement( ) 返回当前 Vector对象中的最后一个元素。
public Object get(int index) 返回当前 Vector对象中指定位置上的元素。
public int indexOf(Object elem) 返回当前 Vector对象中指定对象 elem首次出现的位置，找不到则返回 -1。
public boolean isEmpty( ) 测试当前 Vector对象是否为空。
public Object remove(int index) 将指定位置的元素从当前 Vector对象中移去。
public boolean remove(Object o) 删除当前 Vector对象中首次出现的指定对象，若当前 Vector对象包含该指定对象则返
回 true。
protected void removeRange(int fromIndex,
int toIndex)
删除当前 Vector对象中从 fromIndex位置开始，到 toIndex-1位置的所有元素。
public void removeAllElements() 删除 Vector对象中的所有元素，并将其大小重置为 0。
public Object set(int index,Object element) 将 Vector对象中指定位置上的元素置换为指定对象 element。
public int size() 返回 Vector对象中元素的数目。
public void trimToSize( ) 将当前 Vector对象的容量调整为与其元素个数相同。
