Java面向对象选择题2

1.(多选)查看如下代码：

public class Foo { 
    public void method(String str,int age){} 
}  

下列选项中，和 Foo 类中 method 方法重载的方法是（）。

A.public int method(String str,int age){}
B.public void method(int year,String s){}
C.public int method(int year,String s){}
D.public int method(String str){}

答案：BCD
难度等级：简单
解析：
重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

2.(多选)查看如下代码：

class A {
    protected int method (int a, int b) { 
        return 0; 
    } 
｝  

下列选项中，可以在 A 的子类中使用的是（）。

public int method (int a, int b) { return 0; }
.private int method(int a, int b) { return 0; }
.private int method(int a, long b) { return 0; }
.public short method(int a, int b) { return 0; }

答案：AC
难度等级：简单
解析：
重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

3.选)请看下列代码：

class One { 
    public One foo() { 
        return this; 
    } 
} 
class Two extends One { 
    public One foo() { 
        return this; 
    } 
} 
class Three extends Two { <插入代码> } 

下列选项中的代码，放置在<插入代码>处无编译错误的是：

.public void foo() { }
.public Object foo() { return this; }
.public Two foo() { return this; }
.public One foo() { return this; }

答案：CD
难度等级：简单
解析：
在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

3.下面说法正确的是 （）

A 一个类只能有一个构造器
B 一个类可以有多个构造器
C 一个类的构造器可以省略

答案：BC
难度等级：简单
解析：
使用构造器时需要记住：
1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）
2.每个类可以有一个以上的构造器
3.构造器可以有0个、1个或1个以上的参数
4.构造器没有返回值
5.构造器总是伴随着new操作一起调用

4.下面程序运行的结果是 （）

Public class A {
    Int a = 0 
    Int c = 0
    Do{
         --c
    }while(a>0){
            Shystem.out.println(c)
      }
}

A 0
B -1
C 编译错误
D 无法计算

答案：C
难度等级：简单
解析：
逻辑代码必须放在方法中，而不能放在类中

5.试图编译和运行以下代码的时候，将会发生什么结果(JAVA)

public class MyTest{
    int i = 100;
    public static void main(String argv[]){
        MyTest m = new MyTest();
        m.test();
    }
    void test(){
        int i;
        System.out.println(i);
    }
}

A 运行时将输出：100
B 运行时将输出：0
C 编译时错误(Compile time error)
D 运行时错误(Run time error)

答案：C
难度等级：简单
解析：
void test(){
int i;
System.out.println(i);
}
方法中定义的变量，在使用之前必须初始化

6.给定以下的代码，编译通过后，执行命令java ObParam，将输出什么结果(JAVA)

class ValHold{
    public int i = 10;
}
public class ObParm {
    public static void main(String argv[]){
        ObParm o = new ObParm();
        o.oneMethod();
    }

    public void oneMethod(){
        int i = 99;
        ValHold v = new ValHold();
        v.i = 30;
        twoMethod(v, i);
        System.out.print("\t"+v.i);
    }//End of oneMethod

    public void twoMethod(ValHold v, int i){
        i = 0;
        v.i = 20;
        ValHold vh = new ValHold();
        v =  vh;
        System.out.print(v.i+ "\t"+i);
    }//End of twoMethod
}

A 10 0 30
B 20 0 30
C 20 99 30
D 10 0 20

答案：D
难度等级：中
解析：
此题考查值传递和引用传递
public void twoMethod(ValHold v, int i){
i = 0;
v.i = 20;
ValHold vh = new ValHold();
v = vh;
System.out.print(v.i+ “\t”+i);
}//End of twoMethod
此方法中ValHold vh = new ValHold();这句话执行后vh是一个新的对象vh中的i是10
v=vh，那么v中的i也是10了

7.试图编译和运行以下代码，将获得什么结果(JAVA)

