阅读以下说明和Java代码，回答问题[说明] 在某些系统中，存在非常复杂的对象，可以采用循序渐进的方

阅读以下说明和Java代码，回答问题1和问题2，将解答填写在对应栏内。

【Java代码】

class usethread implements (1) {

int num

usethread(int n){

num=n;

}

public void (2) {

for(int i=0;i＜3;i++)

System.out.println("running:"+num);

System.out.println("finished:"+num);

}

public class multhread{

public static void main(String args[]) (3) InterruptedException{

Thread m1=new Thread(new usethread(1));

Thread m2=new Thread(new usethread(2));

m1.start();

m2.start();

m1.join();

m2.join();

}

}

【问题1】

补充完整上面Java代码中(n)处。

【问题2】

写出上面Java代码运行的结果。

阅读下列说明、图和Java代码，回答问题1至问题3。

【说明】

已知四个类之间的关系如图2-4所示，分别对每个类的方法进行编号，例如Shape的perimeter()为1号，表示为1：perimeter()，Rectangle类的perimeter()为2号，表示为 2：perimeter()，依此类推，其中，每个类的perimeter方法签名相同。

【Java代码】

Triangle tr=new Triangle()；

Square sq=new Square()；

Shape sh=tr；

关于上述Java代码中sh和tr的以下叙述中，哪两个是正确的(写出编号)。

①sh和tr分别引用同一个对象；

②sh和tr分别引用同一类型的不同的对象：

③sh和tr分别引用不同类型的不同对象：

④sh和tr分别引用同一个对象的不同拷贝；

⑤sh和tr所引用的内存空间是相同的。

阅读以下说明和Java代码，回答问题

[说明]

对多个元素的聚合进行遍历访问时，需要依次推移元素，例如对数组通过递增下标的方式，数组下标功能抽象化、一般化的结果就称为迭代器(Iterator)。模式以下程序模拟将书籍(Book)放到书架(BookShelf)上并依次输出书名。这样就要涉及到遍历整个书架的过程。使用迭代器Iterator实现。图6-1显示了各个类间的关系。以下是JAVA语言实现，能够正确编译通过。

[图6-1]

[Java代码]

//Iterator. java文件

public interface Iterator {

public abstract boolean hasNext();

public abstract Object next();

}

//Aggregate. java文件

public interface Aggregate {

public abstract Iterator iterator();

}

//Book. java

public class Book {

//省略具体方法和属性

}

//BookshelfIterator. java文件

public class Bookshelf工terator (1) Iterator{

private BookShelf bookShelf;

private int index;

public BookshelfIterator(BookShelf bookShelf) {

this. bookShelf = bookShelf;

this. index = 0;

}

public boolean hasNext(){//判断是否还有下一个元素

if(index ＜ bookShelf. getLength()){

return true;

}else{

return false;

}

}

public Object next()f//取得下一个元素

Book book = bookShelf. getBookAt(index);

index++;

return book;

}

}

//BookShelf. java

import java. util. Vector;

public class BookShelf {

private Vector books;

public BookShelf(int initialsize){

this. books = new Vector(initialsize);

}

public Book getBookAt(int index){

return(Book)books.get(index);

}

public int getLength(){

return books.size();

}

public Iterator iterator(){

return new BookShelfIterator((2) );

}

}

//Main. java文件

public class Main {

public static void main(String args){

BookShelf bookShelf = new BookShelf(4);

//将书籍上架，省略代码

Iterator it = bookShelf. (3) ;

while((4) ){//遍历书架，输出书名

Book book = (Book)it. (5) ;

System.out.printin(" "+book.getName());

}

}

}

试题七（共 15 分）

阅读下列说明、图和Java 代码，回答问题1 至问题3，将解答写在答题纸的对应栏内。

[说明]

已知四个类之间的关系如图 7-1 所示，分别对每个类的方法进行编号，例如 Shape的 perimeter()为 1 号，表示为“1:perimeter()” ，Rectangle 类的 perimeter()为 2 号，表示为“2:perimeter()” ，依此类推，其中，每个类的 perimeter方法签名相同。

