西北工业大学java课程考试试卷
说明：1.所有题目做在答卷纸上
      2.考试完毕后连考卷一起交上
一、选择（共25题，每题1分，共25分）
1. 以下标识符中哪项是不合法的(  d  )。
A. price_per_m
B. Salary
C. myVar
D. class
2. 设原来变量a和n的值分别为7和2，则表达式a+=n-2的结果是（  d ）。
A. 1
B. 2
C. 9
D. 7
3. Java语言使用的字符集是(  c  )。
A. ASCII
B. Latin-1
C. Unicode   
D. ISO-Latin
4. 设x = 2, 则表达式( x++)/3的值是(  b  )。
A. 2
B. 0
C. 1
D. 3
5．下面的语句（    d ）是正确的。
A. char c = ‘abc’;
B.char cr = ‘12’;
C. float f = 0.23;
D.int i = 2;
6．一个Java字节码文件必须以（  b p9  ）为其扩展名。
A. java
B. class
C. html
D. exe
7．switch后面的表达式的类型不可以是（  c  p37 ）。
A. byte
B. char
C. long
D. short
8．不允许作为类成员的访问控制符的是（  d  ）。
A. public
B. private
C. protected
D. static
9．执行代码String s; 后，正确的结论是以下的选项（  b  ）。
A. s为””（空串）
B. s为null
C. s为”s”
D. s为0
10．为AB类的一个无形式参数、无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，那么该方法的定义形式为（  c  ）。
A. final  void  method ( )
B. public  void  method ( )
C. static  void  method ( )
D. abstract  void  method ( )
11．在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种特性称为（  c    ）。
A．Java不支持此特性
计算机专业java
B. 方法的改写
C. 方法的名复用
D. 方法的隐藏
12. 在方法的改写（override）中，如果超类中的方法被说明为protected，子类中可以重新说明为： （  a   ）。
A. public或protected
B. private或protected
C. public或private
D. ABC均正确
13．若在某个类中定义了方法：
abstract  void  method( );
那么该方法属于（  d  ）。
A．最终方法
B. 本地方法
C. 同步方法
D. 抽象方法
14．在某个类中仅说明了一个含有形参的构造器，其子类构造器的设计应该：(  c  )。
A. 子类无需设计构造器，而用缺省构造器。
B. 子类必须设计不含形参的构造器。
C. 子类的构造器中第一条语句应以super（实参）调用超类构造器。
D. 子类的构造器中可用缺省方式调用超类构造器。
15．下面关于类及其修饰符的一些描述，正确的是（  d  ）。
A. abstract类可以用来派生子类，也可以用来创建abstract类的对象。
B. final类不但可以用来派生子类，也可以用来创建final类的对象。
C. abstract能与final同时修饰一个类。
D. abstract方法必须在abstract类中声明，但abstract类定义中可以没有abstract方法。
16．类Test1定义如下：
1．public  class  Test1{
2．        public  float  aMethod（float  a，float  b）{  }
3．       
4．}   
将以下（ b  ）方法插入标号为3的行是不合法的。
A. public  float  aMethod（float  a， float  b，float  c）{  }
B. public  float  aMethod（float  c，float d）{  }
C. public  int  aMethod（int  a， int b）{  }
D. private  float  aMethod（int a，int b，int c）{  }
17．在Java语言中，说法(  c )是正确的。
A．一个子类可以有多个父类，一个父类也可以有多个子类
B．一个子类可以有多个父类，但一个父类只可以有一个子类
C．一个子类只可以有一个父类，但一个父类可以有多个子类
D．上述说法都不对
18. 下面说法正确的是(  b  )。
A. 每个try代码块都必须至少有一个catch块和它对应，如果一个try块有多个catch块与之对应，应该将参数为父类异常对象的catch块排在前面。
B. 如果程序运行到try块中时，某个语句产生了异常，则程序流程将跳过try块后面的语句，直接进入catch块中。
C. 如果catch块后还有一个finally块，程序在运行时，一旦进入catch块后，就不会再进入finally块，只有不产生异常时才跳过catch块进入finally块中运行。
D. catch语句可以是多个。catch语句中的异常类型不必是Throwable类的子类。
19.在使用interface声明一个接口时，只可以使用（    d  ）修饰符修饰该接口。
A. protected
B. private  protected
C. private
D. public
20.创建一个新的线程对象后，通过使用（  a    ）方法就可以启动该线程。
A. start( )
B. set( )
C. main( )
D. run( )
21．设有下面的一段代码：
public class Person{
  static int arr[ ] = new int[10];
  public static void main(String a[ ])
  {
  　System.out.println(arr[1]);
  }
}
对类Person进行编译、解释运行的结果是：（  c  ）。
A. 编译时报错
B. 编译时正确，运行时报错
C. 程序通过编译，解释运行结果为输出0
D. 程序通过编译，解释运行结果为没有任何输出
22.下面程序代码的运行结果是（  b  ）。
class Exercise_1
{
    public static void main(String[] args)
    {
        for(int i = 0; i < 3; i++)
        {
          if(i < 2)
              break;
          System.out.println(i + "\t");
        }
        System.out.println("i = " + i);
    }
}
A.  i = 0
B. 编译出错
C. 无限循环
D. 2
23.下面程序代码的运行结果是（  c  ）。
class StringET{
    public static void main(String[] args)
    {
        String  s1="abc"+"def";
        String  s2=new  String(s1);
        if(s1==s2)          //boolean
            System.out.println("== succeeded");
        if(s1.equals(s2))
            System.out.println(".equals()  succeeded");
    }
}
A. 没有任何输出
B. 输出 == succeeded
C. 输出 .equals()  succeeded
D. 输出
== succeeded
.equals()  succeeded
24. 对于接口，下列叙述错误的是（d ）：
A. 接口是一种完全没有实现的类
B. 在接口中只包含常量和方法的定义，没有方法的实现
C. Java提供一种特别类型----“接口”（interface）来实现多重继承
D. 一个类最多只能实现一个接口
25. 已知类ArrayList实现了List接口，欲创建ArrayList类的一个对象，下列哪个方法是正确的（  b  ）。
A. ArrayList  myList = new  Object();
B. List  mList = new  ArrayList ();
C. ArrayList  myList = new  List();
D. List  myList = new  List();
二、填空题（每空1分，共20分）
1. 接口是一种由____常量_____和__抽象方法_______组成的类型。
2. 在Java中创建有名常量是用___static___和____final_____来说明一个变量。
3. 若x = 5, y = 10，则 x < y 和 x >= y的逻辑值分别为____true_______和______false_____。
4. Java中有两种多态，一种是使用方法的____名复写___实现多态，另一种是使用方法的_____改写____实现多态。
5. 一个Java源程序文件名为MyJavaApp.java，如果使用Sun公司的Java开发工具JDK编译该源程序文件，并使用其虚拟机运算这个程序的字节码文件，应该顺序执行如下两个命令：________javac MyJavaApp.java___java MyJavaApp.class____________。
6. Java中类成员的访问控制符有以下几种：private, public, __protected_, _缺省___。 其中___public____是类成员的缺省访问控制符。
7. 如果在子类中说明了一个与超类相同名字的域，超类的那个域仍然存在，但不能用其名直接访问，这种特性称为域的_____隐藏______。
8. Java异常有两种：检测性异常和非检测性异常。所谓检测性异常就是编译器要检测以确保该方法只引发自己所说明的一种异常。标准的RuntimeException类和Error类属于上述两种异常中的__非检测性异常_异常。
9. 线程的创建方式有两种，一种是扩展___thread类___，一种是实现____throwable类___。
10. 如果有一个类MyFrame是Frame的子类，能够被不同包中的类所使用，同时又能够为线程提供运行代码（run()方法），请写出该类的声明头__ public class MyFrame extends Frame implements Throwable。
11. Java中的__string_类用于处理字符串常量，而__stringBuffer_____类用于处理字符串变量。
三、概念解释 （共4题，每题3分，共12分）
1. 方法的改写(1)方法的改写：子类中用相同的基调替代超类中某方法的实现。
2. 异常(2)异常：提供了一种能检测错误且不会使程序代码变得凌乱的清晰方式。
3. 抽象类(3)抽象类：是其中仅定义了部分实现的类，而留待扩展类去提供这些方法的部分或全部的具体实现。抽象类不能直接实例化对象，抽象类需用abstract关键字修饰。
4. 类和接口之间的关系(4) 类和接口之间的关系：一个类可以实现多个接口，对接口中每个方法都给出具体实现；一个接口可以被多个类所实现；一个接口说明了一种类型，可用接口类型来说明引用变量的类型。该类型的引用变量可指向实现该接口的任一类的对象。所以可通过接口来调用不同类的相同方法。
四、写出下列程序完成的功能（共2题，每题4分，共8分）
1. public  class  Sum
{  public  static  void  main( String  args[ ])
  {  double  sum = 0.0 ;
      for  ( int  i = 1 ;  i <= 100 ; i + + )
          sum += 1.0/(double) i ;
      System.out.println( "sum="+sum );  }
}  //1/1+1/2+1/3…..+1/100
2. class CMax
{
    int [ ][ ] a={{3,4,6,7,8},{8,7,9,5,2},{21,54,26,89,45},{34,87,54,67,23}};
    int row = 0, col = 0, value = a[0][0];
    void find()
    {
        for(int i = 0; i < a.length; i++)
            for(int j = 0; j < a[0].length; j++)
                if(a[i][j] > value)
                {
value = a[i][j];
                    row = i;
                    col = j;
                }
        System.out.println("value=" + value + " row = " + row + " colum = " + col);
    }
    public static void main(String[] args)
    {
        CMax cm = new CMax();
        cm.find();
    }
}      //数组最大值
五、写出下面程序的运行结果（共2题，每题5分，共10分）
1．public class Test extends TT
{
    public static void main(String args[])
    {
        Test t = new Test("Tom");
    }
    public Test(String s)
    {
        super(s);
            System.out.println("How do you do?");
    }
    public Test()
    {
        this("I am Tom");
    }
}
class TT
{
    public TT()
    {
        System.out.println("What a pleasure!");
    }
    public TT(String s)
    {   
        this();
        System.out.println("I am "+s);
    }
}
2. interface MyInterface
{
void Fun();
}
class MyClass1 implements MyInterface
{
public void Fun()
{
System.out.println("调用MyClass1中的方法Fun!");
}
}
class MyClass2 implements MyInterface
{
public void Fun()
{
System.out.println("调用MyClass2中的方法Fun!");
}
}
public class MyClass3
{
public void CallFunOfClass(MyInterface If)
{
If.Fun();
}
public static void main(String[] args)
{
MyInterface f;
MyClass1 Obj1=new MyClass1();
MyClass2 Obj2=new MyClass2();
f=Obj1;
f.Fun();
f=Obj2;
f.Fun();
MyClass3 Obj3=new MyClass3 ();
Obj3.CallFunOfClass(Obj1);
Obj3.CallFunOfClass(Obj2);
}
}
六、改错（5分）
下面程序中编译错误的原因是______ _ _ _                _。
abstract class MineBase
{
        abstract void amethod();
static int i;
}
public class Mine extends MineBase
{
    public static void main(String argy[ ])
    {
        int[ ] ar = new int[5];
            for(i = 0;i < ar.length;i++)
                System.out.println(ar[i]);
    }
}
七、综合设计(写在答题纸上并注明题号)（20分）
为某船运公司设计一个集装箱运输管理软件，依次完成下面设计：
1． 每个集装箱有唯一的注册号regNumber、重量weight(吨)、货物描述description。编写一个Container类，包含一组私有域、一组访问方法、一个有参量构造器、一个toString()方法将属性描述为字符串。
2． 危险品箱是一种特殊的集装箱，每个危险品箱须确定一个危险级别(hazadousLevel，可以是1、2、3等)。编写一个DangerousContainer类，包含私有域、访问方法、一个有参量构造器、一个toString()方法将属性描述为字符串。
3． 每条船有一个船名name，最大载重量maxLadenWeight(吨)，可加载若干集装箱，集装箱的总重量不能超过该船的最大载重量。编写一个Ship类，包含一组私有域、一组访问方法、一个有参量构造器、一个toString()方法将该船的属性和所加载的集装箱信息描述为字符串。另外设计：
①方法boolean load(Container cnt)：加载一个集装箱cnt到船上，若返回true，则表示未超重且成功加载；若返回false，则表示因超重而加载失败。
②方法boolean unload(String regNumber)：按注册号regNumber卸载一个集装箱。若到该集装箱且卸载，则返回true；若未能到该集装箱而卸载失败，则返回false。
可根据设计需要增加方法。
参考类库如下：
java.util.ArrayList表示一个数组列表对象。
构造器:public ArrayList()构建一个空的数组列表对象。
方法:public boolean add(Object o)把指定对象o加入列表尾部。
方法:public Object get(int index) 返回数组列表中index位置上的对象。
方法:public Object remove(int index) 撤销数组列表中index位置上的对象并返回。
方法:public int size()返回数组列表中已加入的元素个数。
java6答  案
一、选择（共25题，每题1分，共25分）
1 ～10  D D C B D      B C D B C     
11～20  C A D C D     B C B D A
21～25  C B C D B
二、填空题（每空1分，共20分）
1. 常量    抽象方法
2. static  final
3. true    false
4. 名复用    改写
5. javac MyJavaApp.java        java MyJavaApp
6. protected    package    package
7. 隐藏
8. 非检测性异常
9. Thread类      Throwable接口
10. public class MyFrame extends Frame implements Throwable
11. String    StringBuffer
三、名词解释 （共4题，每题3分，共12分）
(1)方法的改写：子类中用相同的基调替代超类中某方法的实现。
(2)异常：提供了一种能检测错误且不会使程序代码变得凌乱的清晰方式。
(3)抽象类：是其中仅定义了部分实现的类，而留待扩展类去提供这些方法的部分或全部的具体实现。抽象类不能直接实例化对象，抽象类需用abstract关键字修饰。
(4) 类和接口之间的关系：一个类可以实现多个接口，对接口中每个方法都给出具体实现；一个接口可以被多个类所实现；一个接口说明了一种类型，可用接口类型来说明引用变量的类型。该类型的引用变量可指向实现该接口的任一类的对象。所以可通过接口来调用不同类的相同方法。
四、写出下列程序完成的功能（共2题，每题4分，共8分）
(1) 实现求解1.0/1.0+1.0/2.0+1.0/3.0+...+1.0/100.0，并输出结果。
(2) 求解给定4×5矩阵中所有元素的最大值，并输出该最大值以及其所在的行号和列号。
五、写出下面程序的运行结果（共2题，每题5分，共10分）
(1) What a pleasure!
I am Tom
How do you do?
(2) 调用MyClass1中的方法Fun!
调用MyClass2中的方法Fun!
调用MyClass1中的方法Fun!
调用MyClass2中的方法Fun!
六、改错（5分）
类Mine应该被声明为abstract类，因为它没有实现抽象方法amethod( )。
七、综合设计(写在答题纸上并注明题号)（20分）
public class Container                    //（6分）
{
    private String regNumber;
    private int weight;
    public String description;
    public Container(String regNumber,int weight,String description){
        Number=regNumber;
        this.weight=weight;
        this.description = description;
    }
    public String getRegNumber(){
        return regNumber;
    }
    public int getWeight(){
        return weight;
    }
    public String toString(){
        return "RegNumber:"+regNumber+" Weight:"+weight + " Desc:"+description;
    }
}
class DangerousContainer extends Container{          //（6分）
    private int hazadousLevel;
    public DangerousContainer(String regNumber,int weight,String description,int hazadousLevel){
        super(regNumber,weight,description);
        this.hazadousLevel=hazadousLevel;
    }   
public int getHazadousLevel(){
        return hazadousLevel;
    }
    public String toString(){
        String()+"\r\nHazadous Level:"+hazadousLevel;
    }
}
import java.util.*;        //（8分）
class Ship{
    private String name;
    private int maxLadenWeight;
    private ArrayList containers;
   
    public Ship(String name,int maxLadenWeight){
        this.name=name;
        this.maxLadenWeight=maxLadenWeight;
        containers=new ArrayList();
    }
    public int getMaxLadenWeight(){
        return maxLadenWeight;
    }
    public int getTotalWeight(){
        int n=0;
        for(int i=0;i<containers.size();i++){
            Container con=((i);
            n+=Weight();
        }
        return n;
    }
    public boolean load(Container cnt){
        Weight()+TotalWeight()<=maxLadenWeight){
            containers.add(cnt);       
            return true;
        }else return false;
    }
    public boolean unload(String regNumber)
{
for (int i=0;i<containers.size();i++){
            Container con=((i);
            if (RegNumber().equals(regNumber)){
                ve(i);
                return true;
            }
        }
        return false;
    }
    public String toString(){
        return "Name:"+name+" Maximum LadenWeight:" +maxLadenWeight+" Total Laden Weight="+getTotalWeight();
    }
    public void print(){
        for (int i=0;i<containers.size();i++){
            Container con=((i);
            System.out.println(con);
        }
    }

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。