分析Java程序设计09-10试卷A（二）

二、判断题。在题后括号内，填上正确答案代号。（本大题共14小题，每小题1分，共14分）

得分

（ F ）1、Java应用程序必须有一个类是public类。

分析: 不必要, 可以全部是是private类, 比如后面会学到的”单例模式”

（ F）2、下列两个语句的作用等价：int[] a={1,2,3,4,5,6,7,8};

int [] a=new int[8];

分析: 不等价, 前面是赋值了, 后面只是申请了空间

（ F ）3、Java编译器将源文件编译生成的字节码是机器码。

分析: 为了保持它跨平台的特性,java源文件先编译成一种中间码,在运行的时候再实时编译成目标平台的机器码

（ F ）4、无论Java源程序包含几个类的定义，若该源程序文件以Itee.java命名，编译后生成的都只有一个名为Itee的字节码文件。

分析: Java的源代码中定义几个类，编译结果就生成几个以class为后缀的字节码文件。

（ F ）5、子类可以继承父类所有的成员变量及成员函数。

分析: 私有变量和方法不能被继承

（ T ）6、Java类中可以存在同名的两个成员方法。

分析: 方法重载, 只要满足参数个数不同或参数类型不同便可

（ T ）7、do-while的循环体至少被执行一次。

分析: 先执行循环体, 再执行判断条件, 所以循环体至少被执行一次

（ T）8、若两个对象有相同的引用，则这两个对象就具有完全相同的属性和功能。

分析: 如果：this为一个对象的引用。 otherobject为另一个对象的引用。 如果this==otherobject，则这两个对象相等。

利用＝＝来比较对象，只有在左右都指向同一个对象时成立，利用.equal来比较，则比较两个对象的内容是否一致，如：String的比较。

（ T ）9、Socket类既用于客户端，又用于服务器端。

分析: Socket是套接字, 用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过\套接字\向网络发出请求或者应答网络请求，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。 服务器端:

public class TCPServer { }

