《Java试题》

《Java试题》

 

一、选择题（20分）

说明：将正确答案填写在题目前的[ ]内，每小题2分。

[  B] 1．可以将（）范围的数值赋给short型变量：

A．0～2^16－1     B．－2^15～2^15－1     C. 0～2^32－1     D. －2^31～2^31－1

[ A ]2．根据给出的下面代码，那个选项是正确的？

public class test{

static int a[] = new a[10];

public static void main(String args[]) {

System.out.println(arr[0]);

}

}

A．编译时将产生错误。 B．编译时正确，运行时将产生错误。

C．程序输出零。 　　　D．程序输出null。

 [ B ] 3. 对于下列代码, 下述哪些方法可以加入类Child?

public class Parent {

　 public int addValue( int a, int b) {

　　 int s; s = a+b; return s;

}

}

class Child extends Parent { }

A. int addValue( int a, int b ){...}

B. public void addValue (int a, int b ){/...}

C. public int addValue( int c ,int d){...}

D. public int addValue( int a, int b )throws MyException {...}

[  C]4. 在Java应用程序的主类体中，（）主方法函数头是非法的？

A. public static void main(String[] args)

B. public static void main(String args[])

C. final public static void main(String [] arg)

D. public void main(String[] args)

[  A] 5. 现有如下程序片断：

String handle ＝ “Prof.”;

String name = “First”+“Last”；

String title ＝ handle＋name；

System.out.println(title);

则最后一条语句的输出是：

A. Prof.FirstLast     B. First

C. Last             D. Prof

[ D ]6. 下面哪种注释方法能够支持javadoc命令:

A. /**...**/     B. /*...*/     C. //     D. /**...*/

[ C ] 7. switch语句的整型表达式若是（）则编译出错：

A．int 　　　　B．byte

C．boolean 　　D．short

[ B ] 8. 以下哪个约束符只能用于定义成员常量？

A、final  static

B、final

C、abstract

D、以上约束符都不能用

[  B] 9.现有程序片段如下：

Float pi = new Float(3.14f);

if(pi > 3){

System.out.print("pi is bigger than 3. ");

}

else{

System.out.print("pi is not bigger than 3. ");

}

finally{

System.out.print("Have a nice day.");

}

 

 

请问运行的结果是?

 

A. 编译失败

 

B.pi is bigger than 3.

 

C.在运行时出现异常

 

D.pi is bigger than 3.Have a nice day.

 

E.pi is not bigger than 3.Have a nice day.

 [ D ] 10.下列关于Java类的构造方法的说法中错误的是：

A. 构造方法的名字必须与类的名字完全相同。

B. 构造方法一般不能由程序员在程序中主动调用。

C. 父类的构造方法不能被子类继承。

D. 构造方法必须用public访问控制符修饰。

二、判断题（16分）

说明：判断正误，如果有错，写出错误原因并改正错误，每小题4分。

1．使用方法length（）可以获得字符串或数组的长度。

         错误  使用方法length（）只可以获得数组的长度。

2．子类要调用父类的方法，必须使用super关键字。

错误  只有当子类要调用父类的构造方法时才需要使用super关键字。

3．面向对象的特征是封装、继承、多态、抽象、组合。

   正确

4.      String是基本数据类型之一.

  错误  String 是引用数据类型之一

三、程序阅读和简答题（24分）每小题6分。

1．程序如下：阅读程序写出类MyClass3的所有成员，并写明它们定义自哪里。

class MyClass1

{

private int prol1;

double prol2;

}

class MyClass2 extends MyClass1

{

private double prol2;

int pro21;

}

class MyClass3 extends MyClass2

{

private int pro21;

double pro31;

}

答:

double prol2;   来自MyClass1

int pro21;   来自MyClass2

private int pro21;来自 MyClass3

double pro31;  来自 MyClass3

2．阅读下面的程序片段并回答问题。

class Class1

{

int field1;

int field2;

void method1()

{

System.out.println(“我是Class1的第一个方法”);

}

void method2()

{

System.out.println(“我是Class1的第二个方法”);

}

}

class Class2 extends Class1

{

int fieldChild1;

void methodChild1()

{

System.out.println(“我是Class2的第一个方法”);

}

}

回答如下问题

（1）Class1被称为是Class2的什么？Class2被称为是Class1的什么？

    父类 (基类)

    子类 (超类)

 

