程序设计学习通超星期末考试答案章节答案2024年

程序设计学习通超星期末考试章节答案2024年52.[其它]请编码实现动物世界的继承关系：1)动物（Animal）具有行为：吃（eat）、睡觉（sleep）说明：只要在方法中打印一句话即可。例如Publicvoideat(){

System.out.println(“动物在吃东西”)；}2)动物包括：兔子（Rabbit），老虎（Tiger）3)这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡觉的行为是一致的。请通过继承实现以上需求，并编写测试类AnimalTest进行测试。作业提交后，可以查看答案

答案:packagehomework2;publicclassAnimalTest{publicstaticvoidmain(Stringargs[]){Animalr=newRabbit();r.eat();r.sleep();r=newTiger();r.eat();r.sleep();}}classAnimal{publicvoideat(){System.out.println("动物在吃东西");}publicvoidsleep(){System.out.println("动物在睡觉");}}classRabbitextendsAnimal{publicvoideat(){System.out.println("兔子在吃草");}}classTigerextendsAnimal{publicvoideat(){System.out.println("老虎在吃肉");}}/star3/origin/6fb7cdd544f2d94fae170406334cf109.png

答案:publicabstractclassEmployee{

Stringname;

Stringid;

doublepay;

publicEmployee(Stringname,Stringid,doublepay){

=name;

this.id=id;

this.pay=pay;

}

publicabstractvoidwork();}classProgrammerextendsEmployee{

publicProgrammer(Stringname,Stringid,doublepay){

super(name,id,pay);

}

publicvoidwork(){

System.out.println("程序员疯狂编码");

}}classManagerextendsEmployee{

privatedoublebouns;

publicManager(doublebouns,Stringname,Stringid,doublepay){

super(name,id,pay);

this.bouns=bouns;

}

publicvoidwork(){

System.out.println("项目经理谨慎管理");

}}publicclassTest{

publicvoidworkTest(Employeee){

e.work();

}

publicstaticvoidmain(String[]args){

Testt=newTest();

t.workTest(newProgrammer("码农","01",20));

t.workTest(newManager(10000,"管理","02",20));

}}同步代码块中的锁对象可以是任意类型的对象，但多个线程共享的锁对象必须是【

】的。

答案:唯一Java中有两种创建线程的方式，但大部分的多线程应用都会采用【

】方式来创建线程。

答案:实现Runnable接口Java中thread类的sleep()方法可以让让当前线程进入【

】状态。

答案:休眠在Thread类中提供了一个【

】方法来实现线程插队。

答案:join同步锁可以是任意【

】。

答案:对象基于TCP/IP的参考模型将协议分成四个层次，分别是【

】、【

】、【

】和【

】。

答案:链路层；网络层；传输层；应用层【

】指本机地址，该地址一般用来测试使用。

答案:在JDK中，提供了一个与IP地址相关的【

】类，该类用于封装一个IP地址。

答案:InetAddress【

】是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。

答案:UDPDatagramPacket类的【

】方法用于返回发送端或者接收端的端口号。

