java自学考试复习资料.docx
《java自学考试复习资料.docx》由会员分享，可在线阅读，更多相关《java自学考试复习资料.docx（49页珍藏版）》请在冰豆网上搜索。
java自学考试复习资料
《Java语言程序设计》
第1章Java语言基础
Java语言的特点。
Java语言主要有以下特点：
1）强类型：
强制约束程序员必须遵守更多的编程规定，编译器能检测程序中尽可能多的错误。
2）编译和解释：
用Java编写的源程序在计算机上运行必须经过编译和解释执行两个阶段。
编译程序先江Java源程序翻译成与机器无关的字节码（bytecode），不是通常的编译程序将源程序翻译成特定计算机的机器代码。
运行时，由Java虚拟机（JVM）中的Java解释器负责将字节码文件解释成为特定的机器码进行运行。
3）自动无用内存回收功能：
垃圾收集器（garbagecollector）可以自动回收程序不再使用的内存，避免程序遗漏或重复释放内存。
4）面向对象
5）与平台无关：
与平台无关是对程序可移植性最直接最有效的支持，“一次编程，到处运行”。
可移植性源于两方面：
1.Java的编译和解释的特征（Java虚拟机）；2.Java采用基于国际标准的数据类型，在任何平台上，同一种数据类型是一致的。
6）安全性：
取消指针，避免因指针使用不当，访问不该访问的内存空间；提供数组下标检测机制，禁止程序越界访问内存；编译执行过程中进行比较严格的检查：
在解释执行前，对字节码文件作检查，防止被恶意改动的字节码文件被解释执行而破坏系统；浏览器限制下载的小应用程序不允许访问本地文件，避免其破坏本地文件。
7）分布式计算
8）多线程：
Java的运行环境采用多线程实现。
Java语言提供语言级多线程支持，用Java语言能直接编写多线程程序。
两种类型的Java程序。
Java程序可分为应用程序（Application）和小应用程序（Applet）两类。
这两种程序的主要区别：
1）小应用程序需要嵌入在HTML网页中，当网页被浏览时，在浏览器中运行；且其运行受到严格的安全限制。
2）应用程序则独立运行，不嵌入网页，也没有那些限制。
3）另外，这两类程序在代码编写上也有差异：
一个小应用程序必须定义为java.applet.Applet类的子类，而不必定义main（）方法；应用程序一般不必为java.applet.Applet类的子类，而必须在一个类中定义main（）方法。
注释：
1）行注释//
2）块注释/*….*/
3）文档注释/**…*/
Java程序的开发过程
通常在JDK目录下有bin、demo、lib、jre等子目录，其中bin目录保存了javac（编译器）、java（解释器）、jdb（调试器）、appletviewer（javaAppelt解释器）等命令文件；
Java的字符集和标识符。
Java语言使用Unicode字符集，字符采用双字节的表示方式，共有65535个字符，最前面的128个字符与标准的ASCII字符一致，包括：
1）数字字符10个（0~9）
2）英文大小写字母各26个（A~Z,a~z）
3）下划线（_）、美元符号（$）
4）文字字符（汉字，日文片假名、平假名，朝鲜文字等）
5）其他用于构成特殊符号的字符集
标识符可以用来标识文件名、变量名、类名、接口名和成员方法名等，其构造规则如下：
1）标识符由Java字母和Java数字组成；
2）
首字符必须是Java字母；
3）除去关键字、false、true和null；
4）所有标识符是区分大小写的。
关键字是Java语言保留的一些英文单词，具有特殊的含义。
例如：
public、static和class，具有特殊用途，不能作为标识符使用。
基本数据类型。
布尔型（boolean）1个字节（true或false）
字符型（char）16位
字节型（byte）8位
短整型（short）16位
整数型（int）32位
长整型（long）64位
单精度浮点型（float）32位
双精度浮点型（double）64位
Java直接量是直接显式地表示基本数据类型数据、字符串（String）值和空引用值（null）的表达式，而且在该表达式中不含运算。
布尔（boolean）直接量只有两个：
true和false
字符（char）直接量：
如‘a’，‘6’，‘猫’，‘\u0061’，‘\n’
整型（byte,short,int）直接量：
如-27，+0123，0x56ab
长整型（long）直接量：
如-27L，+0123L，0x56abL
浮点数（float,double）直接量：
如1.5，45.6D，100d，76.4e8，-32.0，1.5F，45.6f，76.4E-8F，-32.0F
字符串（String）直接量：
如“HelloWorld!
”
引用数据类型的直接量：
null
变量在计算机内部对应着一个存储单元，而且总是具有某种数据类型：
基本数据类型或引用数据类型。
每个变量均具有：
名字、类型、一定大小的存储单元以及值。
变量总是具有与其数据类型相对应的值。
基本数据类型：
变量的存储单元中存放的是具体的布尔值或数值；
引用数据类型：
变量的存储单元中存放的是引用值，引用值一般用来指向某个具体的对象。
如果引用值是null,则该引用值不指向任何对象。
在使用变量前，必须先定义该变量，而且一般要求先初始化。
例如:
intstudentNumber;//定义单个变量
studentNumber=30;//给变量赋值
doublevelocity,distance;//定义多个变量
intstudentNumber=30;//定义变量，并赋初值
第2章运算和语句
赋值运算。
●简单赋值运算，格式如下：
变量=表达式
不是“相等”运算符（“==”）。
赋值语句中的数据类型转换只能是简单类型向复杂类型转换，不能从复杂的转换成简单的。
转换规则如下：
byte→short→int→long→float→bouble
●复合赋值运算，格式如下：
变量双目算术运算符=表达式
包括：
+=、-=、*=、/=、&=、|=、%=、<<=、>>=和>>>=。
例如：
a+=b等价于a=a+b，a/=b+c等价于a=a/（b+c）。
算术运算符。
算术运算符包括：
+（取正），-（取负）（单目运算）
+,-,*,/,%（双目运算）
注意事项：
1）当操作数是定点类型数据时，应当注意运算是否会溢出
inti=123456;
i=i*i;//溢出
2）整数除法：
截去余数，7/5结果为1
3）考虑除数是否可能为0或很小的数
4）取模：
返回余数，可以对定点或浮点数进行取模运算，7%5结果为2；15.25%（-0.5）结果为0.25
自增自减运算。
自增（++）和自减（--）：
操作数必须是变量；有前置和后置两种运算
intn=3;
inti=n++,j=n--;//i=3,j=4,n=3
intk=++n,m=--n;//k=4,m=3,n=3
前缀和后缀，对变量本身，效果相同；但表达式的值不相同。
运算对象只能是变量，不能是常量或表达式，如：
7++；（i+j）--都是非法的。
关系运算符。
关系运算符包括:
<、>、<=、>=、==和!
=，关系运算生成一个布尔结果。
例如:
1>2;//false
3.5!
=1;//true
51.5>=23.0;//true
540<=654;//true
24==3*8;//true
booleantest1=（10<10）;//test1=false;
关系运算符的优先级：
<、<=、>、>=优先于==、!
=；<、<=、>、>=优先级相同，结合性是自左向右；==、!
=优先级相同，结合性是自左向右。
【注意】Java不允许将一个数字作为布尔值使用，这与c或c++不同。
例如：
当要表达“如果a不等于0”这个条件
不能写作if（a）
而要写作if（a!
=0）
逻辑运算符。
逻辑运算的操作数必须是布尔型，结果也是布尔型。
可以有3种基本操作：
与（&&）、或（||）、非（!
）。
短路规则：
一旦能够明确无误的确定整个表达式的值，就不再计算表达式余下的部分了。
因此，整个逻辑表达式靠后的部分可能不会计算。
比较:
（birthday==true）&&（++age>=65）
（birthday==true）||（++age>=65）
!
优先于双目算术运算符优先于关系运算符优先于&&优先于||
条件运算符。
条件运算符是一个三目运算符，一般形式为：
逻辑表达式?
表达式1:
表达式2
例如:
inti=5;
intk=（i>=0）?
1:
-1;
条件运算符的结合性为“自右至左”。
例如：
x>y?
x:
u>v?
u:
v等价于
x>y?
x:
（u>v?
u:
v）
位运算和位移运算。
位运算符包括：
&、|、~、^、
移位运算符有：
>>、>>>和<<
&、|、~、^按位求与、或、非、异或
>>带符号右移：
左端空出的位填原符号位
<<左移：
右端空出的位补0
>>>不带符号右移（逻辑右移）：
左端空出的位填0（C或C++中无此运算符）
位运算操作是：
先将整数写成二进制形式（补码），然后按位操作，最后产生一个新的数
注意:
只用于定点类型数据（整型）
基本语句。
表达式语句：
k=k+2;
空语句;
break语句：
break;用于循环或选择
continue语句：
continue;同上
return语句：
return;,return表达式;,该语句的执行将结束方法的执行，只能出现在方法体中。
复合语句。
用花括号引起来的两条或两条以上语句，顺序执行但作为一个整体。
在复合语句中可以定义自己专用的临时变量。
if语句。
if语句的格式是:
if（布尔表达式）
语句
或
if（布尔表达式）
{
一条或多条语句
}
例如：
if（score>=60）
System.out.println（"Passed"）;
if-else语句。
if-else语句的格式是:
if（布尔表达式）
语句1或语句块1
else
语句2或语句块2
例如：
if（score>=60）
System.out.println（"Passed!
"）;
else
System.out.println（"Failed!
"）;
标准嵌套if-else控制结构可实现多路选择，用在想从多个候选项中选择且只选出一项时。
例如：
if（score>90）
System.out.println（“A”）;
elseif（score>=80）
System.out.println（“B”）;
elseif（score>=60）
System.out.println（“C”）;
else
System.out.println（“F”）;
switch语句。
switch语句的格式是:
switch（表达式）
{
case值1:
语句组1；
break;
case值2:
语句组2；
break;
……
case值n:
语句组n；
break;
default:
语句组（n+1）；
}
switch表达式的数据类型可以是基本类型char、byte、short、int；或是这四种基本类型相对应的包装类java.lang.Character、java.lang.Byte、java.lang.Short、java.lang.Integer或enum枚举类型。
跟在case后的必须是常量表达式，其值的类型应当与switch表达式的数据类型相匹配。
Switch语句的执行规则：
1）求出表达式的值；
2）找出给定值与表达式相符的case语句，执行此case标号后的所有语句（除非遇到break语句），直到switch语句结束；
3）若没有匹配的case语句，则转向defalult语句，执行default标号后的所有语句，直到switch语句结束。
4）若没有匹配的case语句，也没有defalult语句，则switch语句的这次执行立即结束。
try…catch语句。
try{
语句块//执行该语句块，可能会发生异常
}catch（异常类型e）{
异常发生时要执行的语句块
}finally{
无论异常发生与否，都要执行的语句块
}
说明：
1）Catch和finally必须和一个try相关联
2）try至少要有一个catch,可以有多个
3）finally语句块是可选的
while语句。
while语句的格式：
while（布尔表达式）
语句或语句块
当条件（布尔表达式）为true，则不断地执行语句或语句块。
“while”循环的中止条件是布尔表达式变为false，如果布尔表达式一开始就为false，则不执行循环体。
有时循环条件很难写出，可以直接使用true,格式如下：
While（true）{
…
If（条件表达式）break;
…
}
do-while语句。
do-while语句的格式是：
do
{
语句或语句块
}
while（布尔表达式）;
do-while和while结构唯一的区别就是do-while中的语句至少会执行一次，即便布尔表达式第一次就被计算为false。
注意最后的分号，一定不能省略。
for语句。
for语句的格式是:
for（[初始化表达式];[条件表达式];[更新表达式]）
语句或语句块
例如：
intcounter,sum;
for（counter=1,sum=0;counter<=100;counter++）
sum+=counter;
System.out.println（“counter=“+counter+”,sum=”+sum）;
注意变量counter和sum的作用域，若将它们改在for语句内部定义，会有何不同。
在for语句的初始化和更新部分，可以使用多个由逗号分隔的表达式，这些表达式都会独立执行。
例如：
for（int1=1,j=i+10;i<5;i++,j=i*2）{
System.out.println（“i=”+i+“j=”+j）;
}
注意：
通过逗号操作符，可以在初始化部分定义多个变量，但这些变量必须具有相同的类型。
无论在初始化还是更新部分，表达式都是顺序执行的。
嵌套的循环结构。
for循环的嵌套
while循环的嵌套
do..while循环的嵌套
以上三个任意之间的嵌套
continue语句。
格式：
continue;
功能：
跳过continue之后的语句，重新判断循环控制条件，决定是否继续循环。
说明：
（1）continue语句只能用在三种循环语句的循环体中。
（2）continue语句通常和if语句联合使用，从而构成其后的部分循环体是否执行的单分支结构。
break语句。
格式：
break;
功能：
强制结束当前的循环，不再执行循环体中break后面的语句。
说明：
（1）break语句只能在三种循环语句的循环体和switch语句中使用。
（2）在循环语句中break通常和if语句联合使用，用于构成第二个退出循环的机会。
Package语句。
程序包相当于其它语言的函数库，系统提供大量的程序包，自己编写的类也可以组成程序包，但一定要用package语句声明。
格式：
package包名；
包名是一个目录名，可以有路径。
import语句。
用来引入所需要的类
格式：
import包名.类名；
例如：
importjava.util.Date;//引入Date类
如果从一个包中引入多个类，可以用通配符“*”，如：
importjava.awt.*;
一个java源程序中可以有多个import语句，它们必须出现在package语句之后；类的定义之前。
Java程序的基本结构。
[package包名;]
import包名.类名；
…//更多的import语句
[public]class类名{
intval=…//变量定义语句
Publicstaticvoidmain（Stringargs[]）
//方法定义
{
…//变量定义和控制语句构成的方法体
}
}
第3章面向对象编程基础
抽象
抽象是程序设计最经常使用的技术之一，是有效控制程序复杂性的重要手段。
在面向对象程序设计中：
把一系列复杂的属性与动作组织到单个模块中，然后把该模块当作一个整体（对象）来对待，就是一种抽象形式。
把一个问题分解成构成它的对象，也是一种抽象形式。
对象（object）
万物皆为对象，它存储数据，还可以要求它在自身上执行操作。
对象具有状态、行为和标识。
这意味着每一个对象可以拥有内部数据（它们给出该对象的状态）和方法（它们产生行为），并且每一个对象都可以唯一地与其他对象区分开来（每一个对象在内存中都有唯一一个地址）。
消息（message）
在面向对象框架中，对象之间通过相互发送消息来进行交互。
在Java里，通过调用方法来传递消息。
类（class）
类定义了某种类型的所有对象所具有的属性与行为，是用来创建对象的蓝图或模板；对象是某个确切类的实例。
在创建一个类的实例（对象）之前必须定义这个类。
继承性（inheritance）
多态性（polymorphism）
类
（1）类的声明
类的定义格式如下：
[类修饰词]class类名[extends父类名]
[implements接口名称列表]
{
类体
//通常先定义成员变量，再定义构造方法，最后编写成员方法
}
（2）成员变量
成员变量的定义格式如下：
[修饰词列表]类型变量名或带初始化的变量名列表；
例如：
privatefloatheight,weight;
privateStringname,sex,no;
（3）方法
类的成员方法：
简称方法，用来实现类的各种功能。
方法的定义格式如下:
[方法修饰词列表]返回类型方法名（方法的参数列表）
{
方法体
}
例如：
publicintmb_method（）{…}
publicstaticvoidmain（Stringargs[]）
{…}
例3.2（若某方法的参数名或局部变量名与类的成员变量名相同，则成员变量名在这个方法内部暂时被隐藏。
）
例3.3（关键字this：
对当前对象的引用）
（4）构造方法
构造方法用来创建类的实例，并对对象初始化。
构造方法的声明和一般方法声明非常相似，但是它必须和类同名，并且不能声明返回值类型。
构造方法的一般形式：
public<类名>（<参数列表>）{<语句>}
默认的构造方法：
当一个类没有包含构造方法时，Java将自动提供一个默认的构造方法。
对象
（1）声明对象
声明一个对象只是命名一个引用变量，这个引用变量和对象关联，可以用来引用该对象。
声明一个对象的格式如下：
类名变量名（对象名）；
例如，声明对象：
Pointp1,p2;
不要把声明一个对象和创建一个对象混淆起来。
声明对象并不会为这个对象分配内存。
（2）创建对象
创建对象：
使用new操作符和构造方法。
构造方法是在对象实例化过程中使用的特殊方法；
操作符new为新的对象分配一片内存并将它存储在那里，然后返回对象的地址。
格式为：
new构造方法名（构造方法的调用参数列表）
例如：
p1=newPoint（）;p2=newPoint（30,40）;
声明和创建对象也可以一起完成，例如：
Pointp3=newPoint（）,p4=newPoint（60,70）;
（3）对象的内存模型
在Java中有两种类型的变量：
基本类型与引用类型。
基本类型的变量总是存放一个该类型的值；引用变量实际上存放的是它所引用的对象的地址，而不是存放对象本身。
在Java中，主要有数组和类类型是引用类型。
（4）使用对象
程序使用对象：
访问对象的成员变量，一般形式为：
对象名.成员变量名
调用对象的方法，一般形式为：
对象名.方法名（[参数表]）
实例变量和类变量
被关键字static修饰的变量为类变量（静态变量），未被关键字static修饰的变量为实例变量。
例如：
classD{
floatx;//实例变量
staticinty;//类变量
…
}
每个对象都有自己的实例变量，不同对象的实例变量也将被分配不同的内存空间。
类变量则被一个类的所有对象共享，在内存中也只有一处。
可以通过类名或对象名引用类变量。
实例方法和类方法
被关键字static修饰的方法为类变量（静态方法），未被关键字static修饰的方法为实例方法。
例3.7
注意：
类中的实例方法可以互相调用，并可调用类方法。
类方法也能相互调用，但不能直接调用实例方法，而要通过在类方法中引入局部对象，通过对象名调用实例方法。
类中的实例方法中可以直接使用实例变量，也可直接使用类变量。
但类方法能直接使用类变量，却必须通过在类方法中引入的局部对象，用对象名引用实例变量。
类方法可以通过类名或对象名调用。
例3.8
访问权限
设置访问权限实现访问控制，为类的成员设置访问权限，保护类的成员不在非期望的情况下被引用。
在类的声明中，除了类的方法总能访问类的成员变量外，为其他类的方法访问本类的成员变量和方法，提供了四种访问权限:
public：
无访问限制，其他类的方法都能访问
private：
最强访问限制，其他类的方法都不能访问
protected：
仅限子类或同一包中的类的方法访问
：
只允许同一包中的类的方法访问
继承
继承性-软件重用的一种方法
继承使得一个类可通过扩展现有类来定义
扩展声明的新类称为子类，原有的类称为超类（父类）
子类继承超类的变量和方法；子类可以增加新的变量和方法；子类可以重写（第51页）从超类中继承的方法。
子类对父类的继承性，Java语言有以下规定：
子类自然地继承其父类中非private的成员变量作为自己的成员变量
子类自然地继承其父类中非private的成员方法作为自己的成员方法
多态性
静态的多态性：
重载，在编译时就能够被识别针对的是同一个类内的同名方法（重载的方法）。
动态的多态性：
重写，在程序运行时才被识别（动态联编）重写父类的方法（同样签名）。
多层继承
继承关系具有传递性。
继承声明的新类，又可被其他类再继承，从而构成多层继承。
Java面向对象的其他机制
（1）final类、final方法和final变量
关键字final的含义为“最终的”，“不能改变的”。
用
升级会员 