客户端: public class TCPClient {

public static void main(String[] args) throws UnknownHostException, IOException { }

//参数前面为本机IP,后面为应用程序的端口号 //Client端的端口系统随机选择 //申请连接

Socket s = new Socket(\创建一个流套接字并将OutputStream os = s.getOutputStream(); //s.getOutputStream为输出管道 DataOutputStream dos = new DataOutputStream(os); //包一层数据流 dos.writeUTF(\以与机器无关方式使用 UTF-8(比较省dos.flush(); dos.close();

s.close(); //连接完成以后要自己关闭

public static void main(String[] args) throws Exception { }

ServerSocket ss = new ServerSocket(6664); // 参数port - 端口号；或者为 }

while (true) { // 可以建立多个端口与不同客户端相连

Socket s = ss.accept(); // 接受连接并在服务器端再建一个端口DataInputStream dis = new DataInputStream(s.getInputStream()); System.out.println(dis.readUTF()); dis.close(); s.close();

来与用户端连接

其连接到指定主机上的指定端口号.

空间) 修改版编码将一个字符串写入基础输出流。

}

（ T）10、当instanceof左边的对象是右边的类创建的对象时，该运算的结果为true。

分析:自己查API,

（ T）11、子类中的成员变量只要和父类中的变量同名，子类就隐藏继承的成员变量。

分析:看书111页, 子类隐藏继承的成员变量, 即子类对象以及子类自己声明定义的方法操作与父类同名的成员变量是指子类重新声明定义的这个成员变量, 需要注意的是, 子类对象可以调用从父类继承的方法操作隐藏的成员变量. class People { }

class Student extends People { }

public class 成员变量的隐藏 {

public static void main(String[] args) {

Student stu = new Student(); stu.x = 98; // 父类的x被隐藏了

System.out.println(\对象stu的x的值是:\// stu.x=98.98; //非法

stu.setX(98.98); // 只设计一个setX端口在父类,就可以修改父类中被隐double m = stu.getDoubleX(); // 通过父类的端口访问

public int getX() { }

// x=20.56 //非法, return x;

int x;

public double getDoubleX() { }

return x;

public void setX(double x) { }

this.x = x;

public double x;

藏的变量了

}

}

System.out.println(\对象stu隐藏的x的值是:\

（ F ）12、子类重写继承的方法时，可以降低方法的访问权限。

分析: 1 基类有一个方法，比如 // 我们不考虑Object作为所有类的基类啦。 呵呵呵！ public void method1(){

method2(); // 此方法需要调用method2(); }

public void method2(){ // 如果这个方法是abstract 的话，也许会看得更清楚，不过不常见. }

2 子类重写了 @Override

private void method2(){ // 当然，编译错误，我们只是用来说明这样做的问题 }

3 子类的子类

如果他调用 method1() 会出现什么后果呢？

a) 他能访问method1(), 因为那是他的基类，且是public

b) 但很可惜，method1()里面 却不能访问method2()了，因为在父类是private的了。

这岂不是很可笑的情况。

所以，子类不能比父类的更私有，但可以更公开。 呵呵。这样才能保证父类已经实现的代码能够使用。

另：从5.0开始，子类方法override时，可以返回与父类不同的类型。但参数必须完全相同。

（ T ）13、Java的包java.net包含所有实现网络功能的类。

分析: 记住吧…

（ F ）14、方法的重载实现功能的多态性，但构造方法不可以重载。

分析也可以重载, 只要满足参数的个数或种类不同便可.

得分 三、填空题。在题中“ ”处填上答案。（本大题共18空，总计36分）

1、Calendar对象调用set(2009,9,1)设置的年、月、日为 ①2009年10月1日 。

分析: API中的解释 set

public final void set(int year, int month, int date)

设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。保留其他日历字段以前的值。如果不需要这样做，则先调用 clear()。 参数：

year - 用来设置 YEAR 日历字段的值。

month - 用来设置 MONTH 日历字段的值。Month 值是基于 0 的。例如，0 表示 January。 date - 用来设置 DAY_OF_MONTH 日历字段的值。

如果想自己设置输出格式的话: 可以使用SimpleDateFormat, SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。 public class Time { }

public static String GetNowTime() { }

Calendar rightNow = Calendar.getInstance();

SimpleDateFormat fmt = new SimpleDateFormat(\年MM月dd日 String sysDatetime = fmt.format(rightNow.getTime()); return sysDatetime;

public static void main(String[] args) { }

new Time();

System.out.println(Time.GetNowTime());

HH:mm:ss\

2、public URL（String protocol,String host,String file）throws

MalfomedURLException—构造的URL对象的 ②协议 、地址和资源分别由参数protocol、host和file指定。

分析: 记住吧…

3、当把级别高的变量的值赋给级别低的变量时，须使用 ③显式类型转换 类型转换运算。

分析: 自动类型转换（也叫隐式类型转换） 强制类型转换（也叫显式类型转换） 表达式的数据类型自动提升

所有的byte型、short型和char的值将被提升到int型。 如果一个操作数是long型，计算结果就是long型； 如果一个操作数是float型，计算结果就是float型； 如果一个操作数是double型，计算结果就是double型。 个人觉得是为了保持精度, 所以有自动类型转换.

4、Java中创建多线程主要采用一下两种方法：使用Thread子类，重写④ run（） 方法 ；使用 ⑤ Runnable 接口，并将其实例与Thread实例相关联。

分析: 建议使用第二种, 因为java只能继承一个类, 却可以重写很多接口, 所以实现接口更好些.

5、类成员的访问属性有：默认、public、 ⑥ private 和protected。

分析: 送分题…

6、若要在程序中引入有用的数据类型类包中的Date类，则需使用语句： ⑦ import java.util.Date;

分析: 按住 ctrl+shift+m 导入指定的包, 按住ctrl+shift+o 导入所有包, 删除没有用过的包

7、子类要想继承父类的所有参数的构造方法，须使用关键字super，super须是子类构造方法中的⑧第一条语句 。

分析: 记住就好…

8. Java使用try-catch语句来处理异常，将可能出现的 ⑨异常（操作） 放在try部分，将发生异常后的 ⑩处理 放在catch部分，并可有多个catch部分组成。

分析: 送分题…

1 read() 方法从输入流中顺序读取单个字节的数据。 9、FileInpueStream流的 1○分析: 原来答案是run(), 我查了API, 并没有这个方法, 根据题意, 应该是read()方法. 用法看下面一个例子吧: public class FileOutputStream类 {

public static void main(String[] args) {

int b = 0; //b用来存放字节

}

}

FileInputStream in = null; //初始化 FileOutputStream out = null; try { }

System.out.println(\文件已复制\

in = new FileInputStream(\out = new FileOutputStream(\重要数据\\\\桌面while((b = in.read()) != -1) { } in.close(); out.close();

System.out.println(\文件未找到!\System.exit(-1);

System.out.println(\文件复制错误!\System.exit(-1);

out.write(b); // 将指定 byte 写入此输出流

流\\\\节点流\\\\InputStream\\\\FileInputStream类.java\\\\\TEST.java\

} catch(FileNotFoundException e2) {

} catch(IOException e1) {

2 setPriority(int grade) 方法调整，这一方法需要10.线程的优先级可通过 1○一个int类型参数。

分析: //线程的优先级用数字表示,范围从1到10,一个线程缺省优先级是5

//Thread.MIN_PRIORITY = 1; Thread.MAX_PRIORITY = 10; Thread.NORM_PRIORITY = 5; //使用int getPriority()可以获得线程对象的优先级,使用void setPriority(int newPriority)可以设置线程对象的优先级 import java.lang.Thread;

public class setPriority方法 {

public static void main(String[] args) {

Thread t1 = new Thread(new T1()); Thread t2 = new Thread(new T2());

t1.setPriority(Thread.NORM_PRIORITY + 3); t1.start(); t2.start();

}

}

class T1 implements Runnable { }

class T2 implements Runnable { }

public void run() { }

for (int i = 0; i < 10; i++) { }

System.out.println(\

public void run() { }

for (int i = 0; i < 10; i++) { }

System.out.println(\

11. 下列代码接收键盘输入一整数，并显示于屏幕上： public static void main(String[] args) throws Exception{ String s=\int i = 0;

System.out.println(\

3 InputStreanReader (System.in)); BufferedReader in =new BufferedReader(new 1○ s = in.readLine();

4 parseInt (s); i = Integer. 1○ System.out.println(\}

分析: BufferedReader(Reader in)参数是个Read类型 而

java.lang.Object

java.io.Reader

java.io.InputStreamReader

InputStreamReader继承了Reader类, 就是多态的用法.

再看中间:

InputStreamReader(InputStream in)参数是InputStream类型

而System中public static final InputStream in返回类型正好是InputStream

为什么要包那么多层呢?

节点流外包了层转化流,方便中文输入(把键盘输入的字节流转化为字符流(防止像中文那样2个字节读取的).从键盘上读内容到程序中),再包了层缓冲流,方便整行读取(s = br.readLine();)

只要记住就好了: 输入操作都是这种写法: BufferedReader in =new BufferedReader(new InputStreanReader (System.in));

请看下面的例子: package 转换流;

//非常典型的用法！

//节点流外包了层转化流,方便中文输入,再包了层缓冲流,方便整行读取 import java.io.*;

public class InputStreamReader类 {

public static void main(String[] args) {

// System.in是\标准\输入流(阻塞)

InputStreamReader isr = new InputStreamReader(System.in); // 把键盘输入BufferedReader br = new BufferedReader(isr); // 再包一层缓冲区,有一个String s = null; // s用来记录输入的一行字符 try { }

s = br.readLine(); // 整行读取 while (s != null) { } br.close(); e.printStackTrace();

if (s.equalsIgnoreCase(\

break;

System.out.println(s.toUpperCase()); // 转化为大写 s = br.readLine(); // 读取下一行

的字节流转化为字符流(防止像中文那样2个字节读取的).从键盘上读内容到程序中 比较好的方法,readLine(),可以整行得读

} catch (IOException e) {

}

}

Integer. parseInt(String s)是一种很常用的将字符串转换为int类型的方法,还可以转换成其他类型, 比如parseDouble parseLong …自己查API

12.下列代码将c:\\aa.txt文件的数据读出，写入文件c:\\bb.txt中，并显示于屏幕上： public static void main(String[] args) throws Exception{ String s = new String();

5 FileReader (\BufferedReader in =new BufferedReader(new 1○6 FileWriter (\PrintWriter out =new PrintWriter( new 1○while((s = in.readLine())!= null){ System.out.println(s);

7 out .println(s); 1○}

in.close(); out.close(); ｝

分析: BufferedReader(Reader in), 而从文件中读取的节点流是: FileReader java.lang.Object

java.io.Reader

java.io.InputStreamReader java.io.FileReader

这也是多态.

缓冲流的作用是把把原本一个一个读取的数据, 分层一块一块读取, 每次这一块放了一定的数据后, 才会读入. 最后全部读入. 可以提高效率, 减少读取的次数.

System.out应该不陌生吧, 它的返回类型就是PrintRead类型, 只不过现在不是在控制台显示了, 而是写入文件中而已.

下面看两个例子: 缓冲流和PrintRead用法

package 缓冲流; import java.io.*;

public class BufferedWriter_BufferedReader {

public static void main(String[] args) { try {

} }

BufferedWriter bw = new BufferedWriter(new FileWriter(\BufferedReader br = new BufferedReader(new FileReader(\String s = null;

for(int i=0; i<=100; i++) { }

bw.flush(); //刷新该流的缓冲,把缓冲区内未写入的都写入 while((s=br.readLine()) != null) { } bw.close(); br.close();

System.out.println(s); //读取一个文本行

s = String.valueOf(Math.random()); //生成一个随机数, 返回该bw.write(s);

bw.newLine(); //写入一个行分隔符

对象的字符串表示

} catch (IOException e) { e.printStackTrace();}

package Print流; import java.io.*; import java.util.*;

public class PrintWriter类 { 输出

public static void main(String[] args) {

String s = null; //s用来存放键盘输入的数

//键盘输入的节点流处理成字符流(方便中文输入),再套上缓冲流,方便正BufferedReader br = new BufferedReader(new try {

FileWriter fw = new FileWriter(\重要数据\\\\桌面PrintWriter log = new PrintWriter(fw); while((s = br.readLine()) != null) {

if(s.equalsIgnoreCase(\

System.out.println(s.toUpperCase()); //在显示器上

行读取

InputStreamReader(System.in));

\\\\TEST.txt\

}

}

}

}

log.println(\

log.println(s.toUpperCase());

log.flush(); //把缓冲区的东西都读入文件中(其实

PrintWriter已经实现了)

log.println(\类用来表示特log.flush(); log.close(); e.printStackTrace();

定的瞬间

} catch(IOException e) {

13. 用static修饰的方法，称为静态方法。它们不是对象的方法，而是整个类的方法。静态方法只能处理用关键字static 修饰的数据。

分析: 静态方法(类方法)只能处理静态变量(类成员), 而普通方法(成员方法)则可以处理所有变量, 包括静态变量(类变量)和普通变量(成员变量), 所以不推荐在主方法中(public static void main(String[] args))写函数体. 比较推荐的写法是 public class Test { } } }

public void init() {

要写的内容

public static void main(String[] args) {

new Test().init();

四、简答题。（本题共8分，每题4分）

得分

1、 关键字this可以出现在构造方法中吗？可以出现在实例方法中吗？如可以，它分别

代表什么？

关键字this可以出现在类的构造方法中（1分），代表使用该构造方法所创建的对象（1分）；可以出现在类的实例方法中（1分），代表使用该方法的当前对象（1分）。

2、 简述实现多态性的几种技术（至少两种）?

1）与继承有关的多态性实现技术（上转型对象）：父类的方法被其子类重写时，可以各自产生自己的功能行为，同一个操作被不同类型对象调用时可能产生不同的行为。不同对象的上转型对象调用同一方法可能产生不同的行为，实现多态性。

2）接口回调技术：不同的类在使用同一接口时，可能具有不同的功能体现，即具有不同的接口方法体，接口回调产生不同的行为，实现多态性。

3）方法重载技术：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即要么参数的个数不同，要么参数的类型不同，通过对象调用重载的方法实现功能的多态性。

3、匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

五、编程题。（本题共10分，每空1分）

得分 仔细阅读并分析下列程序，填写程序的空缺部分。

提示：改程序能计算并输出Company对象一年需要支付的薪水总额。要求有一个abstract类，类名为Employee。Employee的子类有YearWorker、MonthWorker和WeekWorker，其对象分别按年、月、周领取薪水（不同职员的具体薪水可分别定位80000元/年、5000元/月、800元/周，每年按12个月或52周计算）。Employee类有一个abstract方法：public abstract earnings();子类须重写父类的earnings()方法，给出各自领取报酬的具体方式。

abstract class Employee {

public abstract double earnings(); }

Class YearWorker extends Employee{

① public double earnings( ) //重写earnings()方法 ②{return 80000; } }

class MonthWorker extends Employee{

③ public double earnings( ) //重写earnings()方法 ④ {return 12*5000; } }

class WeekWorker extends Employee{

⑤public double earnings( ) //重写earnings()方法 ⑥{return 52*800; } }

class Company{

Employee[] employee; double salaries=0;

Company(Employee[] employee){

}

Public double salariesPay(){ } }

public class HardWork{

public static void main(String[] args){

Employee[] employee=new Employee[20]; for(int i=0;i

if(i%3==0)

employee[i]=new YearWorker ();

Salaries=0;

⑦ for(int i=0;i

this.employee=employee;

else if(i%3==1)

employee[i]=new MonthWorker ();

else if(i%3==2)

employee[i]=new WeekWorker ();

}

Company company=new Company(⑨ employee ); System.out.println(“公司年工资总额：” ⑩ +company.salariesPay( ) ); } }

分析: 根据题意Employee的子类有YearWorker、MonthWorker和WeekWorker，其对象分别按年、月、周领取薪水（不同职员的具体薪水可分别定位80000元/年、5000元/月、800元/周，每年按12个月或52周计算）, 前六个空就是重写了父类的抽象方法.

先看主方法: Employee[] employee=new Employee[20];申请了20个装填Employee对象的空间. if(i%3==0)

employee[i]=new YearWorker (); employee[i]=new MonthWorker (); employee[i]=new WeekWorker ();

else if(i%3==1) else if(i%3==2)

对每一个对象进行实例化(要用继承了抽象类并实现了抽象类全部抽象方法的子类), 这也是一种多态, 用子类实例化父类的引用. 好处就是接口统一, 方便日后修改.

再: 这个对象数据实例化好了后, 就Company company=new Company(⑨ employee ); 创建一个Company对象, Company中得分构造方法接受了这个对象数组, 再: System.out.println(“公司年工资总额：” ⑩ +company.salariesPay( ) ); 调用company这个对象的salariesPay( )方法, 统计总的工资情况, 并返回输出

}

Company company=new Company(⑨ employee ); System.out.println(“公司年工资总额：” ⑩ +company.salariesPay( ) ); } }

分析: 根据题意Employee的子类有YearWorker、MonthWorker和WeekWorker，其对象分别按年、月、周领取薪水（不同职员的具体薪水可分别定位80000元/年、5000元/月、800元/周，每年按12个月或52周计算）, 前六个空就是重写了父类的抽象方法.

先看主方法: Employee[] employee=new Employee[20];申请了20个装填Employee对象的空间. if(i%3==0)

employee[i]=new YearWorker (); employee[i]=new MonthWorker (); employee[i]=new WeekWorker ();

else if(i%3==1) else if(i%3==2)

对每一个对象进行实例化(要用继承了抽象类并实现了抽象类全部抽象方法的子类), 这也是一种多态, 用子类实例化父类的引用. 好处就是接口统一, 方便日后修改.

再: 这个对象数据实例化好了后, 就Company company=new Company(⑨ employee ); 创建一个Company对象, Company中得分构造方法接受了这个对象数组, 再: System.out.println(“公司年工资总额：” ⑩ +company.salariesPay( ) ); 调用company这个对象的salariesPay( )方法, 统计总的工资情况, 并返回输出

本文来源：https://www.bwwdw.com/article/v5kr.html