[Java 代码]

Triangle tr = new Triangle();

Square sq = new Square();

Shape sh = tr;

[问题 1] 关于上述 Java代码中 sh 和 tr 的以下叙述中，哪两个是正确的（写出编号） 。

① sh 和 tr 分别引用同一个对象；

② sh 和 tr 分别引用同一类型的不同的对象；

③ sh 和 tr 分别引用不同类型的不同对象；

④ sh 和 tr 分别引用同一个对象的不同拷贝；

⑤ sh 和 tr 所引用的内存空间是相同的。

[问题 2] 写出下面消息对应的方法编号（如果该消息错误或者没有对应的方法调用，请

填写“无” ） 。

tr.height() （1）

sh.perimeter() （2）

sq.height() （3）

sq.perimeter() （4）

sh.height() （5）

tr.perimeter() （6）

[问题 3] 下列赋值语句中哪两个是合法的（写出合法赋值语句的编号） 。

① sq = sh; ② sh = tr; ③ tr = sq; ④ sq = tr; ⑤ sh = sq;

阅读以下说明和Java代码，请回答问题1和问题2。 【说明】 己知类Stock和类cxyjava都定义在cxyjava.java文件中，类Stock的定义中第14行前共有四行出现了错误，将下面代码修改正确并完善后的输出结果为： 0:0 1:23 【Java代码】 01

阅读以下应用说明、图和Java代码，根据要求回答问题1至问题5。

【说明】

Stack类是java. ntil包中专门用来实现栈的工具类。以下Java程序是一个不使用库函数而实现字符串反转的程序。例如，输入：123456，则输出：654321：输入：asdfeg，则输出：gefdsa。

【Java程序】

import java.applet.Applet;

import java.awt.*;

import java.awt.event.*;

import java.util.*;

public class UseStack extends Applet implements ActionListener

{ Stack MyStack;

Label prompt=new Label("输入要反转字符:");

Button pushBtn=new Button("压栈");

Button popBtn=new Button("弹栈"); //反转

TextField input=new TextField(5);

int[] DrawStack =new int[10]; //记录堆栈中数据

int[] PoppedOut=new int[20]; //记录被弹出的数据

int StackCnt=0; //记录模拟堆栈的数组中的数据个数

String msg=" ";

public void init()

{ MyStack=new Stack();

add(prompt);

add(input);

add(pushBtn);

add(popBtn);

pushBtn.addActionListener(this);

(1)

}

public void paint(Graphics g)

{ for (int i=10; i＜StackCnt; i++) //模拟显示堆栈内部的数据排列情况

{ g.drawRect(50,200-i*20,80,20);

g.drawString(Integer.toString(DrawStack[i]),80,215-i*20);

}

for (int i=0;(2) ) //显示被弹出的数据

g.drawString(Integer.toString(PoppedOut[i]),200+i*20,100);

g.drawString("堆栈",70,236);

g.drawString("栈底",135,225);

g.drawString("栈顶",160,225-StackCnt*20);

g.drawString(msg,200,140);

}

public void actionPerformed((3) )

{ if (e.getAct ionCommand () == "压栈") //压栈操作

{ if(StackCnt＜10)

{ MyStack.push(new Integer((4) ));

DrawStack[StackCnt++]=Integer.parseInt(input.getText() );

input.setText (" ");

}

else

msg="输入数据过多，请先弹栈!"

}

else if (e.getActionCommand () == "弹栈") //弹栈操作

{ if((5) )

{ StackCnt--;

PoppedOut[PopCnt++]=[(Integer)(MyStack.pop())).intValue();

}

else

msg="堆栈已空，不能再弹栈!";

}

repaint();

}

}

阅读以下说明和Java代码，回答问题

[说明]

任何一种程序都是为了解决问题而撰写的，解决问题时需要实现一些特定的运算法则。在策略(Strategy)模式下，可以更换实现算法的部分而不留痕迹，切换整个算法，简化改为采用其他方法来解决同样问题。