（2）Class1有哪些方法和属性？Class2有哪些方法和属性？其中哪些与Class1的方法和属性有关，是什么关系？

  Class1中的属性: field1,field2   方法: method1() method2()

    Class2中的属性: field1,field2 , fieldChild1

               方法: method1() method2(),methodChild1()

         属性: field1,field2   方法: method1() method2()与Class1有关，是继承关系

3.请描述overload和override的相同点和不同点？

   相同点：

      1)都要求方法名相同

      2)都可用于抽象方法与非抽象方法，静态方法与非静态方法

不同点:

    1)方法重写要求参数签名完全一致，而方法重载则要求参数签名至少有一项不同

    2)方法重写存在与子类与父类之间，而方法重载存在于一个类中。

   3)方法重写要求子类不能抛出比父类更多的异常，方法重载没有此限制

4)      父类的非静态方法不能被子类重写为静态方法(静态方法不能被子类重写为非静态方法),而方法重载则没有次限制

5)      方法重写对访问控制有严格限制，方法重载没有此限制访问控制类型可以不同

 

 

 

 

 

4.请描述java中的数据类型,并列出相关类型的包装类？

   基本数据类型  相应的包装类    

    byte      Byte

   short     Short

  char     Character

   float     Float

   double  Double

  boolean  Boolean

  int       Integer

  long   Long

 

引用数据类型

  类   数组   接口

 

 

 

 

 

四、程序设计题（40分）

说明：按照题目要求编写下面程序。

1．定义一个时钟类（Clock）(10分)

要求如下：

1）存储时钟的时（0-23）、分（0-59）、秒（0-59）；

2）创建新对象时默认为0时0分0秒；

3）设置时钟为指定的时间；

4）使时钟前进1秒钟的功能；

5）以“时：分：秒”的形式输出时钟的时间。

  Class Clock

{

    public int hour;

   public  int  minute;

   public int  second;

   public  Clock(int hour, int  minute,int  second)

     {

             this. hour=hour;

             this.minute =minute;

            this.second=second;

     }

   public  void  setsecond()

    {

         second=second+1;

         if(second==60)

          {

             second =0;

              minute=minute+1;

          }

        if(minute=60)

       {

             minute=0;

             hour=hour+1;

       }

      if(hour=24)

       {

          hour=0;

        }

     }

public String toString()

{

 

    return  hour+”：”+minute+“:” +second;

}

 

}

 

Public class  ClockTest

{
   public static void  main(String args[])

     {

       Clock c=new Clock(0,0,0,0);

       System.out.println(c);

         c.setsecond();

         System.out.println(c);

 

      }

 

 

}

 

 

 

 

2．编写一个单例类(10)

  public class SingleTon

{

 

     private  SingleTon  instance;

    private SingleTon()

    {

    }

   

   public static  SingleTon getInstance()

   {

     if(instance==null)

     {

     instance   =new SingleTon();

     }

   else

     {

       return   instance

     }

 

   public static void  main(String args[])

     {

       SingleTon   s1= SingleTon.getInstance();

      SingleTon   s2= SingleTon.getInstance();

       System.out.println(s1==s2);  

      

      }

 

   

    }

 

 

 

 

 

}

 

 

 

 

 

 

 

 

 

3.编写一个多态的程序(10)

  如果编译时的状态与运行时状态不一致就产生多态

  class Animal

{

 

   public  String name;

 

   public void sing()

   {
     System.out.println(“所有动物都会叫”);  

   }

 

}

    class Cat extends Animal

{

        public  String   catcolor;

        public void sing()

       {
         System.out.println(“猫在叫”);  

         }

 

}

 

public class Test

{

      public static void  main(String args[])

    {

      Animal a=new Cat ();

      a.sing();

    }

}

 

 

 

 

 

 

4.编写一个封装类(10)

      将过程与属性封装起来，对属性的访问只能通过方法来访问

public class  Student

{
  private String  id ;

  private  String name;

    public String getId()

{

   return  id;

}

    public String  getName()

{

   return  name;

}

 

public void setId(String  id)

{

   this.id=id;
}

public void setName(String  name)

{

   this.name=name;
}

    public static void  main(String args[])

    {
          Student  s =new Student ();

           s. setId(“001”)；

            s. setName(“itany”)；

          System.out.println(“学号:”s. getId()+ “姓名:”s. getName());  

 

 

   }

 

 

}