Java面向对象选择题1

1.给出下列代码

Class A{
    public byte getNumber(){
    return 1;
    }
}
Class B extends A{
    public short getNumber(){
    return 2;
}
    Public static void main(String[] args){
        B b=new B();
        System.out.println(b.getNumber());
    }
}

What is the result?

A.compilication successed and 1 is printed
B.compilication successed and 1 is printed
C.An error at line 7 causes compilication to fail
D.An error at line 14 causes compliation to fail

答案：C
难度等级：简单
解析：
public short getNumber(){//此行报错，返回值是short，但实际return是int
return 2;
}

2、下列哪一个关键字能够限制父类字符中的方法只能在子类中调用，而不能在其他类中调用()

A.public
B.private
C.protected
D.transient

答案：C
难度等级：C简单
解析：
java的四个访问修饰符：
访问权限    类    包    子类   其他包
public       ∨     ∨     ∨      ∨
protect      ∨     ∨      ∨      ×
default      ∨     ∨      ×       ×
private      ∨      ×      ×       ×

3、下面那几份函数是public void example(){…}的重载函数()

A.public void example(int m){}
B.Public int example(){}
C.Public void example2(){}
D.Public int example(int m,float f){}

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

4.Which three are valid on line 2?

 public interface Status { 
     /* insert code here */ int MY_VALUE = 10;
 }

A. final
B. static
C. native
D. public
E. private
F. abstract
G. protected

答案：ABD
难度等级：简单
解析：
接口中的放置的是公有的静态的final常量

5.下面代码中的第2行可以插入一行代码 ()保证程序编译通过。

public interface A{

}

A. void method();
B. public void method();
C. static void method();
D. private void method();
E. protected void method();

答案：AB
难度等级：简单
解析：
接口中的方法可以不写public修饰符，

6、关于被私有访问控制符private修饰的成员变量，以下说法正确的是（）

A． 可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B． 可以被两种类访问和引用：该类本身、该类的所有子类
C． 只能被该类自身所访问和修改
D． 只能被同一个包中的类访问

答案：C
难度等级：简单
解析：
私有的成员变量只能被本类自己访问
java的四个访问修饰符：
访问权限    类    包    子类   其他包
public       ∨     ∨     ∨      ∨
protect      ∨     ∨      ∨      ×
default      ∨     ∨      ×       ×
private      ∨      ×      ×       ×

7、类Test1定义如下：

1．public  class  Test1{
2．        public  float  aMethod（float  a，float  b）{   }
3．        
4．}    

将以下哪种方法插入行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）{ }

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

8、 已知如下代码：

1: class Example{
2:     String str;
3:     public Example(){
4:         str= "example";
5:     }
6:     public Example(String s){
7:         str=s;
8:     }
9:} 
10: class Demo extends Example{
11: }
12: public class Test{
13:    public void f () {
14:        Example ex = new Example("Good");
15:        Demo d = new Demo("Good");
16:    } }

哪句语句会导致错误？( )

A、line 3
B、line 6
C、line 10
D、line 14
E、line 15

答案：E
难度等级：简单
解析：
语法报错，Demo类中没有带一个字符串参数的构造函数

9、下述说法中，错误的是( )

A．Java中，方法的重载是指多个方法可以共享同一个名字
B．Java中，用abstract修饰的类称为抽象类，它不能实例化
C．Java中，接口不包含成员变量和方法实现
D．Java中，构造方法可以有返回值

答案：ACD
难度等级：简单
解析：
选项A 重载是方法的名字相同，但参数的个数和类型不同
选项C 接口中是可以有成员变量的，但必须是静态的且是常量
选项D 构造方法是不能有返回值的

10、 下面哪些是正确的( )

class ClassA {}                            
class ClassB extends ClassA {}                
class ClassC extends ClassA {}                
and:                                            
ClassA p0 = new ClassA();
ClassB p1 = new ClassB();
ClassC p2 = new ClassC();
ClassA p3 = new ClassB();
ClassA p4 = new ClassC();

A. p0 = p1;
B. p1 =p2;
C. p2 = p4;
D. p2 = (ClassC)p1;
E. p1 = (ClassB)p3;
F. p2 = (ClassC)p4;

答案：AEF
难度等级：简单
解析：
子类的对象可以赋值给长辈的引用
要把长辈的对象赋值给小辈的引用，就必须要强制转换

11.下面关于final说法正确的是：（）。

A.final修饰类时，该类能被继承。
B.final修饰方法时，该方法能被重写。
C.当使用static final 修饰的常量时，将采用编译期绑定的方式。
D.当使用final和abstract共同修饰一个类时，final应至于abstract之前。

