以下代码能够编译通过吗，为什么？

以下代码能够编译通过吗，为什么？

unsigned int const size1 = 2;

char str1[ size1 ];

unsigned int temp = 0;

cin >> temp;

unsigned int const size2 = temp;

char str2[ size2 ];

以下代码能够编译通过吗，为什么？unsigned int const size1 = 2char str1[ size1 ]unsigned以下代码能够编译通过吗，为什么？ unsigned int const size1 = 2 char str1[ size1 ] unsigned int temp = 0 cin $amp>amp$gt temp unsigned int const size2 = temp char str2[ size2 ]

以下说法哪项是正确的()

A、以上代码可通过编译

B、不能通过编译，因为没有实现MouseListener接口中的所有方法

C、不能通过编译，因为类头定义不能分行

D、能通过编译，若组件用该类作为Mouse的监听者并且接收了mouse-exited事件，则在执行过程中会抛出异常

在J2EE中，给定某Servlet的代码如下，编译运行该文件，以下陈述正确的是( )

public class Servletl extends HttpServlet{

public void init() throws ServletException{

}

public void service(HttpServletRequest

request,HttpServletResponse response)throws

ServletException,IOException{

PrintWriter ut=response.getWriter();

out.println(“hello!”);

}

}

A、编译该文件时会提示缺少doGet()或者doPost()方法，编译不能够成功通过

B、编译后，把Servletl.class放在正确位置，运行该Servlet，在浏览器中会看到输出文字：hello!

C、编译后，把Servletl.class放在正确位置，运行该Servlet，在浏览器中会看不到任何输出的文字

D、编译后, 把Servletl.class放在正确位置，运行该Servlet，在浏览器中会看到运行期错误信息

A．编译时出错：第3行的逻辑表达式语法不正确。

B．运行时打印“We are equal 30”。

C．运行时打印“Not equal! 20”。

D．以上选项都不正确。

A．编译时出错：在构造方法中不允许给staticfinal类型的成员变量赋值。

B．编译时出错：main方法中无法访问private类型的变量var。

C．运行时出错：变量var没有被初始化。

D．运行时打印“Value is: 1”。

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

[说明]

在某些系统中，存在非常复杂的对象，可以采用循序渐进的方式进行组合将小对象组合，成复杂的对象。

以下实例展示了Builder(生成器)模式。该实例用来建立“文件”，文件内容包括：一个标题、一串字符以及一些有项目符号的项目。Builder类规定组成文件的方法，Director类利用这个方法产生一份具体的文件。图6-1显示了各个类间的关系。

以下是Java语言实现，能够正确编译通过。

[Java代码]

//Builder. java文件

public (1) class Builder {

public abstract void makeTitle(String title);

public abstract void makeString(String str);

public abstract void makeItems(String[] items);

public abstract Object getResult();

}

//Director. java文件

public class Director{

private (2) builder;

public Director(Builder builder){

this. builder = builder;

}

public Object construct(){

builder.makeTitle("Greeting");

builder.makeString("从早上到白天结束");

builder.makeItems(new String[]{"早安", "午安",});

builder.makeString("到了晚上");

builder.makeItems(new String[]("晚安", "好梦",});

return builder.getResult();

}

}

//TextBuilder.java文件