class Base {
    int i = 99;
    public void amethod() {
        System.out.println("Base.amethod()");
    }
    Base() {
        amethod();
    }
}
public class RType extends Base {
    int i = -1;
    public static void main(String argv[]){
        Base b = new RType();
        System.out.print(b.i+"\t");
        b.amethod();
        RType r = (RType)b;
        System.out.print(r.i+"\t");
    }
    public void amethod(){
        System.out.print("RType.amethod()"+"\t");
    }
}

A RType.amethod -1 RType.amethod -1
B RType.amethod 99 RType.amethod -1
C 99 RType.amethod 99
D 编译时错误(Compile time error)

答案：B
难度等级：中
解析：
面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
多态的作用：消除类型之间的耦合关系。

8、 下列说法正确的有（ ）

A、class中的constructor 不可省略
B、constructor必须与class同名，但方法不能与class同名
C、constructor在一个对象被new时执行
D、一个class只能定义一个constructor

答案：C
难度等级：简单
解析：
选项A 构造函数可以省略，但会自动给提供一个默认构造函数
选项B 构造函数必须跟类同名，但方法可以与类同名，只要添加上方法的返回值即可
选项D 一个类可以定义多个构造函数，他们的关系是重载的关系

9、下列哪一种描述是正确的（ ）

A、abstract 修饰符可修饰字段，方法和类
B、抽象方法的body 部分必须用一对大括号{}包住
C、声明抽象方法，大括号可有可无
D、声明抽象方法没有大括号

答案：D
难度等级：简单
解析：
选项A abstract只能修饰在类或方法上
选项B 抽象方法是不能有body体的
选项C 声明抽象方法是不能给大括号的

10、下列哪种说法是正确的（ ）

A、实例方法可直接调用超类的实例方法
B、实例方法可直接调用超类的类方法
C、实例方法可直接调用其他类的实例方法
D、实例方法可直接调用本类的类方法

答案：D
难度等级：简单
解析：
选项A 需要通过super.调用
选项B 需要通过super.调用
选项C 必须作为参数传递，才可以使用

11.不能用来修饰interface 的有（ ）

A、private
B、public
C、proterted
D、static

答案：ACD
难度等级：简单
解析：
接口是公有的

12、下列说法错误的有（ ）

A、在类方法中可用this来调用本类的类方法
B、在类方法中调用本类的类方法时可直接调用
C、在类方法中只能调用本类中的类方法
D、在类方法中绝对不能调用实例方法

答案：CD
难度等级：简单
解析：
选项C 在类方法中也可以调用其它类中的方法，前提是需要把其他类的对象作为函数的参数传递到当前方法中
选项D 是可以调用的，比如 this.method();

13.下面的程序输出的结果是（ ）

public class A implements B {
    public static void main(String args[]) {
        int i;
        A c1 = new A();
        i= c1.k;
        System.out.println("i="+i);
    }
}

interface B {
 int k = 10;
}

A i=0
B i=10
C 程序有编译错误
D i=true

答案：C
难度等级：简单
解析：
方法中的变量在使用前必须给初值C

14、MAX_LENGTH是int型public成员变量, 变量值保持为常量100，用简短语句定义这个变量。（ C ）

A public int MAX_LENGTH=100;
B final int MAX_LENGTH=100;
C public final int MAX_LENGTH=100;
D public static int MAX_LENGTH=100;

答案：C
难度等级：简单
解析：
final修饰的变量就是常量

15.给出下面代码：

class Parent { 
  2) private String name; 
  3) public Parent(){} 
  4) } 
  5) public class Child extends Parent { 
  6) private String department; 
  7) public Child() {} 
  8) public String getValue(){ return name; } 
  9) public static void main(String arg[]) { 
  10) Parent p = new Parent(); 
  11) } 
  12) } 

那些行将引起错误？ （ ）

A 第3行；
B 第5行；
C 第6行；
D 第8行

答案：D
难度等级：简单
解析：
父类中的name变量是私有的，子类中无法使用name变量

16.Integer n1=new Integer(47); Integer n2=new Integer(47); n1.equals(n2)的值为: （ ）

A false
B null
C true
D 0