答案:getPort(设i、j、k为类X中定义的int型变量名，下列类X的构造函数中正确的是(

)。

答案:

X(inti){...}

;X(inti,intj){...}

;X(inti,intj,intk){...}

Java中的每一个类：

答案:只能有一个父类

;可以没有父类

在定义一个类时，若希望某个成员方法调用范围是同一包内所有类，其修饰词应为：

答案:public

;protected;默认关于接口以下说法正确的是：

答案:接口中的变量必须用publicstaticfinal三个修饰词修饰；;一个接口可以继承多个父接口；关于Java中包的概念，以下正确的是：

答案:包是一些类与接口的集合；;

Java的包中可以包含子包；;包中的类不能访问子包中非public的类。在Java中，下列关于方法重载的说法中错误的是（）。

答案:

重载方法的返回类型必须一致;一个方法在所属的类中只能被重载一次给定Java代码如下所示，在横线处新增下列（）方法，是对cal方法的重载。publicclassTest{

publicvoidcal(intx,inty,intz){}

}

答案:publicintcal(intx,inty,floatz){return0;};publicvoidcal(intx,intz){}下面关于抽象类的说法那些是正确的?(

)

答案:该类不能实例化

;抽象类的定义中必须包含abstract关键字（）类是所有异常类的父类。

答案:Throwable现有两个类A、B，以下描述中表示B继承自A的是(

)。

答案:class

B

extends

A

一个类中，用static修饰的变量称静态变量：

答案:与实例变量一样，每个对象中的值互相独立。属于对“synchronized”的使用原则的是①不需要在多个线程中使用共享资源时，就没有必要使用②如果方法只是放回对象的值，而不进行修改，就没有必要使

答案:①②下列有关线程的两种创建方式说法错误的是（

）

答案:通过继承Thread类与实现Runnable接口创建多线程这两种方式没有区别在TCP/IP网络中，为各种公共服务和系统保留的端口号范围是（

）

答案:0~1023输入字符流的父类是（

）

答案:Reader对于FileInputStream来说，从方向上来分，它是

答案:输入流输入字节流的父类是

答案:InputStream下面哪个流可以在逻辑上连接一组输入流，即将这一组输入流视为一个连续的输入流。

答案:SequenceInputStream三层模型这种休系结构为企业应用提供了良好的运行性和可扩展性,那么以下哪个选项不属于三层模型呢?

答案:NetBeans6.8开发工具JDBCAPI支持两种应用方式：两层模型和三层模型，以下说法哪项是错误的？

答案:JDBC驱动程序负责独立于数据库的数据库连接访问。它属于数据源这一层。以下哪类应用程序不属于JDBC的应用场合

答案:ASP应用程序以下哪项不是JDBC的组成部分?

答案:数据库使用JDBCAPI不可以完成的工作是?

答案:设计用户界面下列选项中，哪个是java语言所有类的父类

答案:Object有一个类A，以下为其构造方法的声明，其中正确的是

答案:publicA(intx){...}下列类头定义中，错误的是

答案:publicxextendsy{...}下面对构造方法的描述不正确是

答案:构造方法可以有参数，所以也可以有返回值下述哪些说法是不正确的？

答案:实例变量是用static关键字声明的端口号的取值范围是0~65535。（

）

答案:对IP地址用于唯一标识一台计算机，它有IPv4和Ipv6两个版本。（

）

答案:对处于等待的线程，必须被其他线程唤醒后才能继续运行。（

）

答案:对Java多线程中，如果某个资源在一段时间内只能由一个进程占有，不能同时被两个或两个以上的进程占有。必须在占有该资源的进程主动释放它之后，其它进程才能占有该资源，这样就一定会出现死锁。（

）

答案:错Statement接口的executeUpdate(Stringsql)返回值是int，它表示数据库中受该SQL语句影响的记录的数目。（

）

答案:对使用DriverManager.registerDriver进行驱动注册时，数据库驱动会被注册2次。（

）

答案:对FileWriter用于向文件中写入字符，它属于字符输出流。（

）

答案:对Java中的数据传输“流”都位于java.io包中，称为IO(输入/输出)流（

）

答案:对BufferedReader和BufferedWriter是具有缓冲功能的流，使用它们和使用其他流没有任何区别。（

）

答案:错Statement接口的executeUpdate(Stringsql)方法用于执行SQL中的insert、【

】和delete语句。

答案:updateResultSet接口中，能将游标移动到此ResultSet对象的最后一行的方法是【

】。

答案:last(java.io包中可以用于从文件中直接读取字符的是【

】类。

答案:FileReaderIO流通常都是成对出现的，即【

】流和【

】流一起使用。

答案:输入；输出File类中用于删除文件或整个目录的方法是【

】。

答案:delete(同一类中有两个以上方法同名称方法重载，Java语言规定：

答案:重载方法的参数表必须不同；下面是有关子类继承父类构造函数的描述，其中正确的是(

)。

答案:子类通过super关键字调用父类的构造函数。

下列方法定义中，正确的是(

)。

答案:intx(inta,intb)

{returna-b;}

下面关于DatagramSocket的说法正确的是

答案:创建接收UDP套接字时不需要指定端口号要创建一个用于保存接收到的数据的数据报，应使用以下哪个构造器

答案:DatagramPacket(byte[]buff,intlength)或DatagramPacket(byte[]buff,intoffset,intlength)要创建一个发送数据的数据报，应使用以下哪个构造器：

答案:DatagramPacket(byte[]buff,intlength,InetAddressaddress,intport)或DatagramPacket(byte[]buff,intoffset,intlength,InetAddressaddress,intport)关于TCP和UDP的论述正确的是

答案:所有的TCP、UDP等数据都以IP数据报格式传输Runnable接口定义了如下哪些方法？

答案:run()编写线程类，可以通过实现那个接口来实现

答案:Runnable编写线程类，要继承的父类是

答案:Thread实现线程的方法之一是覆盖Thread类的run方法，以下run方法书写正确的是

答案:publicvoidrun()下列哪个方法可以实现多线程

答案:继承Thread类关于对象序列化(serialize)说法错误的是

答案:实现java.io.Serializable接口的对象是面向字符的可以采用Writer层次结构的流。对一个Serializable对象而言，所有的序列化操作都会自动进行，除了用（

）关键字声明的属性不会序列化。

答案:transientObjectOutputStream的对象不能访问以下哪个方法（

）

答案:readObject()Serializable接口属于（

）包

答案:javax.swing在编写Java

Application程序时，若需要使用到标准输入输出语句，必须在程序的开头写上

答案:import

java.io.*;

下面哪个流类不是抽象类

答案:OutputStreamWriter关于File类说法错误的是

答案:可以读写文件对文件不可进行的操作有（

）。

答案:删除文件System.in是下列哪个流的对象（

）。

答案:InputStreamJava语言中提供了一个▁线程，自动回收动态分配的内存。

答案:垃圾收集下列关于线程性质说法错误的是：

答案:线程不能创建其他线程52.[其它]编写一个程序，创建一个HashMap对象，用于存储银行储户的信息(其中储户的主要信息有储户的ID，姓名和余额)。另外，计算并显示其中某个储户的当前余额。

答案:publicclassMyMap{

publicstaticvoidmain(String[]args){

BarkUseruser1=newBarkUser(101,"祝枝山",10000);

BarkUseruser2=newBarkUser(102,"文征明",20000);

BarkUseruser3=newBarkUser(103,"祝枝山",30000);

HashMapmap=newHashMap();

map.put(1,user1);

map.put(2,user2);

map.put(3,user3);

for(Entryentry:map.entrySet()){

System.out.println(entry.getValue());

}

}}classBarkUser{

intid;

Stringname;

doublecount;

publicBarkUser(intid,Stringname,doublecount){

super();

this.id=id;

=name;

this.count=count;

}

@Override

publicStringtoString(){

//TODOAuto-generatedmethodstub

return"储户ID为"+this.id+",姓名为"++"的储户账户余额为"+this.count;

}}51.[其它]创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NumOfWheels方法，使它显示一个字符串值。*创建两个类Car和Motorbike从Vehicle类继承，并在这两个类中实现NumOfWheels方法。在Car类中，应当显示“四轮车”信息；而在Motorbike类中，应当显示“双轮车”信息。*创建另一个带main方法的类，在该类中创建Car和Motorbike的实例，并在控制台中显示消息。

答案:abstractclassVehicle{publicabstractvoidNumOfWheels();}classCarextendsVehicle{publicvoidNumOfWheels(){

System.out.println("这个车4个轮子");}}classMotorbikeextendsVehicle{publicvoidNumOfWheels(){

System.out.println("这个车2个轮子");}}publicclassDemo1{publicstaticvoidmain(String[]args){

Carc=newCar();

c.NumOfWheels();

Motorbikem=newMotorbike();

m.NumOfWheels();}}对于相同的SQL语句，Statement对象只会对其编译执行一次。（

）

答案:错FileOutputStream是操作文件的字节输出流，专门用于把数据写入文件。（

）

答案:对分析如下Java代码，如果想在控制台上输出“B类的test()方法”，则在横线处应填入（）。classA{

publicvoidtest(){

System.out.println("A类的test()方法");

}}classBextendsA{

publicvoidtest(){

System.out.println("B类的test()方法");

}

publicstaticvoidmain(Stringargs[]){

}}

答案:a=newB();a.test();;Bb=newB();b.test();在Java接口中，下列选项中属于有效的方法声明是（）。

答案:publicvoidaMethod();

;voidaMethod();

给定java代码，如下：

abstract

class

Shape

{

publicabstract

void

draw(

);

}

要创建Shape类的子类Circle，以下代码正确的是(

)。

答案:abstract

class

Circle

extends

Shape{

}

;class

Circle

extends

Shape{

void

draw(

){}

}如果Triangle类继承自Shape类,那么Shape类中的哪些变量可以用于Triangle类中?

()

答案:Shape类中所有public和protected变量

下列选项中关于Java中封装的说法错误的是（）。

答案:

类的属性必须进行封装，否则无法通过编译下面Java代码的运行结果是（

）。classPenguin{privateStringname=null;//名字privateinthealth=0;//健康值privateStringsex=null;//性别publicvoidPenguin(){health=10;sex="雄";System.out.println("执行构造方法。");}publicvoidprint(){System.out.println("企鹅的名字是"+name+"，健康值是"+health+"，性别是"+sex+"。");}publicstaticvoidmain(String[]args){Penguinpgn=newPenguin();pgn.print();}}

答案:

企鹅的名字是null，健康值是0，性别是null。在Java类中，使用以下（）声明语句来定义公有的int型静态常量MAX。

答案:publicstaticfinalintMAX=100;关于以下程序叙述正确的是：classBase{Base(inti){System.out.print(“Base

”);}}classTestextendsBase{Test(){System.out.print(“Test

”);}publicstaticvoidmain(String[]args){

Testb=newTest();

}}

答案:程序运行出错，因为Base类未定义构造方法；在Java中，有如下两个类Student和Person。如果Student是Person的子类，则下列声明对象x的语句中错误的是（）。

答案:Student

x

=

new

Person()

若有如下接口A的定义，下列哪些类下确实现了该接口interface

A{voidmethod1(inti);voidmethod2(intj);}

答案:class

B

implements

A{void

method1(inti){}void

method2(intj){}}一个类中，用static修饰的方法称静态方法：

答案:它不能直接调用类中其它不用static修饰的方法；用abstract修饰的类称为抽象类，它们：

答案:只能用以派生新类，不能用以创建对象；子类中定义的方法与父类方法同名且同形时称父类方法被覆盖（也称重写）以下说法正确的是：

答案:父类中用final修饰的方法不允许被复盖；关于在子类中调用父类构造方法的问题，下述说法正确的是：

答案:子类构造方法只能在第一条语句调用父类的构造方法；在Java类中，使用以下（

）声明语句来定义公有的int型静态常量MAX。

答案:publicstaticfinalintMAX=100;下述关于继承的说法正确的是：

答案:被继承的父类代码必须与子类代码在同一个源代码文件（.java文件）内。以下程序运行结果是：

publicclassFatherClass{publicFatherClass(){

System.out.print("Father");}}publicclassChildClassextendsFatherClass{publicChildClass(){

System.out.print("Child");}publicstaticvoidmain(String[]args){

FatherClassfc=newChildClass();}}

答案:

FatherChild现有两个类A、B，以下描述中表示B继承自A的是(

)。

答案:

classBextendsA下面说法正确的是(

)。

答案:final可修饰类、属性、方法。

下列类头定义中，正确的是(

)。

答案:publicclassxextendsy

{....}

为了使包sos在当前程序中可见，可以使用的语句是(

)。

答案:importsos.*;

设x,y均为已定义的类名，下列声明对象x1的语句中正确的是(

)。

答案:

xx1=newx();

下列整型的常量属性i的定义中，正确的是

答案:staticfinalinti=100;定义主类的类头时可以使用的访问控制符是

答案:public

为了区分重载多态中同名的不同方法，要求

答案:采用不同的参数列表IP地址用于唯一标识一台计算机,它有IPv4和IPv6两个版本。

答案:对Socket类的getInputStream()返回一个InputStream类型的输入流对象,如果该对象是由服务器端的Socket返回,就用于读取服务端发送的数据。

答案:错门户网站的服务器都是多线程实现的。

答案:对bytebuf=newbyte1024;用于定义1024个字节数组的缓冲区。

答案:对执行Thread.sleep(5000)语句模拟服务器执行其他功能占用的时间。

答案:对InetAddress类实现了对互联网协议地址的封装。

答案:对TCP是一种用户数据报协议。

答案:错DatagramSocket类中提供了accept()方法用于接收数据报包。

答案:错UDP协议是面向无连接的协议,可以保证数据的完整性。

答案:错在聊天程序设计中,initSocket()方法使用了while(true)循环,目的是为了当用户填写的监听端口号不满足要求时,反复地弹出输入窗口,让用户重新输入端口号。

答案:对IP地址中有一个回送地址【】,指本机地址。

答案:当客户端和服务端建立连接后,数据是以【】的形式进行交互的,从而实现通信。

答案:IO流在JDK中,提供了一个与IP地址相关的【】类,该类用于封装一个IP地址,并提供了一系列与IP地址相关的方法。

答案:InetAddress在下载文件时必须采用【】协议。

答案:TCP在介绍TCP/IP结构时,提到传输层的两个重要的高级协议,分别是【】和TCP。

答案:UDPServerSocket对象负责监听某台计算机的某个端口号,在创建ServerSocket对象后,需要继续调用该对象的【】方法,接收来自客户端的请求。

答案:accept(在JDK中提供了两个用于实现TCP程序的类,一个是【】类,用于表示服务器端;一个是Socket类,用于表示客户端。

答案:ServerSocket在计算机命令行窗口输入【】命令可以来查看当前计算机端口占用情况。

答案:netstat-anbJDK中提供了一个【】类,该类用于封装UDP通信中发送或者接收的数据。

答案:DatagramPacket使用UDP协议开发网络程序时,需要使用两个类,分别是【】和【】

答案:DatagramPacket、DatagramSocket传输层主要使网络程序进行通信,在进行网络通信时,可以采用TCP协议,也可以采用【】协议。

答案:UDPUDP是一种面向无连接的协议,因此,在通信时发送端和接收端【】建立连接。

答案:不用JDK中提供了一个【】类,用于封装UDP通信中发送或者接收的数据。

答案:DatagramPacketJDK提供了【】类,可以发送和接收DatagramPacket数据报。

答案:DatagramSocketTCP通信同UDP通信一样,都能实现两台计算机之间的通信,通信的两端则都需要创建【】对象。

答案:Socket在JDK中提供了两个用于实现TCP程序的类,分别是【】类和【】类。

答案:ServerSocket、SocketTCP通信时,首先要创建代表服务器端的【】对象。

答案:ServerSocket下面关于IP地址的描述中,正确的是(

)

答案:IP地址可以唯一标识一台计算机;目前,IP地址广泛使用的版本是IPv4;通常会将IP地址写成十进制的形式下列关于使用多线程完成TCP网络程序的描述中,正确的是(

)

答案:服务器端程序都是允许被多个应用程序访问的。;服务器端程序都是多线程实现的。;服务器端为每个客户端创建一个对应的Socket。以下哪些属于InetAddress类的一些常用方法()。

答案:getByName(Stringhost);;getLocalHost();;getHostName();;getHostAddress()以下属于DatagramPacket类中的常用方法的有()。

答案:getPort();;getData();;getLength()。在TCP/IP网络中,为各种公共服务和系统保留的端口号范围是(

)

答案:0~1023下列关于Socket类的描述中,错误的是()

答案:Socket类中定义的close()方法用于关闭输入\\输出流对象。InetAddress类中能获取IP地址及主机名的方法是(

)

答案:getLocalHost()下列说法中,错误的是(

)

答案:使用UDP协议传送数据保证了数据的完整性下列关于UDP协议特点的描述中,错误的是()

答案:在UDP协议连接中,必须要明确客户端与服务器端。下列选项中,用于将发送数据进行打包的类是(

)

答案:DatagramPacket下列选项中,哪个是TCP协议的“三次握手”中的第一次握手(

)

答案:客户端向服务器端发出连接请求,等待服务器确认。下列层次中,哪一层是整个TCP/IP协议的核心()

答案:网络层TCP是一种用户数据报协议。（

）

答案:错在TCP程序中，ServerSocket类的实例对象可以实现一个服务器端的程序。（

）

答案:对目前应用最广泛的网络通信协议是UDP协议。（

）

答案:错以下哪个类用于实现TCP通信的客户端程序（

）

答案:SocketHTTP协议服务的默认端口号是（

）

答案:80下列层次中，哪一层是整个TCP/IP协议的核心（

）

答案:网络层如果URLurl=newURL("")则url.getFile()得到的结果是

答案:""关于URL的语法格式正确的是

答案:://:/#常用IP地址有A、B、C三类，属于

答案:C类网络层上的主要协议是

答案:IP协议下面说法不正确的是：

答案:TCP是TCP/IP协议族中最为核心的协议传输层的功能主要是：

答案:为两台主机上的应用程序提供端对端的通信计算机网络中实体之间的有关通信规则约定的集合称为

答案:协议FTP协议主要用于：

答案:交互式的文件传输下面可以用于表示本机的IP地址是

答案:下面关于Socket的说法错误的是：

答案:使用Socket编程要充分考虑数据链路传输错误。下面关于Socket编程说法不正确的是：

答案:通过Socket获得的是字节流，因此不能发送字符信息。下面哪个方法是类.Socket的成员方法，用来获取Socket的输入流。

答案:getInputStream()下面关于ServerSocket的描述错误的是：

答案:一个ServerSocket只能在一个端口监听，因此一个ServerSocket只能接收到一个客户端请求。Java多线程中,如果进程所获得的资源在未使用完毕之前,资源申请者不能强行地从资源占有者手中夺取资源,而只能由该资源的占有者进程自行释放,就一定会出现死锁。

答案:错如果前台线程全部死亡,后台线程也会自动死亡。

答案:对JAVA中Thread类的sleep()是静态方法,只能控制当前正在运行的线程休眠,而不能控制其它线程休眠。

答案:对如果两个线程访问不同类中的静态同步方法,这两个线程是不需要等待的

答案:对线程安全问题其实就是由多个线程同时处理共享资源所导致的,通过同步代码块能够解决该问题。

答案:对当在某个线程中调用其它线程的join()方法时,调用的线程将被阻塞,直到被join()方法加入的线程执行完成后它才会继续运行

答案:对Runnable接口中只有一个run()方法。

答案:对线程对象创建完成时,该线程处于就绪状态

答案:错线程安全问题其实就是由多个线程同时处理共享资源所导致的。

答案:对Thread类中提供了一个join()方法,可以实现线程插队的功能。

答案:对使用synchronized关键字修饰的代码块,被称作同步代码块。

答案:对notify()方法唤醒等待线程后,该线程会立即被CPU执行。

答案:错对Java程序来说,如果一个进程中只有前台线程运行,这个进程就会结束。

答案:错yield方法和sleep方法相同,都可以让当前正在运行的线程进入阻塞状态。

答案:错使用Thread类创建多线程程序可以实现资源共享的效果。

答案:错实现Runnable接口比继承Thread类创建线程的方式扩展性更好。

答案:对多线程操作共享资源一定会导致线程的安全问题。

答案:错yield()方法和sleep()方法相同,都可以让当前正在运行的线程暂停。

答案:错Java中可以通过yield方法来实现线程的让步。

答案:对实现Runnable接口方式创建线程同样需要重写run()方法。

答案:对使用Java提供的线程池来创建多线程,进一步优化线程管理

答案:对JAVA的JDK中提供了一个线程类Thread,通过继承该类,并重写它的run()方法便可实现多线程。

答案:对在JAVA中一个类只要继承了java.lang.Thread类,那么这个类中的任何方法都会在该线程的start()方法被调用后被JVM自动运行。

答案:错wait()、notify()和notifyAll()这三个方法的调用者都应该是同步锁对象。

答案:对一个进程只能包含一个线程。

答案:错Java多线程中,如果某个资源在一段时间内只能由一个进程占有,不能同时被两个或两个以上的进程占有。必须在占有该资源的进程主动释放它之后,其它进程才能占有该资源,这样就一定会出现死锁。

答案:错同步代码块的格式是synchronized(对象){}。

答案:对被synchronized关键字修饰的方法称为同步方法。

答案:对对Java程序来说,只要还有一个前台线程在运行,这个进程就不会结束。()

答案:对死锁就是两个线程在运行时都在等待对方的锁。

答案:对同一个类中所有的同步的静态方法,它们在类范围内是同步的,也就是同一时间只能有一个线程可以访问所有同步静态方法中的一个。

答案:对Lock锁在使用时也更加灵活。

答案:对处于等待的线程,必须被其他线程唤醒后才能继续运行。

答案:对在调用sleep()方法时,应该捕获或者声明抛出InterruptedException异常。

答案:对实现Runnable或Callable接口相比继承Thread类方式创建线程,优点在于它解决了单继承带来的局限性。

答案:对Thread类的join()方法能够将两个交替执行的线程合并为顺序执行的线程。

答案:对线程的优先级数值越大,表示该线程的优先级越低。

答案:错Future接口中常用方法有()

答案:booleancancel(boolean

mayInterruptIfRunning);booleanisCancelled();booleanisDone();Vget()下列有关sleep()方法的描述正确的是(

)

答案:属于Thread类的静态方法;让线程在指定的时间休眠;方法参数中必传入毫秒值下列关于同步方法的描述中,正确的是(

)

答案:同步方法在某一时刻只允许一个线程访问;同步方法也有锁,它的锁就是当前调用该方法的对象;同步方法也可以是静态方法下列关于线程的优先级的说法中,正确的是(

)

答案:线程的优先级仍然无法保障线程的执行次序,只不过,优先级高的线程获取CPU资源的概率较大,优先级低的并非没机会执行;可以通过Thread类的setPriority(intnewPriority)方法更改优先级;优先级不能超出1-10的取值范围,否则抛出IllegalArgumentException在Java中,下面哪些方式可以实现多线程程序(

)

答案:继承Thread类;实现Runnable接口Java在Object类中提供了哪些方法用于解决线程间的通信问题()

答案:wait();wait(longtimeout);notify();notifyAll()下面关于使用同步代码块描述正确的是(

)

答案:同步代码块中的锁对象可以是任意类型的对象;当多个线程共享的锁对象必须是唯一的;锁对象的创建代码不能放到run()方法中;当线程执行同步代码块时,首先会检查锁对象的标志位下列关于Thread类的说法中,错误的是(

)

答案:Thread类是一个接口,创建线程类,需要实现其run()方法;Thread类是一个抽象类,创建线程类,需要重写其run()方法同步代码块的作用是(

)

答案:保证多线程访问数据的安全;保证同步代码块中只有一个线程运行下列选项中,属于可以实现多线程程序方式的是(

)

答案:继承Thread类;实现Runnable接口下面关于线程创建的说法中,错误的有(

)

答案:定义Thread类的子类,重写Thread类的run()方法,创建该子类的实例对象,调用对象的run()方法;定义一个实现Runnable接口的类并实现run()方法,创建该类实例对象,将其作为参数传递给Thread类的构造方法来创建Thread对象,调用Thread对象的start()方法下列关于线程优先级的描述中,正确的是(

)

答案:线程的优先级需要操作系统支持,不同的操作系统对优先级的支持是不一样。;在程序中可以对线程的优先级进行重新设置。publicclassExample{

publicstaticvoidmain(String[]args){

SaleThreadsaleThread=newSaleThread();//创建Ticket1对象

//创建并开启四个线程

newThread(saleThread,"窗口1").start();

newThread(saleThread,"窗口2").start();

newThread(saleThread,"窗口3").start();

newThread(saleThread,"窗口4").start();

}}//定义Ticket1类实现Runnable接口classSaleThreadimplementsRunnable{

privateinttickets=10;//10张票

publicvoidrun(){

while(tickets>0){

try{

Thread.sleep(5);//经过此处的线程休眠10毫秒

}catch(InterruptedExceptione){

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"---卖出的票"+tickets--);

}

}}运行以上程序,可能的运行结果是(

)

答案:某个窗口卖出了负数张票;同一张票被卖出两次阅读下面程序publicclassExample{

publicstaticvoidmain(String[]args){

TicketWindowtw=newTicketWindow();

newThread(tw,"窗口1").start();

newThread(tw,"窗口2").start();

}}classTicketWindowimplementsRunnable{

privateinttickets=50;

publicvoidrun(){

while(true){

if(tickets>0){

Threadth=Thread.currentThread();

Stringth_name=th.getName();

System.out.println(th_name+"正在发售第"+tickets--+"张票");

}

}

}}下列选项中,可能是程序运行结果的是(

)

答案:窗口1和窗口2共卖了50张票;窗口1和窗口2各卖了25张票;窗口1卖了50张票,窗口2卖了0张票Executors创建线程池的方法说明,正确的是()

答案:newCachedThreadPool()创建一个可扩展线程池的执行器。;newFixedThreadPool(intnThreads)创建一个固定线程数量线程池的执行器;newSingleThreadExecutor()在特殊需求下创建一个只执行一个任务的单个线程;newScheduledThreadPool(intcorePoolSize)创建一个定长线程池,支持定时及周期性任务执行下列选项中,会导致线程进入死亡状态的是(

)

答案:线程的run()方法正常执行完毕;线程抛出一个未捕获的异常;线程执行过程中出现错误Thread类中,可以使线程休眠的方法是(

)

答案:sleep();wait()下列关于同步代码块的特征说法错误的是(

)

答案:多线程同步的锁只能是object对象下列关于进程和线程的说法中,错误的是(

)

答案:、线程和进程一样,是由CPU同时执行的下列关于Java后台线程的描述,错误的是()

答案:在start()方法执行后,使用setDaemon(true)可以将线程设置为后台线程以下写法中可以正确定义一个同步代码块的是(

)

答案:synchronized(对象){}关于线程的死锁,下面的说法正确的是(

)

答案:线程的死锁是一种逻辑运行错误,编译器无法检测下列方法中,可以实现线程让步的是(

)

答案:yield()下列关于Thread类中sleep()方法的描述,错误的是(

答案:、sleep()方法指定时间结束后,线程进入了运行状态下列关于线程优先级的描述,错误的是(

)

答案:新建线程的优先级默认为最低Java多线程中,关于解决死锁的方法说法错误的是(

)

答案:使用打破循环等待条件(避免第一个线程等待其它线程,后者又在等待第一个线程)的方法不能避免线程死锁下列关于Thread类的说法中,错误的是()

答案:Thread类属于java.util包下列关于多线程中的静态同步方法说法中,正确的是()

答案:静态同步方法的锁不是this,而是该方法所在类的class对象CompletableFuture对象创建的方法说明,错误的是()

答案:supplyAsync(Suppliersupplier)并使用指定作为它的线程池执行异步代码获取CompletableFuture计算结果非空的对象wait()方法作用是()

答案:导致线程等待下面关于静态同步方法说法错误的是(

)

答案:一个类中的多个同步静态方法可以同时被多个线程执行。notify()方法作用是()

答案:唤醒线程关于Thread类yield()方法的作用,下列描述中正确的是(

)

答案:使线程由运行状态进入就绪状态下面关于yield方法描述正确的是(

答案:yield方法是用于线程让步下列情况中,不会使线程返回所持有的对象锁的是(

)

答案:当调用了线程的suspend()方法下列属于定义同步代码块的关键字的是(

)

答案:synchronized下列有关线程的创建方式说法错误的是()

答案:通过继承Thread类与实现Runnable接口创建多线程这两种方式没有区别线程的优先级用1-10之间的整数表示,默认的优先级是()

答案:5下列关于线程状态转换的描述中,错误的是(

)

答案:死亡状态下的线程调用start()方法可以使其重新进入就绪状态JAVA中调用Thread类的sleep()方法后,当前线程状态如何转换()

答案:由运行状态进入等待状态以下关于Runnable接口的描述错误的是()

答案:通过Runnable接口中的start()方法可以开启线程以下哪个方法可以实现线程让步(

)

答案:yield()下列有关Java多线程中静态同步方法的说法错误的是(

)

答案:静态同步方法不可以和以this为同步监视器的同步代码块同时执行分析程序，写出结果classInfo{

privateStringname="张三";

privatebooleanflag=false;

publicsynchronizedvoidset(Stringname){

if(!flag){

try{

super.wait();

}catch(InterruptedExceptione){

e.printStackTrace();

}

}

this.setName(name);

try{

Thread.sleep(300);

}catch(InterruptedExceptione){

e.printStackTrace();

}

flag=false;

super.notify();

}

publicsynchronizedvoidget(){

if(flag){

try{

super.wait();

}catch(InterruptedExceptione){

e.printStackTrace();

}

}

try{

Thread.sleep(300);

}catch(InterruptedExceptione){

e.printStackTrace();

}

System.out.println(this.getName()+"-->"

);

flag=true;

super.notify();

}

publicStringgetName(){

returnname;

}

publicvoidsetName(Stringname){

=name;

}

}

classProducerimplementsRunnable{

privateInfoinfo=null;

publicProducer(Infoinfo){

=info;

}

@Override

publicvoidrun(){

booleanflag=false;

for(inti=0;i<20;i++){

if(flag){

.set("张三");

flag=false;

}else{

.set("李四");

flag=true;

}

}

}

}

classConsumerimplementsRunnable{

privateInfoinfo=null;

publicConsumer(Infoinfo){

=info;

}

@Override

publicvoidrun(){

for(inti=0;i<20;i++){

try{

Thread.sleep(100);

}catch(InterruptedExceptione){

e.printStackTrace();

}

.get();

}

}

}

publicclassThreadDemo2{

publicstaticvoidmain(String[]args){

Infoi=newInfo();

Producerpro=newProducer(i);

Consumercon=newConsumer(i);

newThread(pro).start();

newThread(con).start();

}

}

答案:张三-->李四-->张三-->李四-->张三-->李四-->张三-->李四-->张三-->李四-->张三-->李四-->张三-->李四-->张三-->李四-->张三-->李四-->张三-->李四-->分析程序，写出结果classMyThread1extendsThread{

privateStringname;

publicMyThread1(Stringname){

=name;

}

@Override

publicvoidrun(){

for(inti=0;i<10;i++){

System.out.println(name+i);

}

}

}

classMyThread2implementsRunnable{

privateStringname;

publicMyThread2(Stringname){

=name;

}

@Override

publicvoidrun(){

for(inti=0;i<10;i++){

System.out.println(name+i);

}

}

}

classMyThread3implementsRunnable{

privateintticket=5;

@Override

publicvoidrun(){

if(ticket>0){

System.out.println("卖票：ticket="+ticket--);

}

}

}

classMyThread4implementsRunnable{

@Override

publicvoidrun(){

for(inti=0;i<3;i++){

System.out.println(Thread.currentThread().getName()+"运行,i="+i);

}

}

}

classMyThread5implementsRunnable{

privateStringname;

privateinttime;

publicMyThread5(Stringname,inttime){

=name;

this.time=time;

}

@Override

publicvoidrun(){

try{

Thread.sleep(this.time);

}catch(InterruptedExceptione){

e.printStackTrace();

}

System.out.println(+"线程,休眠"+this.time+"毫秒");

}

}

classMyThread6implementsRunnable{

privateintticket=110;

@Override

publicvoidrun(){

for(inti=0;i<200;i++){

synchronized(this){

if(ticket>0){

try{

Thread.sleep(100);

}catch(InterruptedExceptione){

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"卖票：ticket="+ticket--);

}

}

}

}

}

publicclassThreadDemo1{

publicstaticvoidmain(String[]args){

MyThread6mt=newMyThread6();

Threadt1=newThread(mt,"A");

Threadt2=newThread(mt,"B");

Threadt3=newThread(mt,"C");

Threadt4=newThread(mt,"D");

Threadt5=newThread(mt,"E");

t1.start();

t2.start();

t3.start();

t4.start();

t5.start();

}

}

答案:B卖票：ticket=110B卖票：ticket=109B卖票：ticket=108B卖票：ticket=107B卖票：ticket=106B卖票：ticket=105B卖票：ticket=104B卖票：ticket=103B卖票：ticket=102B卖票：ticket=101B卖票：ticket=100B卖票：ticket=99E卖票：ticket=98E卖票：ticket=97E卖票：ticket=96E卖票：ticket=95E卖票：ticket=94E卖票：ticket=93E卖票：ticket=92E卖票：ticket=91E卖票：ticket=90E卖票：ticket=89E卖票：ticket=88E卖票：ticket=87E卖票：ticket=86E卖票：ticket=85E卖票：ticket=84E卖票：ticket=83E卖票：ticket=82E卖票：ticket=81E卖票：ticket=80E卖票：ticket=79E卖票：ticket=78E卖票：ticket=77E卖票：ticket=76D卖票：ticket=75D卖票：ticket=74D卖票：ticket=73D卖票：ticket=72C卖票：ticket=71C卖票：ticket=70C卖票：ticket=69C卖票：ticket=68C卖票：ticket=67C卖票：ticket=66C卖票：ticket=65A卖票：ticket=64A卖票：ticket=63A卖票：ticket=62C卖票：ticket=61C卖票：ticket=60C卖票：ticket=59C卖票：ticket=58C卖票：ticket=57C卖票：ticket=56C卖票：ticket=55C卖票：ticket=54C卖票：ticket=53C卖票：ticket=52C卖票：ticket=51C卖票：ticket=50D卖票：ticket=49D卖票：ticket=48D卖票：ticket=47D卖票：ticket=46D卖票：ticket=45D卖票：ticket=44D卖票：ticket=43D卖票：ticket=42D卖票：ticket=41E卖票：ticket=40E卖票：ticket=39E卖票：ticket=38E卖票：ticket=37E卖票：ticket=36E卖票：ticket=35E卖票：ticket=34E卖票：ticket=33E卖票：ticket=32E卖票：ticket=31E卖票：ticket=30E卖票：ticket=29B卖票：ticket=28B卖票：ticket=27B卖票：ticket=26B卖票：ticket=25B卖票：ticket=24B卖票：ticket=23B卖票：ticket=22B卖票：ticket=21B卖票：ticket=20B卖票：ticket=19B卖票：ticket=18B卖票：ticket=17B卖票：ticket=16B卖票：ticket=15B卖票：ticket=14E卖票：ticket=13E卖票：ticket=12D卖票：ticket=11D卖票：ticket=10D卖票：ticket=9D卖票：ticket=8D卖票：ticket=7D卖票：ticket=6D卖票：ticket=5C卖票：ticket=4C卖票：ticket=3C卖票：ticket=2C卖票：ticket=1分析程序，写出结果packagecom.wj.demo;

/*

*1.Product类是一个产品类，用来表示生产产品

*2.里面的有set和get方法，set方法用来设置生产什么样的产品，get是得到产品*/

classProduct{

privateStringname="A";//产品的名字

privatebooleanflag=true;//标志，true代表可以生产，false代表可以取得产品

publicsynchronizedvoidgetName(){//得到产品的函数

if(flag){//如果标志为true，则代表只可以生产，不能进行取产品

try{

super.wait();//调用Object父类的方法，使得到该对象锁的线程等待，把该线程放到等待该对象锁的队列里面

//，并且释放cpu，和释放该对象的对象锁，使其他的线程可以得到该对象的锁

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

}

System.out.println(name);//打印产品的名字

try{

Thread.sleep(200);//该线程休眠200毫秒，释放cup，让其他的线程执行，但是不会释放对象锁

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

flag=true;//把标志置位true，表示已经取了产品了，可以进行生产了，已经不没有产品了，不能得到产品了

//调用了super.notifyAll()方法后，并不会马上执行，要等待synchronized代码块所有的程序执行完了以后才会

//释放对象锁，进行唤醒其他的线程

super.notifyAll();//调用父类Object的方法，释放对象锁，唤醒在等待该对象锁的所有线程

}

publicsynchronizedvoidsetName(Stringname){

if(!flag){//如果flag为false则表示，只可以取产品，不能进行生产产品

try{

super.wait();//进行等待，和上面的一样

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

}

try{

Thread.sleep(200);//解释如上

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

=name;//设置产品的名字

flag=false;//设置标志，表示可以取产品了，不能再进行生产了

super.notifyAll();//如上所示，唤醒其他的想得到该对象锁的所有线程

}

}

//Factory类是一个工厂，用来控制生产什么样的产品

classFactoryimplementsRunnable{

privateProductproduct;//共享的对象

publicFactory(Productproduct){//构造函数，对product进行初始化

super();

duct=product;

}

@Override

publicvoidrun(){//覆写的run方法，进行线程操作

//TODOAuto-generatedmethodstub

for(inti=1;i<31;i++){

if(i%3==1){//如果余数为1，则生产A产品

product.setName("A");//生产A产品

}elseif(i%3==2){//如果余数为2，则生产B产品

product.setName("B");//生产B产品

}else{//其他的生产C产品

product.setName("C");//生产C产品

}

}

}

}

//Customer是消费者类，用来使用工厂生产的产品

class

CustomerimplementsRunnable{

privateProductproduct;//贡献资源对象

publicCustomer(Productproduct){//构造函数，初始化product

super();

duct=product;

}

@Override

publicvoidrun(){

//TODOAuto-generatedmethodstub

for(inti=1;i<31;i++){

try{

Thread.sleep(500);//进行线程休眠，使打印有时间延迟

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

System.out.print(""+i+"----->");

duct.getName();//消费产品

}

}

}

publicclassThreadDemo4{

/**

*@paramargs

*/

publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

Productp=newProduct();//创建共享资源对象

Factoryfp=newFactory(p);//创建工厂

Customercp=newCustomer(p);//创建消费者

Threadtfp=newThread(fp);//创建工厂线程进行生产

Threadtcp=newThread(cp);//创建消费者线程进行消费

tfp.start();//启动线程

tcp.start();//启动线程

}

}

答案:1----->A2----->B3----->C4----->A5----->B6----->C7----->A8----->B9----->C10----->A11----->B12----->C13----->A14----->B15----->C16----->A17----->B18----->C19----->A20----->B21----->C22----->A23----->B24----->C25----->A26----->B27----->C28----->A29----->B30----->C简述程序、进程和线程之间的关系？什么是多线程程序？

答案:答：程序是一段静态的代码，它是应用软件执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行到执行完毕的一个完整过程。这个过程也是进程本身从产