public class TextBuilder (3) Builder{

private StringBuffer buffer = new StringBuffer();

public void makeTitle(String title){

buffer.append("『" + title + "』"\n\n");

}

public void makeString(String str){

buffer.append('■' + str + "\n\n ");

}

public void makeItems(String[] items){

for(int i = 0; i< (4) ; i++){

buffer.append('·' + items[i] + "\n");

}

buffer.append("\n");

}

public Object getResult(){

return buffer.toString();

}

}

//Main.java文件

public class Main {

public static void main(String[] args) {

Director director = new Director(new TextBuilder());

String result = (String)director. (5) ;

System.out.println(result);

阅读以下说明和C代码(代码13-4)，将应填入(n)处的字句写在对应栏内。

【说明】

在一公文处理系统中，开发者定义了一个公文结构OfficeDoc，其中定义了公文应该具有的属性。当公文的内容或状态发生变化时，与之相关联的DocExplorer结构的值都需要发生改变。一个OfficeDoc结构能够关联一组DocExplorer结构。当OfficeDoc结构的内容或状态发生变化时，所有与之相关联的DocExplorer结构都将被更新，这种应用被称为观察者模式。以下代码采用C语言实现，能够正确编译通过。

【代码13-4】

include＜stdio.h＞

define OBS_MAXNUM 20 /*一个OfficeDoc变量最多能够关联的DocExplorer变量的个数*/

typedef void( (1) )(struc OffieeDoc*, struct DoeExplorer*)I;

struct DocExplorer{

func update;/*DocExplorer结构采用的更新函数*/

/*其它的结构字段省略*/

};

struet OffieeDoc{

(2) myObs[OBS_MAXNUM];

/*存储所有与OfficeDoc相关联的DocExplorer结构指针*/

int index;/*与OffieeDoc结构变量相关联的DoeExplorer结构变量的个数*/

}；

void attaeh(struct OfficeDoc*doc, struct DocExplorer*ob){

/*关联Observer结构ob与OffieeDoe结构doe*/

int loop=0;

if(doc-＞index＞=OBS_MAXNUM｜｜ob==NULL)return;

for(loop=0, loop＜doc-＞index; loop++)

if(doc-＞myObs[loop]==ob)return;

doc-＞myObs[doe-＞index]=ob；

doc-＞index++;

}

void detaeh(struct OfficeDoc*doc, struct DocExplorer*ob){

/*解除doc结构与ob结构间的关联*/

int loop;

if(ob==NULL)return;

for(loop=0;loop＜doc-＞index; loop++){

if(doe-＞myObs[loop]==ob){

if(loop＜=doc-＞index-2)

doc-＞myObs[loop]=doc-＞myObs[(3)];

doc-＞myObs[doc-＞index-1]=NULL;

doc-＞index——;

breack;

}

}

}

void updatel(struct OfficeDoe*doe, struct DoeExplorer *ob){

/*更新ob结构的值，更新代码省略*/

} void update2(struct OffieeDoc*doc,struet DocExplorer *ob){

/*更新ob结构的值，更新代码省略*/

}

void notifyObs(struct OfficeDoc* doc){

/*当doc结构的值发生变化时，通知与之关联的所有DocExplorer结构变量*/

int loop;

for(loop=0; loop＜doc-＞index; loop++){

(doc-＞myObs[loop])-＞update((4));

}

}

void main(){

struct OfficeDoc doc; /*定义一了OfficeDoe变量*/

struct DocExplorer explorer1, explorer2; /*定义两个DocExplorer变量*/

/*初始化与OfficeDoc变量相关的DocExplorer变量个数为0*/

doc.index=0;

explorer1.update=update1; /*设置explorer1变量的更新函数*/

explorer2. update=update2; /*设置explorer2变量的更新函数*/

attach(&doc, &explorer1); /*关联explorer1与doc对象*/

attach(&doc, &explorer2); /*关联explorer2与doc对象*/

/*其它代码省略*/

(5); /*通知与OfficeDoe相关的所有DoeExploer变量*/

return;

}

阅读以下说明和C代码，将应填入(n)处。

[说明]

在一公文处理系统中，开发者定义了一个公文结构OfficeDoc，其中定义了公文应该具有的属性(字段)。当公文的内容或状态发生变化时，与之相关联的DocExplorer结构的值都需要发生改变。一个OfficeDoc结构能够关联一组DocExplorer结构。当OfficeDoc结构的内容或状态发生变化时，所有与之相关联的DocExplorer结构都将被更新，这种应用被称为观察者模式。以下代码采用C语言实现，能够正确编译通过。

[C代码]

include ＜stdio.h＞

define OBS_MAXNUM 20 /*一个OfficeDoc变量最多能够关联的*/

/*DoeExplorer变量的个数*/

typedef void((1))(struct OfficeDoc*,street DocExplorer*);

struct DocExplorer{

func update;/* DocExplorer结构采用的更新函数*/

/*其他的结构字段省略*/

};

struct OfficeDoc{

(2) myObs[OBS_MAXNUM];

/*存储所有与OfficeDoc相关联的DoeExplorer结构指针*/

int index;/*与OfficeDoc结构变量相关联的DocExplorer结构变量的个数*/

};

void attach(struet OfficeDoc *doc, struet DocExplorer *ob){

/*关联Obersver结构ob与OfficeDoe结构doc*/

int loop=0;

if(doc-＞index ＞=OBS_MAXNUM || b==NULL) return;

for(loop=0; loop ＜doc-＞index; loop++)

if(doc-＞myObs[loop]==ob)return;

doc-＞myObs[doe-＞index]=ob;

doc-＞index++;

)

void detach(struct OfficeDoc *doc, struct DocExplorer *ob){

/*解除doc结构与ob结构间的关系*/

int loop;

if(ob==NULL)return;

for(loop=0; loop ＜doc-＞index; loop6++){

if(doc-＞myObs[loop]==ob){

if(loop＜=doc-＞index-2)

doe-＞myObs[loop]=doc-＞myObs[ (3) ];

doc-＞myObs[doe-＞indox-1]=NULL;

doe-＞index--;

break;

}

}

}

void updatel(struct OfficeDoc *doc,struct DocExplorer *ob){

/*更新ob结构的值，更新代码省略*/

}

void update2(stmct OfficeDoc *doc, struct DocExplorer *ob){

/*更新ob结构的值，更新代码省略*/

}

void notifyObs(struet OfficeDoc *doc){

/*当doc结构的值发生变化时，通知与之关联的所有DocExplorer结构变量*/

int loop;

for(loop=0; loop ＜doc-＞index; loop++){

(doc-＞myObs[loop])-＞update((4));

}

}

void main(){

stmct OfficeDoc doc;/*定义一OfficeDoc变量*/

struct DocExplorer explorer1, explorer2;/*定义两个DocExplorer变量*/

/*初始化与OfficeDoc变量相关的DocExplorer变量个数为0*/

doc.index=0;

explorer1.update=update1;/*设置explorer1变量的更新函数*/

explorer2.update=update2;/*设置explorer2变量的更新函数*/

attaeh(&doc,&explorer1);/*关联explorer1与doc对象*/

attach(&doc,&explorer2);/*关联explorer2与doc对象*/

/*其他代码省略*/

(5);/*通知与OfficeDoc相关的所有DocExplorer变量*/

return;

}

阅读以下函数说明和Java代码，将应填入(n)处的字句写在对应栏内。

[说明]

很多时候，希望某些类只有一个或有限的几个实例，典型解决方案是所谓单身(Singleton)模式。但在多线程情况下，Singleton模式有可能出现问题，需要进行同步检查。如果对“检查singleton对象是否已经创建”进行同步，则存在严重的瓶颈，所有的线程都必须等待检查对象是否存在。解决方式是一种称为Double-Checked-Locking模式，其意图是将非必须的锁定优化掉，同步检查最多只发生一次，因此不会成为瓶颈。以下是Java语言实现，能够正确编译通过。

[Java代码]

public class USTax {

private static USTax instance=null;

(1) USTax(){}

private (2) static void doSync(){

if(instance==null){

System.out.println("实例不存在，创建实例..");

instance=(3);

System.out.println("实例创建成功");

}else{

System.out.println("实例已被创建了");

}

}

public static USTax getInstance(){

if(instance==null){

System.out.println("实例暂时不存在");

(4);//同步控制

}else{

System.out.println("实例已经存在");

}

return (5);

}

}

(1)