答案：A
难度等级：简单
解析：
在堆空间中，每new一个对象都会开辟一个新的空间，而==运算符判断的是地址相等
因为是2个对象空间，所以不是一个地址，结果为false

17.看下面一段程序：

  public class Aclass{ 
       public void go(){ 
            System.out.print(" Aclass");
       } 
  } 
  public class Bclass extends Aclass{ 
       public void go(){ 
            System.out.print(" Bclass"); 
       } 
      public static void main(String args[]){ 
         Aclass a  = new Aclass(); 
         Aclass a1 = new Bclass(); 
         a.go(); 
         a1.go(); 
  }
    } 

以上程序运行结果是： （ ）

A Aclass Aclass
B Bclass　Bclass
C Aclass Bclass
D Bclass Aclass

答案：C
难度等级：简单
解析：
a.go(); //调用的是自己类中的方法
a1.go(); //调用的是子类中的方法

18.运行下列程序, 会产生什么结果 （ ）

public class X extends Thread implements Runnable{ 
 public void run(){ 
  System.out.println("this is run()"); 
 } 
 public static void main(String args[]) 
 { 
  Thread t=new Thread(new X()); 
  t.start(); 
 } 
} 

A 第一行会产生编译错误
B 第六行会产生编译错误
C 第六行会产生运行错误
D 程序会运行和启动

答案：*D 难度等级：D简单 解析：**
就是启动和运行了一个线程

19.下列哪些语句是正确的? ( )

A int a[][]=new int[][3];
B int a[][]={{1,3},{2,3,4},{1,2}};
C String s[][]=new String[2][];
D String s[][]={{“can”,”I”},{“help”,”you”}};

答案：BD
难度等级：
解析：
选项A 3前面的方括号中不能为空
选项B 其实开辟了一个33的数组
选项C 2后面的方括号中不能为空
选项D 开辟了一个22的数组

20.下述哪些说法是正确的？ ( )

A java语言中的类只能有一个构造函数 。
B 程序员可以自己定义自己的异常 。
C java语言允许多继承 。
D 内存回收程序负责释放无用内存。

答案： BD
难度等级：简单
解析：
选项A 可以有很多重载的构造函数
选项C java语言是单继承

21．不能用来修饰interface的有（ ）

A．private
B．public
C．protected
D．static

答案：ACD
难度等级：简单
解析：
接口可以是公有的和默认的

22．下列说法错误的有（）

A．在类方法中可用this来调用本类的类方法
B．在类方法中调用本类的类方法时可直接调用
C．在类方法中只能调用本类中的类方法
D．在类方法中绝对不能调用实例方法　

答案：CD
难度等级：简单
解析：
选项A 正确
选项B 正确
选项C 可以调用其它类的方法，但前提必须把其他类的对象作为函数的参数传递到当前的方法中
选项D this.metod(),就是通过实例对象调用的

23．下列说法错误的有（）

A．Java面向对象语言容许单独的过程与函数存在
B．Java面向对象语言容许单独的方法存在
C．Java语言中的方法属于类中的成员（member）
D．Java语言中的方法必定隶属于某一类（对象），调用方法与过程或函数相同

答案：ABC
难度等级：简单
解析：
java中一切皆对象

24、 在某个类中存在一个方法：void getSort(int x),以下能作为这个方法的重载的声明的是：( )

A.public getSort(float x)
B.int getSort(int y)
C.double getSort(int x,int y)
D.void get(int x, int y)

答案：AC
难度等级：简单
解析：
重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

25、下面的程序名为Student.java ( )

public class Student
{
private String name; 1
public Student(String s_name)    
{
    name = s_name;   2
}
public static void main(String args[])
{
    Student s = new Student();  3
}
}

使用如下指令编译：javac Student.java将会得到什么结果？

A.将会顺利通过编译，并将产生一个Student.class的类文件
B.编译时在//3处出错
C.编译时在//2处出错
D.编译时在//1处出错

答案：B
难度等级：简单
解析：
如果在类中明确显示的写了一个构造函数，那么默认的空的无参构造函数就不会给提供了

generated by haroopad