以下是一个“剪刀石头布”游戏。猜拳时的“策略”有2种方法：第一种是“猜赢后继续出同样的招式”(WinningStrategy)，第二种是“从上一次出的招式种，以概率分配方式求出下一个招式的几率”(ProbStrategy)。程序中定义了Hand类表示猜拳时的“手势”，类内部以0(石头)、1(剪刀)、2(布)来表示。Hand类的实例只会产生3个。

以下是Java语言实现，省略了不相关属性及方法，方法实现体亦有所省略，能够正确编译通过。

[Java代码]

//Hand.java文件

public class Hand{

public static final int HANDVALUE_GUU = 0; //石头

public static final int HANDVALUE_CHO = 1; //剪刀

public static final int HANDVALUE_PAA = 2; //布

public static final Hand[] hand = {

new Hand(HANDVALUE_GUU),

new Hand(HANDVALUE_CHO),

new Hand(HANDVALUE_PAA),

};

private int handvalue;

(1) Hand(int handvalue){

this.handvalue = handvalue;

}

public (2) Hand getHand(int handvalue)(//从值取得对象实例

return hand[handvalue];

}

}

//Strategy.java文件

public interface Strategy{

public (3) Hand nextHand();

}

//ProbStrategy.java文件

import java.util.Random;

public class ProbStrategy implements Strategy{

public Hand nextHand(){

int handvalue = 0;

/*省略具体实现*/

return Hand.getHand(handvalue);

}

}

//WinningStrategy.java文件

import java.util.Random;

public class WinningStrategy implements Strategy {

/*省略了不相关属性*/

public Hand nextHand(){

if(!won){

prevHand = Hand.getHand(random.nextInt(3));

}

return prevHand;

}

}

//Player.java文件

public class Player {

private String name;

private Strategy strategy;

public Player(String name, (4) strategy){

this.name = name;

this.strategy = strategy;

}

public Hand nextHand(){//向战略请示手势

return (5) ;

}

}

请仔细阅读以下关于某传输系统的技术说明、状态转换图及Java程序，根据要求回答问题1～问题2。

[说明]

传输门是传输系统中的重要装置。传输门具有Open(打开)、Closed(关闭)、Opening(正在打开)、 StayOpen(保持打开)和Closing(正在关闭)5种状态。触发状态的转换事件有click、complete和timeout3种。事件与其相应的状态转换如图7-16所示。

下面的[Java代码1]与[Java代码2]分别用两种不同的设计思路对传输门进行状态模拟，请填补代码段中的空缺语句。

[Java代码1]

请将以上[Java代码1]与[Java代码2]程序段中，(1)～(7)空缺处的语句填写完整。

阅读以下说明和Java代码，请回答问题1和问题2。

【说明】

己知类Stock和类cxyjava都定义在cxyjava.java文件中，类Stock的定义中第14行前共有四行出现了错误，将下面代码修改正确并完善后的输出结果为：

0:0

1:23

【Java代码】

01 public class Stock{

02 static {

03 shares = 0;

04 share val = 0.0;

O5 }

06 public Stock(){getData();}

07 public Stock(int n, iht pr=0){

08 shares = n;

09 share val = pr;

10 getData();

11 }

12 public void getData() {

13 System.out.println(shares + ":"+share_val);

14 }

15 private int shares;

16 private int share_val;

17 };

18

19 public class cxyjava{

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

21 Stock a = (1) ;

22 Stock b = new Stock(1,23);

23 //其他无输出代码省略

24 }

25 }

请指出错误所在行号并给出该行修改后的完整结果。

阅读以下说明，回答问题，将解答填入答题纸的对应栏内。

[说明]

某电子商务网站采用ASP+SQL Server开发的电子商务网站系统，提供了商品查询、网上购物车、订单管理、后台商品管理和支付等功能。其后台修改商品页面如图6-12所示。

通常，客户端浏览器不能执行(1)。

(1) A．HTML代码 B．VBScript代码 C．JavaScript代码 D．ASP内置对象代码