java考试重点整合.docx
《java考试重点整合.docx》由会员分享，可在线阅读，更多相关《java考试重点整合.docx（17页珍藏版）》请在冰豆网上搜索。
java考试重点整合
Java复习题
注意:
细节部分得看书，编程题具体数值会变
二，范围划分：
考试范围：
1，2，3，4，5，6，7，8，9，10章
重点章节：
2，3，6，7，8，10章
难点章节：
6，7，10章
三，考试重点：
1.基本数据类型及运算符的使用,方法调用参数传递问题.
基本数据类型有：
整数类型：
long（8字节）,int（4字节）,short（2字节）,byte（1字节）
浮点数类型：
float单精度浮点数；double（双精度浮点数）
字符类型：
char
布尔类型：
boolean
运算符：
算术运算符：
双目运算符包括：
+，—，*，/,%和单目运算符：
>，<，>=，<=，==，和！
=
逻辑运算符：
&&（与），||（或），！
（非）
位运算符：
~（位反），&（位与），|（位或），^（位异或），<<（左移位），>>（右移位），>>>（无符号右移位）
赋值运算符：
变量名=表达式；“=”是赋值运算符
条件运算符：
表达式1？
表达式2：
表达式3
括号运算符：
（）
2.流程控制,多重循环
多重循环：
如果循环语句的循环体中又包含循环语句，就形成了多重循环结构。
3.自定义类的创建及使用，构造方法的重载,对象的创建及属性和方法的调用。
类的声明形式如下：
[修饰符]class类名[extends父类名][implements借口名列表]
{成员变量声明部分
成员方法声明部分
}
对象的创建：
类名对象名
对象名=new类名（参数表）
或者类名对象名=new类名（参数表）
4，Java程序设计语言的特性
Java程序分为Java应用程序（application）和Javaapplet两种.
Java源文件保存在以.java为后缀名的文件中,被编译后的Java文件被保存在后缀名为.class的字节码文件中.
Java是严格区分大小写的.
Application必须包含主方法main（）,main（）方法的定义形式.,
5，Java的基本数据类型,4种基本的整数类型.
Java数据类型分为基本数据类型：
int，float，char，boolean。
引用类型：
数组，接口，类，
变量:
局部变量.实例变量.类变量.使用局部变量前应对变量赋初值,在类中声明的变量为实例变量,类中声明并用static关键字定义的变量是类变量.类变量实质是全局变量.用法实例可参考书上实例.
运算符:
++--的前缀后缀区别,布尔运算符中&&和||短路运算符的使用.
关系运算符,赋值运算符=和==区别
实例
publicclassVarScope{
publicstaticintx=10;
publicstaticvoidmain（Stringargs[]）{
inty=5;
if（x==10）{
intz=2;
x=x+z;
System.out.println（“Thefirstx=”+x）;
System.out.println（“Thefirsty=”+y）;
}
VarChange（）;
System.out.println（“Thethirdx=”+x）;
System.out.println（“Thethirdy=”+y）;
}
publicstaticvoidVarChange（）{
intx=6,y=4;
y=y+1;
System.out.println（“Thesecondx=”+x）;x=6,y=6
System.out.println（“Thesecondy=”+y）;
}
}
输出结果为：
Thefirstx=12
Thefirsty=5
Thesecondx=6
Thesecondy=5
Thethirdx=12
Thethirdy=5
6种基本的程序控制结构:
会看懂程序的运行过程,执行结果,特别是多重循环
While循环最少执行次数为0次,do-while循环最少执行次数为1次.
For循环语句结构,多重for循环嵌套
多重循环图形符号的输出
方法声明,如何写一个方法
方法调用,如何调用方法
参数传递
2、publicclassChangeStrDemo{
publicstaticvoidchangestr（Stringstr）{
str="welcome";
}
publicstaticvoidmain（String[]args）{
Stringstr="1234";
changestr（str）;
System.out.println（str）;
}
}
输出结果为：
1234
数组的声明和创建,如何访问数组元素,通过数组名和下标访问.
多维数组a[5][4],a.length=5,a[0].length=4
面向对象的3个重要特性:
封装,继承,多态.
学会创建自己的类
声明类的格式.
[修饰符]class类名[extends父类名]
[implements接口名表]{
成员变量声明//类体
方法成员声明
}
classRectangle{
doublelength;
doublewidth;
doublearea（）{
returnlength*width;
}
publicRectangle（doublew,doublel）{
width=w;
length=l;
}
}
类定义完成后就可以对它进行实例化,创建它的对象.对象经声明必须用new运算符创建才能使用.
类名对象名=new类名（）
如:
Rectanglerect1=newRectangle（）;
用.称做点运算符访问对象内的属性和方法.
对象名.成员变量名
对象名.成员方法名（）//方法名带圆括号
刚才定义了Rectangle类，可以用如下的方法来引用对象的成员：
Rectangler=newRectangle（）;//定义类的对象
r.length,r.width//引用对象的数据成员
r.area（）//引用对象的成员方法
修饰符（p85表6-1）:
public公共的,其他包中的类也可访问
private私有的,只能被本类方法所使用
protected本类,本包,子类都可访问
缺省的同一个包中的才能访问.
Abstract抽象类不能实例化，只能被子类继承，抽象方法必须定义在抽象类中，但抽象类中可包含非抽象方法。
final类不能被继承既没有子类，final方法不能被子类覆盖。
Abstract和final不能同时修饰类.
构造函数的特点:
方法名与类名同名,没有返回值,但不用void声明，用new运算符自动调用,每一个类可以有零个或多个构造方法。
默认的构造函数，学会创建多个构造函数
课后习题编程题
this引用和super引用
classA{
PublicA（）{
System.out.println（“Aiscalled”）;
}
publicA（Stringx）{
System.out.println（“Aiscalledandinputstring:
”+x）;
}
}
ClassBextendsA{
publicB（）{
super（）;
System.out.println（“Biscalled”）;
}
publicB（Stringx）{
super（x）;
System.out.println（“Biscalledandinputstring:
”+x）;
}
}
ClassCextendsB{
publicC（）{
System.out.println（“Ciscalled”）;
}
publicC（Stringx）{
super（x）;
System.out.println（“Ciscalledandinputstring:
”+x）;
}
}
publicclassExtendTest1{
publicstaticvoidmain（Stringargs[]）{
newc（“haoareyou?
”）
}
}输出结果为：
Aiscalledandinputstring“howareyou?
”
Biscalledandinputstring“howareyou?
”
Ciscalledandinputstring“howareyou?
”
类的继承
类的多态通过方法重载和覆盖来实现.
什么是方法重载p93，会判断合法的重载的方法（相同的方法名，不同的参数列表，或者是参数个数不同，或者是参数类型不同）
在一个类中，多个方法具有相同的方法名。
但却有不同的参数表，称为方法的重载。
重载表现为同一个类中方法的多态性。
什么是方法覆盖,两者有何区别?
覆盖:
子类通过派生继承了超类的方法，但是当超类中的方法对于子类不合适时，可以在子类中定义一个与超类方法名字、参数列表完全相同的新方法来取代超类中的方法，这种机制称作覆盖。
区别:
重载是一个类中有多个方法，方法名相同而参数不同，覆盖是指父类和子类中方法同名且拥有相同的参数列表，子类调用时默认调用子类的同名方法而覆盖掉父类的方法。
classAclass{
voidgo（）{
System.out.println（"Aclass"）;
}}
publicclassBclassextendsAclass{
voidgo（）{
System.out.println（"Bclass"）;
}
publicstaticvoidmain（Stringargs[]）{
Aclassa=newAclass（）;
Aclassa1=newBclass（）;
a.go（）;
a1.go（）;
}
输出结果：
Aclass
Bclass
继承，通过extends关键字实现
子类从超类那里继承所有非私有的属性和方法，子类对象可以当作超类对象对待，但超类对象未必是子类对象。
子类继承抽象超类时，若子类不希望定义为抽象类，则在子类中必须覆盖超类中的抽象方法，否则子类必须定义为抽象类。
抽象方法只有方法头部，没有方法体。
例如:
publicabstractStringgetInformation（）;
接口中只包含常量和抽象方法的定义，用interface定义。
实现一个接口用关键字implements,实现一个接口，则在类中一定要实现接口中的所有方法。
Java采用关键字import来引用包中的类或接口。
Java不允许多重继承，多重继承必须通过接口实现。
各章课后简答题认真看看（特别是第六章）
第六章课后简答题P84
1,什么是类？
如何定义一个类？
类包含哪几个部分？
p71
在面向对象的程序设计中，将属性及行为合起来定义为类。
类成为定义一组具有共同属性和行为的对象的模板。
2，什么是对象？
如何创建对象？
对象是表现显示世界中的某个具体的事物。
对象是类的实例，随想与类的关系就像变量和数据类型的关系一样。
对象是类的取值，能够保存类的一个实例。
对象的创建包括声明和实例化工作。
创建对象的形式如下：
类名对象名
对象名=new类名（参数表）；
或者
类名对象名=new类名（参数表）
异常处理机制的概念：
两种异常处理的方式
使用try…catch…finally结构对异常进行捕获和处理；
通过throws和throw抛出异常
程序填空题
基于字符流的文件操作
第五六十章节中的课后习题java代码
第五章
第一题：
publicclassSort{
publicstaticvoidbubbleSort（inta[]）
{
inttemp;
for（inti=a.length-1;i>0;i--）
for（intj=0;j{
if（a[j+1]{
temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
}
publicstaticvoidmain（Stringargs[]）
{
intm[]={10,8,21,65,32,51,74,14,28,95};
System.out.println（"beforesort"）;
for（inti=0;iSystem.out.print（m[i]+""）;
bubbleSort（m）;
System.out.println（"aftersort"）;
for（inti=0;iSystem.out.print（m[i]+""）;
}
}
答案：
beforesort
1082165325174142895aftersort
8101421283251657495
第五题
publicclassTranspose
{
publicstaticvoidmain（Stringargs[]）
{
inta[][]=newint[3][4];
intb[][]=newint[4][3];
System.out.println（"转置之前的矩阵"）;
for（inti=0;i<3;i++）
{
for（intj=0;j<4;j++）
{
a[i][j]=（int）（100*Math.random（））;
System.out.print（a[i][j]+""）;
}
System.out.println（）;
}
System.out.println（"转置之后的矩阵"）;
for（inti=0;i<4;i++）
{
for（intj=0;j<3;j++）
{
b[i][j]=a[j][i];
System.out.print（b[i][j]+""）;
}
System.out.println（）;
}
}
}
答案：
转置之前的矩阵
7496898
742362
5487045
转置之后的矩阵
71745
96248
83670
98245
第六章
第八题
publicclassAccount{
Stringaccount;
Stringname;
Stringaddress;
doublebalance;
staticdoubleminBalance=50;
publicAccount（Stringaccount1,Stringname1,Stringaddress1,intbalance1）
{account=account1;
name=name1;
address=address1;
balance=balance1;
}
publicvoiddeposit（doublecash）
{
System.out.println（"您帐户原有余额：
"+balance）;
System.out.println（"现存入：
"+cash）;
balance=balance+cash;
System.out.println（"最终余额：
"+balance）;
}
publicvoidwithdraw（doublecash）
{
doubletemp=balance-cash;
if（tempSystem.out.println（"至少保留余额：
"+minBalance）;
else
balance=temp;
}
publicvoidquery（）
{
System.out.println（"您的余额是：
"+balance）;
}
publicstaticvoidmain（Stringargs[]）
{
AccountJame=newAccount（"112233","Jame","江汉大学文理学院",200）;
Jame.deposit（300.0）;
Jame.withdraw（200.0）;
Jame.withdraw（300.0）;
Jame.query（）;
}
}
答案：
你的账户原有余额：
200
现存入：
300
最终余额：
500
至少保留余额：
50
您的余额是300
第十题：
classCube
{
doubleside;
publicCube（doublea）
{
side=a;
}
publicdoublegetSide（）
{
returnside;
}
publicdoublearea（）
{
return6*side*side;
}
publicdoublevolume（）
{
returnside*side*side;
}
}
publicclassuseCube{
publicstaticvoidmain（Stringargs[]）
{
Cubecube1=newCube（2.0）;
System.out.println（"side="+cube1.getSide（））;
System.out.println（"area="+cube1.area（））;
System.out.println（"volume="+cube1.volume（））;
}
}
答案：
side=2.0
area=24.0
volume=8.0
第十章:
第四题
importjava.io.*;
publicclassUniteFile
{
publicstaticvoidmain（String[]args）throwsIOException
{
Filefile1=newFile（"d:
\\File1.txt"）;
Filefile2=newFile（"d:
\\File2.txt"）;
Filefile3=newFile（"d:
\\File3.txt"）;
try
{
BufferedReaderbr1=newBufferedReader（newFileReader（file1））;
BufferedReaderbr2=newBufferedReader（newFileReader（file2））;
BufferedWriterbw3=newBufferedWriter（newFileWriter（file3））;
Strings1=br1.readLine（）;
while（s1!
=null）
{
bw3.write（s1）;
bw3.newLine（）;
s1=br1.readLine（）;
}
br1.close（）;
Strings2=br2.readLine（）;
while（s2!
=null）
{
bw3.write（s2）;
bw3.newLine（）;
s2=br2.readLine（）;
}
br2.close（）;
bw3.close（）;
}catch（FileNotFoundExceptione）{
System.out.println（e）;
}catch（IOExceptione）{
System.out.println（e）;
}
}
}
按任意键开始~
第八题
importjava.io.*;
publicclassSaveGrade{
publicstaticvoidmain（Stringargs[]）throwsException
{
InputStreamReaderiin=newInputStreamReader（System.in）;
BufferedReaderbr=newBufferedReader（iin）;
FileWriterfw1=newFileWriter（"d:
\\grade.txt"）;
BufferedWriterbw=newBufferedWriter（fw1）;
Strings;
while（true）{
System.out.print（"输入姓名：
"）;
System.out.flush（）;
s=br.readLine（）;
if（s.length（）==0）
break;
bw.write（s）;
bw.newLine（）;
System.out.print（"输入学号：
"）;
s=br.readLine（）;
bw.write（s）;
bw.newLine（）;
System.out.print（"输入成绩：
"）;
s=br.readLine（）;
bw.write（s）;
bw.newLine（）;
}
br.close（）;
bw.close（）;
intmax=0,min=100,total=0,num=0;
BufferedReaderbf=newBufferedReader（newFileReader（"d:
\\grade.txt"））;
while（true）
{
Stringss=bf.readLine（）;
if（ss==null）
break;
ss=bf.readLine（）;
ss=bf.readLine（）;
intgrade=Integer.parseInt（ss）;
total+=grade;
num+=1;
if（grade>max）
max=grade;
if（grademin=grade;
}
System.out.println（"学生成绩中最高为：
"+max+",最低为：
"+min+",平均值为：
升级会员 