答案：AB
难度等级：简单
解析：
选项C 不是在编译期绑定的
选项D final 和 abstract 关键字不能同时使用

12.(单选)请看下列代码编译和运行的结果是：

package packagea; 
public class Message { 
    String getText() { 
        return "text"; 
    }
 } 
 package packageb; 
 public class XMLMessage extends packagea.Message{
     String getText() { 
         return "<msg>text</msg>"; 
     } 
     public static void main(String[] args) {
         System.out.println(new XMLMessage().getText()); 
     } 
 }

A.text
B.text
C.抛出运行时异常
D.代码public class XMLMessage extends packagea.Message{行，编译错误

答案：B
难度等级：简单
解析：
考查继承，调用的是本类XMLMessage中自己的方法

13.(单选)请看下列代码：

interface Data { 
    public void load(); 
} 
abstract class Info { 
    public abstract void load(); 
} 

下列选项中，能正确使用Data接口和Info类的是（）。

A.

public class Employee extends Info implements Data { 
     public void load() { 
         /*do something*/ 
     } 
}

B.

public class Employee implements Info extends Data {
    public void load() {
        /*do something*/ 
    } 
}

C.

public class Employee implements Info extends Data { 
    public void Data.load() { 
        /*d something */ 
    }
    public void load() { 
        /*do something */ 
    }
}

D.

public class Employee extends Info implements Data { 
    public void load() { 
        /*do something */ 
    }
    public void Info.load() {
        /*do something*/ 
    } 
}

答案：A
难度等级：简单
解析：
先继承类后实现接口，因为方法的生命是相同的，所以只需要重写一次即可

14.(单选)类Super及Sub定义如下：

public class Super { 
    private void f() { 
        System.out.println("Super.f()"); 
    } 
    public void g() { 
        f(); 
    } 
    public void k() {
        f(); 
    } 
} 
public class Sub extends Super {
    private void f() { 
        System.out.println("Sub.f()"); 
    } 
    public void k() { 
        f(); 
    } 
}  

运行下列语句:

Super obj = new Sub(); obj.g(); obj.k();  

输出的结果是：（）。

A.Sub.f() Sub.f()
B.Sub.f() Super.f()
C.Super.f() Sub.f()
D.Super.f() Super.f()

答案：C
难度等级：中
解析：
此题考查继承和多态
obj.k();实际上是执行的子类中的重写的k方法
在子类中的k方法调用的就是子类的f方法

15.(单选)下列代码的输出结果是：

public class Yikes {
    public static void go(Long n) { 
        System.out.println("Long"); 
    } 
    public static void go(Short n) {
        System.out.println("Short");
    } 
    public static void go(int n) {
        System.out.println("int"); 
    } 
    public static void main(String[] args) {
        short y = 6; 
        long z = 7; 
        go(y); 
        go(z); 
    } 
}

A.Long Long
B.Short Long
C.int Long
D.int int

答案：C
难度等级：简单
解析：
此题考查方法调用和数据类型，还有重载

16.(单选)下列代码的输出结果是：

public class Blip { 
    protected int blipvert(int x) { 
        return 0; 
    } 
} 
class Vert extends Blip {
    <插入代码> 
} 

在<插入代码>处填入选项中的代码，使Vert类没有编译错误的是（）。

A.public int blipvert(int x) { return 0; }
B.private int blipvert(int x) { return 0; }
C.private void blipvert(int x) { return 0; }
D.protected long blipvert(int x) { return 0; }

答案：A
难度等级：简单
解析：
方法的重写，方法的声明要相同，作用域修饰符不能比父类的方法小

17.(单选)关于下列代码说法正确的是：

public class A {
    private int counter = 0; 
    public static int getInstanceCount() { 
        return counter; 
    } 
    public A() { 
        counter++; 
    } 
    public static void main(String[] args) { 
        A a1 = new A(); 
        A a2 = new A(); 
        A a3 = new A();
        System.out.println(A.getInstanceCount()); 
    } 
}

A.该类编译失败
B.输出：1
C.输出：3
D.输出：0

答案：A
难度等级：简单
解析：
public static int getInstanceCount() {
return counter;
}
静态方法只能访问静态的变量，counter不是静态变量

18.(单选)下列类的定义，错误的是（）。

A.public class Test extends Object{……}
B.final class Operators{……}
C.class Point{……}
D.void class Point{……}

答案：D
难度等级：简单
解析：
void不能修饰在类上，可以修饰方法上

19.(单选)关于下列代码说法正确的是：

public class Money {
    private String country, name; 
    public String getCountry() { 
        return country; 
    } 
} 
class Yen extends Money { 
    public String getCountry() { 
        return super.country; 
    } 
} 
class Euro extends Money { 
    public String getCountry(String timeZone) {
        return super.getCountry(); 
    } 
}

A.Yen类编译正确
B.Euro类编译正确
C.Money类编译错误
D.Yen和Money编译错误

答案：B
难度等级：简单
解析：
class Yen extends Money {
public String getCountry() {
return super.country;
}
}
super.country;编译报错，country是私有的无法访问

20.(单选)下列代码运行的结果是（）。

public class Base { 
    public static final String FOO = "foo"; 
    public static void main(String[] args) { 
        Base b = new Base();
        Sub s = new Sub(); 
        System.out.print(Base.FOO); 
        System.out.print(Sub.FOO); 
        System.out.print(b.FOO); 
        System.out.print(s.FOO); 
        System.out.print(((Base) s).FOO); 
    } 
} 
class Sub extends Base { 
    public static final String FOO = "bar";
}

A.foofoofoofoofoo
B.foobarfoobarbar
C.foobarfoofoofoo
D.foobarfoobarfoo

答案：D
难度等级：简单
解析：
静态的方法只能访问静态的变量或静态方法，非静态的方法即可以访问静态的方法或静态的变量，也可以访问非静态的方法或非静态的变量
静态的变量或方法属于类而不属于对象，所以在访问范围允许的情况下，静态的变量或方法都可以通过类名访问。虽然可以通过对象来访问静态的变量或静态的方法，但不推荐。

21.(单选)题目： 下列代码的输出结果是: （）。

public class A { 
    public void info(){ 
        System.out.println("A info"); 
    } 
} 
public class B extends A{ 
    public void info(){ 
        System.out.println("B info"); 
    } 
    public static void main(String[] args) { 
        B b=new B(); 
        A a=b; 
        a.info();
    } 
}

A.B info A info
B.A info B info
C.A info
D.B info

答案：D
难度等级：
解析：
多态，用长辈的引用调用的是小辈里重写的方法

22.(多选)请看下列代码

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

和Foo类中method方法重载的方法是:

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

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

23.(多选)请看下列代码：

package com.tarena; 
public class Geodetics { 
public static final double DIAMETER = 12756.32;
} 

访问静态常量DIAMETER的方式正确的是：

A.

import com.tarena.Geodetics; 
public class TerraCarta { 
    public double halfway(){  
        return Geodetics.DIAMETER/2.0;  
    }  
}

B.

import com.tarena.Geodetics;
public class TerraCarta { 
    public double halfway(){  
        return DIAMETER/2.0;  
    }  
}

C.

import com.tarena; 
public class TerraCarta { 
    public double halfway(){  
        return Geodetics.DIAMETER/2.0;  
    }  
}

D.

import com.tarena.*; 
public class TerraCarta { 
    public double halfway(){  
        return Geodetics.DIAMETER/2.0; 
    } 
}

答案：AD
难度等级：简单
解析：
静态的方法只能访问静态的变量或静态方法，非静态的方法即可以访问静态的方法或静态的变量，也可以访问非静态的方法或非静态的变量
静态的变量或方法属于类而不属于对象，所以在访问范围允许的情况下，静态的变量或方法都可以通过类名访问。虽然可以通过对象来访问静态的变量或静态的方法，但不推荐。

24.(多选)在Java语言中，下列说法正确的是（）。

A.一个接口可以继承多个接口
B.一个类可以继承多个类
C.一个类可以实现多个接口
D.一个类可以有多个子类

答案：ACD
难度等级：简单
解析：
选项B java中继承是单继承

25.(多选)请看下列代码：

public abstract class Shape { 
    int x; 
    int y; 
    public abstract void draw(); 
    public void setAnchor(int x, int y) { 
        this.x = x;
        this.y = y; 
    }
} 

下列选项中能正确使用Shape类的是：

A.public class Circle implements Shape { private int radius; }
B.public abstract class Circle extends Shape { private int radius; }
C.public class Circle extends Shape { private int radius; public void draw(); }
D.public class Circle extends Shape { private int radius; public void draw() {/ code here /} }

答案：BD
难度等级：简单
解析：
抽象类中的抽象方法，在子类中重写，如果没有重写，还是抽象方法，他所对应的类也是抽象类，抽象类中只要有一个抽象方法，那么这个类就是抽象类

generated by haroopad