- 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（c）关键字来申明父类的这些方法。
a) Finalc
b) Static
c) Abstract
d) Void - 给定两个java程序，如下：
public interface Face{
int counter = 40; 40
}
public class Test implements Face{
private static int counter; 0
public static void main(String[ ]args){
System.out.println(++counter); +1=1
}
}
Test.java 的编译运行结果是（d）。
a) 40
b) 41
c) 0
d) 1 - 给定java代码，如下：
public class Test{
static int i;
public int aMethod( ){
i++;
return i;
}
public static void main(String [] args){
Test test = new Test( );
test.aMethod( ); 1
System.out.println(test.aMethod( )); 2
}
}编译运行后，输出结果是（ c）。
a) 0
b) 1
c) 2
d) 3 - 给定java代码，如下：
abstract class Shape
{
abstract void draw( );
}
要创建Shape类的子类Circle，以下代码正确的是（b,d）。
a) class Circle extends Shape{
int draw( ){}
}
b) abstract class Circle extends Shape{
}
c) class Circle extends Shape{
void draw( );
d) class Circle extends Shape{
void draw( ){}
}
给定java代码，如下：
class Parent{
public void count( ){
System.out.println(10%3); 1
}
}
public class Test extends Parent{
public void count(int i){
System.out.println(10%i);
}
public static void main(String[]args){
Parent p = new Test( );
p.count(3); 10%3 1
}
}
编译运行，结果是（d）。
a) 1
b) 3
c) 3.333333333333335
d) 编译错误给定java程序，如下：
public class Test{
private static final int counter=10; 10
public static void main(String [] args){
System.out.println(++counter);
}
}
编译运行Test.java，结果是 （c ）
a) 10
b) 11
c) 编译错误
d) 运行时出现异常在java中，以定义了两个接口B和C，要定义一个实现这两个接口的类，以下语句正 确的是 （c）
a) interface A extends B,C
b) interface A implements B,C
c) class A implements B,C
d) class A implements B,implements C给定一个Java程序代码，如下：
public class Test{
int count = 9;
public void count1(){
int count =10;
System.out.println("count1="+count); 10
}
public void count2(){
System.out.println("count2="+count); 9
}
public static void main(String args[]){
Test t=new Test();
t.count1();
t.count2();
}
行编译后，输出结果是（b）
a) count1=9
count2=9
b) count1=10
count2=9
c) count1=10
count2=10
d) count1=9
count2=10给定如下 java 代码， 以下（a d）访问控制修饰符可以填入下划线处。
class Parent{
protected void eat(){}
}
class Child extends Parent{
_____ void eat(){}
}
a) Protected
b) Private
c) 什么也不填
d) Public在Java中，下面关于抽象类的描述正确的是（bd）。
a) 抽象类可以被实例化
b) 如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类
c) 抽象类中的方法必须都是抽象的
d) 声明抽象类必须带有关键字abstract给定如下Java代码,以下（ab）方法可以加入Child类中。
Public class Parent{
int change(){…}
}
Class Child extends Parent{
()
}
a) public int change(){}
b) int chang(int i){}
c) private int change(){}
d) abstract int change(){}在java中，在定义类时加上修饰符（d）可以实现该类不能在本类被实例化。
a) Final
b) Public
c) Private
d) Abstract在java中，下面（b）的陈述是正确的。
a) 私有方法不能被重载
b) 静态方法能被重载
c) 公有方法被重写后的访问修饰符可以变成private
d) 一个被重写的方法不能抛出一个在基类中不被检查的异常分析下面的java代码输出结果为（d）。
Class Point{
Int x,y;
Point(int x,int y){
This.x=x;//值传递
This.y=y;
}
Public ststic void main(String[] args){
Point pt1,pt2;
Pt1=new Point (3,3);
Pt2=new Point(4,4);
System.out.print(pt1.x+pt2.x);
}
}
a) 6
b) 34
c) 8
d) 7-
在java中，以下程序的输出结果是（c）。
Class Point
{
Int x;
Boolean y;
Void output()
{
System.out.println(x);
System.out.println(y);}
Public static void main(String[] args)
{
Piont pt =new Point();
Pt.output();
}
}
a) 运行错误
b) 0
Ture
c) 0
False
d) 0
0
- 给定java代码如下，编译运行结果是（a）。
public class Test{
public int count(){
return 1%9; 0
}
public static void main(String[] args){
System.out.println(count());
}
}
a) 编译错误
b) 运行时出现例外
c) 正常运行，输出1
d) 正常运行，输出0 - 在Java接口中，下列选项里有效的方法声明是（ab）
a) public void aMethod();
b) void aMethod();
c) static void aMethod();
d) protected void aMethod(); - 给定java代码，如下：编译运行，结果是（a）
public static void main (String [] args){
String s;
System.out.println(“s=”+s);
}
a) 编译错误
b) 编译通过，但出现运行时错误
c) 正常运行，输出s=null
d) 正常运行，输出s=
// 23) 给定java代码，如下，编译运行后,结果是 (b )。
public class Test{
static String s;
publis static void main(String args[ ]){
char c=s.charAt(0);
System.out.println(c);
}
}
a) 编译错误
b) 运行期异常,异常类型为 NullpointerException
c) 运行期异常,异常类型为 ArithmeticExceptioin
d) 运行正常,但无输出内容
1.下面关于Java语言中方法的说法错误的是:
A.方法调用时参数类型必须符合方法的定义
B.参数传递是值传递的方式
C.如果方法没有返回值必须声明返回为void
D.如果方法定义为返回void，则方法中不能出现return语句
2.指出下列程序运行的结果
public class Example{
String str=new String("welcome");
char[]ch={‘a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(Arrays.toString(ex.ch));
}
public void change(String str,char ch[]){
str="test ok";
ch[0]='g';
}
}
A.welcome and abc
B.welcome and gbc
C.test ok and abc
D.test ok and gbc
3.关于Java对象的删除，下列说法正确的是:
A.必须由程序员完成对象的清除
B.Java把没有引用的对象作为垃圾收集起来并释放
C.只有当程序中调用System.gc()方法时才能进行垃圾收集
D.Java中的对象都很小，一般不进行删除操作
4.下列代码编译或运行的结果是:
public class Foo {
public String doit(int x, int y) {
return "a";
}
public String doit(int[] vals) {
return "b";
}
public static void main(String[] args) {
Foo f=new Foo();
System.out.println(f.doit(4, 5));
}
}
A.代码public String doit(int[] vals) {行，编译出错
B.代码System.out.println(f.doit(4, 5));行，抛出运行时异常
C.输出：a
D.输出：b
5.请看下列代码:
class Inner {
private int x;
public void setX(int x) {
this.x = x;
}
public int getX() {
return x;
}
}
class Outer {
private Inner y;
public void setY(Inner y) {
this.y = y;
}
public Inner getY() {
return y;
}
}
public class Gamma {
public static void main(String[] args) {
Outer o = new Outer();
Inner i = new Inner();
int n = 10;
i.setX(n);
o.setY(i);
<插入代码>
System.out.println(o.getY().getX());
}
}
运行上述代码，要求输出“100”，那么<插入代码>处应填入的代码是：
A.n = 100;
B.i.setX( 100);
C.o.getY().setX( 100);
D.i = new Inner(); i.setX( 100); o.setY( i);
6.关于下列代码说法正确的是：
public class Foo {
public int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
Foo foo = null;
System.out.println(foo.add(10, 20));
}
}
A.编译错误
B.正常运行，但无结果输出
C.运行输出：30
D.运行时抛出NullPointerException异常
7.下列说法正确的有:
A.class中的constructor不可省略
B.constructor必须与class同名，但方法不能与class同名
C.constructor在一个对象被实例化时执行
D.一个class只能定义一个constructor
8.关于 Java 中继承的特点，下列说法正确的是:
A.使类的定义复杂化
B.Java 只支持单继承，不可多继承，但可以通过实现接口来达到多继承的目的
C.子类继承父类的所有成员变量和方法，包括父类的构造方法
D.不可以多层继承，即一个类不可以继承另一个类的子类
9.请看下列代码：
class ClassA {}
class ClassB extends ClassA {}
class ClassC extends ClassA {}
public class Test{
public static void main(String[] args) {
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;
10.请看下列代码，程序的输出结果是：
class One {
public One() {
System.out.print(1);
}
}
class Two extends One {
public Two() {
System.out.print(2);
}
}
class Three extends Two {
public Three() {
System.out.print(3);
}
}
public class Numbers {
public static void main(String[] argv) {
new Three();
}
}
A.1
B.3
C.123
D.321
11.下列代码的运行结果是：
public class Animal {
public String noise() {
return "peep";
}
public static void main(String[] args) {
Animal animal = new Dog();
Cat cat = (Cat)animal;
System.out.println(cat.noise());
}
}
class Dog extends Animal {
public String noise() {
return "bark";
}
}
class Cat extends Animal {
public String noise() {
return "meow";
}
}
A.peep
B.bark
C.meow
D.抛出运行时异常
12.下列代码的运行结果是：
class SimpleCalc {
public int value;
public void calculate() {
value += 7;
}
}
public class MultiCalc extends SimpleCalc {
public void calculate() {
value -= 3;
}
public void calculate(int multiplier) {
calculate();
super.calculate();
value *= multiplier;
}
public static void main(String[] args) {
MultiCalc calculator = new MultiCalc();
calculator.calculate(2);
System.out.println("Value is: " + calculator.value);
}
}
A.Value is: 8
B.Value is: -8
C.Value is: 12
D.Value is: -12
13.下列选项不属于属性的可见性有:
A.公有的
B.私有的
C.私有保护的
D.保护的
14.在 Java 中，关于static关键字的说法错误的是:
A.static 可以修饰方法
B.static 可以修饰变量
C.static 可以修饰代码块
D.static 修饰的方法，在该方法内部可以直接访问非静态的成员变量
15.下列类的定义，错误的是:
A.public class Test extends Object{……}
B.final class Operators{……}
C.class Point{……}
D.void class Point{……}
16.在 Java 中，关于 final 关键字的说法正确的是:
A.如果修饰局部变量，必须初始化
B.如果修饰类，则该类只能被一个子类继承
C.如果修饰方法，则该方法不能在子类中被覆盖
D.如果修饰方法，则该方法所在的类不能被继承
17.下列数组创建和初始化的方式不正确的是：
A. public class Test02 {
static final int[] a = { 100,200 };
}
B. public class Test02 {
static final int[] a;
static {
a=new int[2];
a[0]=100;
a[1]=200;
}
}
C.public class Test02 {
final int[] a;
public Test02(){
a=new int[2];
a[0]=100; a[1]=200;
}
}
D.public class Test02 {
static final int[] a;
static void init() {
a = new int[3];
a[0]=100;
a[1]=200;
}
}
18.关于抽象类的说法正确的是
A.抽象类中一定包含抽象方法，否则是出现编译错误
B.包含抽象方法的类一定是抽象类
C.抽象方法可以没有方法体，也可以有方法体
D.抽象类的子类一定不是抽象类
19.关于接口的说法错误的是：
A.接口是特殊的抽象类
B.接口是抽象方法和常量值的定义的集合
C.当一个非抽象类实现一个接口时，需要实现接口中的所有方法
D.多个类可以实现一个接口，一个类只能实现一个接口
20.请看下列代码：
public class UserRequest {
public void request(ServletAction action) {
action.doService();
}
public static void main(String[] args) {
UserRequest user = new UserRequest();
user.request(new ServletAction() {
public void doService() {
System.out.println("处理请求");
}
});
}
}
如果上述代码采用回调模式编写，下列关于ServletAction的定义正确的是：
A.public static class ServletAction {
public void doService();
}
B.public final class ServletAction {
public void doService();
}
C.public class ServletAction {
public void doService();
}
D. public interface ServletAction {
public void doService();
}
21.下列不属于Swing提供的Listener的是：
A.ActionListener
B.MouseListener
C.KeyListener
D.MemeryListener
22.请看下列代码：
public class Line {
public static class Point { }
}
class Triangle {
<插入代码>
}
在<插入代码>处，需要创建Point类的对象，下列选项正确的是：
A.Point p = new Point();
B.Line.Point p = new Line.Point();
C.Line line = new Line() ; line.Point p = new line.Point();
D.Line.Point p = new Line().new Point();
23.请看下列代码：
public abstract class A {
abstract void a1();
void a2() {
}
}
class B extends A {
void a1() {
}
void a2() {
}
}
class C extends B {
void c1() {
}
}
和
A x = new B(); C y = new C(); A z = new C();
下列选项中属于多态形式调用方法的是：
A.x.a2();
B.z.a2();
C.z.c1();
D.y.c1();
24.程序执行的结果是：
public class Test{
int x = 12;
public void method(int x) {
x += x;
System.out.println(x);
}
public static void main(String[] args) {
Test t = new Test();
t.method(5);
}
}
A.5
B.10
C.12
D.17
25.程序的执行结果是:
public class Test {
int x;
public static void main(String [] args){
Test t = new Test();
t.x=5;
change(t);
System.out.println(t.x);
}
public static void change(Test t){
t.x=3;
}
}
A.5
B.3
C.0
D.4
26.关于下列代码说法正确的是：
public class CreditCard {
private String cardlD;
private Integer limit;
public String ownerName;
public void setCardlnformation(String cardlD, String ownerName,
Integer limit) {
this.cardlD = cardlD;
this.ownerName = ownerName;
this.limit = limit;
}
}
A.类CreditCard是完全封装的
B.属性ownerName打破了封装
C.属性cardlD 和 limit打破了封装
D.方法setCardlnformation打破了封装
27.关于下列代码说法正确的是：
public class A {
public void doit() {
}
public String doit() {
return "a";
}
public double doit(int x) {
return 1.0;
}
}
A.无编译错误
B.代码 public String doit() { 行，出现编译错误
C.代码 public double doit(int x) {行，出现编译错误
D.代码 return "a";行处出现编译错误
28.关于下列代码说法正确的是：
public class ItemTest {
private int id;
public ItemTest(int id) {
this.id = id;
}
public void updateId(int newId) {
id = newId;
}
public static void main(String[] args) {
ItemTest fa = new ItemTest(42);
fa.updateId(69);
System.out.println(fa.id);
}
}
A.编译错误
B.运行时异常抛出
C.运行后，fa对象属性id的值没有改变，应然是42
D.运行后，fa对象属性id的值改变成新的值69
29.请看下列代码：
public class Operator {
public String find(){
return "jessica";
}
public static void main(String[] args) {
<插入代码>
System.out.println(op.find());
}
}如果运行上述代码，抛出NullPointerException异常，那么<插入代码>处应填入的代码是：
A.Operator op=new Operator();
B.Operator op；
C.Operator op=null;
D.new Operator();
30.给出下面的代码段：
public class Base{
int w, x, y, z;
public Base(int a, int b){
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
<插入代码>
w=d;z=c;
}}
在<插入代码>处写下如下代码，正确的是:
A.Base(a, b)；
B.super(a，b)；
C.x=a， y=b；
D.this(a，b)；
31.在Java中，所有类的基类是：
A.java.lang.Object
B.java.lang.Class
C.java.applet.Applet
D.java.awt.Frame
32.下列代码运行的结果是：
class Foo {
public int a;
public Foo() {
a = 3;
}
public void addFive() {
a += 5;
}
}
class Bar extends Foo {
public int a;
public Bar() {
a = 8;
}
public void addFive() {
this.a += 5;
}
}
public class TestFoo {
public static void main(String[] args) {
Foo foo = new Bar();
foo.addFive();
System.out.println("Value: " + foo.a);
}
}
A.Value: 3
B.Value: 8
C.Value: 13
D.Value: 18
33.程序的执行结果是:
public class Test {
public static void main(String [] args){
Child c = new Child();
}
}
class Father{
public Father(){
System.out.println("父类无参构造函数");
}
public Father(String name){
System.out.println("父类有参构造函数");
}
}
class Child extends Father{
public Child(){
this("dd");
System.out.println("子类无参构造函数");
}
public Child(String name){
super("dd");
System.out.println("子类有参构造函数");
}
}
A.父类有参构造函数
子类有参构造函数
子类无参构造函数
B.父类无参构造函数
子类有参构造函数
子类无参构造函数
C.子类有参构造函数
子类无参构造函数
父类无参构造函数
D.子类无参构造函数
子类有参构造函数
父类无参构造函数
34.下列代码的运行结果是：
public class Animal {
public String noise() {
return "peep";
}
public static void main(String[] args) {
Cat cat =null;
Animal animal = new Dog();
if (animal instanceof Cat) {
cat = (Cat) animal;
System.out.println(cat.noise());
}else{
System.out.println("animal is not Cat's instance");
}
}
}
class Dog extends Animal {
public String noise() {
return "bark";
}
}
class Cat extends Animal {
public String noise() {
return "meow";
}
}
A.peep
B.bark
C.meow
D.animal is not Cat's instance
35.请看下列代码：
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 int blipvert(long x) { return 0; }
D.protected long blipvert(int x) { return 0; }
36.下面关于import, class和package的声明顺序正确的是:
A.package, import, class
B.class, import, package
C.import, package, class
D.package, class, import
37.请看下列代码：
public class Foo {
static void alpha() { /* more code here */}
void beta() { /* more code here */}
}
下列说法正确的是：
A.Foo.beta()是调用beta方法的正确方式
B.Foo.alpha()是调用alpha方法的正确方式
C.beta方法可以直接调用alpha方法
D.alpha方法可以直接调用beta方法
38.关于下列代码说法正确的是：
public interface DoStuff2 {
float getRange(int low, int high);
}
interface DoMore {
float getAvg(int a, int b, int c);
}
abstract class DoAbstract implements DoStuff2, DoMore {
}
class DoStuff implements DoStuff2 {
public float getRange(int x, int y) {
return 3.14f;
}
}
interface DoAll extends DoMore {
float getAvg(int a, int b, int c, int d);
}
A.无编译错误
B.代码abstract class DoAbstract implements DoStuff2, DoMore {行，编译错误
C.代码interface DoAll extends DoMore {行，编译错误
D.代码float getAvg(int a, int b, int c, int d);行，编译错误
39.请看下列代码编译和运行的结果是：
public class Student {
private String name="sun";
public static void main(String[] args) {
Student[] students=new Student[2];
System.out.println(students[0].name);
System.out.println(students.length);
}
}
A.sun 2
B.null 2
C.null 1
D.运行时抛出NullPointerException异常
40.下面程序定义了一个类，关于该类说法正确的是:
abstract class AbstractClass{ … }
A.可以使用new AbstractClass()；来实例化一个AbstractClass类的对象
B.该类不能被继承
C.该类的方法都不能被重载
D.该类的方法可以在子类中重写
/**
* 求其每一个子串出现的次数
* 要求：对每个字符串，输出它所有出现的次数在1次以上的子字符串，和这个子字符串出现的次数并按字典顺序排序
*/
public class Demo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String line = null;
while(input.hasNextLine()){
line = input.nextLine();
parse(line);
}
}
private static void parse(String line) {
String subLine = null;
Map<String,Integer> map = new TreeMap<>();
List<String> list = new ArrayList<>();
for(int i = 0;i<line.length();i++){
for(int j = i+1;j<=line.length();j++){
subLine = line.substring(i,j);
if(subLine.length()!=line.length()){
list.add(subLine);
map.put(subLine,0);
}
}
}
for(int i = 0;i<list.size();i++){
for(Map.Entry<String,Integer> entry:map.entrySet()){
if(list.get(i).equals(entry.getKey())){
entry.setValue(entry.getValue()+1);
}
}
}
for(Map.Entry<String,Integer> entry:map.entrySet()){
if(entry.getValue() > 1){
System.out.println(entry.getKey()+" "+entry.getValue());
System.out.println();
}
}
}
}
答案：
1.D 2.B 3.B 4.C 5.BCD 6.D 7.C 8.B 9.A 10.C
11.D 12.A 13.C 14.D 15.D 16.C 17.D 18.B 19.D 20.D
21.D 22.B 23.AB 24.B 25.B 26.B 27.B 28.D 29.C 30.D
31.A 32.A 33.A 34.D 35.AC 36.A 37.BC 38.A 39.D 40.D
共40道选择题，每题2.5分。多选题有错则全错，全对才满分.
1-10 : c d d d c c d d d b
11-20: a c b c b c b b c d
a a d c d c c b a c
ad 、 abc 、acd 、bd、bd
ac abc abd ad abc
面向对象部分测试题
- 下面描述函数重写错误的是（C）
A. 要有子类继承或实现
B. 子类方法的权限必须大于等于父类的权限
C. 父类中被private权限修饰的方法可以被子类重写
D. 子类重写接口中的抽象方法,子类的方法权限必须是public的
- 关于封装下面介绍错误的是（D ）。
A. 封装将变化隔离
B. 封装提高重用性。
C. 封装安全性
D. 只有被private修饰才叫做封装
- 试图编译运行下面的代码会发生什么情况（D）
public class MyClass{
static int i;
public static void main(String[] args){
System.out.println(i);
}
}
A. 错误，变量i没有被初始化
B. 输出null
C. 输出1
D. 输出0
- 在Java中，下面对于构造函数的描述正确的是（ D）。
A. 类必须显式定义构造函数
B. 构造函数的返回类型是void
C. 构造函数和类有相同的名称，并且不能带任何参数
D. 一个类可以定义多个构造函数
- 下面Java代码的运行结果是（ C ）。
class Penguin {
private String name=null; // 名字
private int health=0; // 健康值
private String sex=null; // 性别
public void Penguin() { //是一般方法，不是构造方法
health = 10;
sex = "雄";
System.out.println("执行构造方法。");
}
public void print() {
System.out.println("企鹅的名字是" + name +
"，健康值是" + health + "，性别是" + sex+ "。");
}
public static void main(String[] args) {
Penguin pgn = new Penguin();
pgn.print();
}
}
A. 企鹅的名字是null，健康值是10，性别是雄。
B. 执行构造方法。
企鹅的名字是null，健康值是0，性别是null。
C. 企鹅的名字是null，健康值是0，性别是null。
D. 执行构造方法。
企鹅的名字是null，健康值是10，性别是雄。
- class A {
public int i = 10;
}
class B extends A{
public int i = 20;
}
public class Test{
public static void main(String args[]){
B b = new B();
A a = b;
System.out.println(b.i);
System.out.println(a.i);
}
}输出为多少 ( C)
A.10 10
B.10 20
C.20 10
D.20 20
- 下面说法正确的是( D )。
A. 匿名内部类编译后不会生成.class文件
B. 接口编译后不会生成.class文件
C. 抽象类中没有构造方法
D. 局部内部类只能访问被final修饰的局部变量。
- 下面对this的作用描述错误的是D
A. 当成员变量和局部变量重名的时候可以用this区分
B. this()语句必须放在构造函数的第一行,根据this后面括号中的参数调用本类其他的构造函数.
C. this可以调用本类的一般函数
D. this可以调用父类的一般函数
- 在Java中，以下程序编译运行后的输出结果为（D ）。
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}
A. 6
B. 3 4
C. 8
D. 7
- 在Java语言中，下列关于类的继承的描述，正确的是（B ）。
A. 一个类可以继承多个父类
B. 一个类可以具有多个子类
C. 子类可以使用父类的所有方法
D. 子类一定比父类有更多的成员方法
- Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（A ）。
A. C可以继承B中的公有成员，同样也可以继承A中的公有成员
B. C只继承了B中的成员
C. C只继承了A中的成员
D. C不能继承A或B中的成员
- 给定一个Java程序Test.java的代码如下所示，编译时，会出现以下（ C）情况。
class Parent {
public int count() { // 第1行
return 0;
}
}
public class Test extends Parent {
public float count() { // 第2行
return 9; // 第3行
}
}
A. 编译通过
B. 在第1行引发编译错误
C. 在第2行引发编译错误
D. 在第3行引发编译错误
- 给定如下一个Java源文件Child.java，编译并运行Child.java，以下结果正确的是（B ）。
class Parent1 {
Parent1(String s){
System.out.println(s);
}
}
class Parent2 extends Parent1{
Parent2(){
System.out.println("parent2");
}
}
public class Child extends Parent2 {
public static void main(String[] args) {
Child child = new Child();
}
}
A. 编译错误：没有找到构造器Child()
B. 编译错误：没有找到构造器Parent1() //因为当我们给出了构造方法，系统将不再提供默认的无参构造函数
C. 正确运行，没有输出值
D. 正确运行，输出结果为：parent2
- 给定Java程序Child.java的代码如下所示，则编译运行该类的结果是（C ）。
class Parent {
Parent() {
System.out.println("parent");
}
}
public class Child extends Parent {
Child(String s) {
System.out.println(s);
}
public static void main(String[] args) {
Child child = new Child("child");
}
}
A. child
B. child
parent
C. parent
child
D. 编译错误
- 下列选项中关于Java中super关键字的说法错误的是（ B）。
A. 当子父类中成员变量重名的时候,在子类方法中想输出父类成员变量的值,可以用super区分子父类成员变量
B. super语句可以放在构造函数的任意一行
C. 子类可以通过super关键字调用父类的方法
D. 子类可以通过super关键字调用父类的属性
- 分析如下所示的Java代码，则选项中的说法正确的是（ C）。
class Parent{
public String name;
public Parent(String pName){
this.name = pName;
}
}
public class Test extends Parent { //1
public Test(String Name){ //2
name="hello"; //3
super("kitty"); //4
}
}
A. 第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
B. 第3行错误，应使用super关键字调用父类的name属性，改为super.name="hello";
C. 第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
D. 程序编译通过，无错误
- 以下关于Object类说法错误的是（ B）。
A. 一切类都直接或间接继承自Object类
B. 接口也继承Object类
C. Object类中定义了toString()方法
D. Object类在java.lang包中
- 在Java中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及可扩展性，下面哪一个选项不属于多态的条件（ B）。
A. 子类重写父类的方法
B. 子类重载同一个方法
C. 要有继承或实现
D. 父类引用指向子类对象
- 给定Java代码如下所示，则编译运行后，输出结果是（ C）。
class Parent {
public void count() {
System.out.println(10%3);
}
}
public class Child extends Parent{
public void count() {
System.out.println(10/3);
}
public static void main(String args[]) {
Parent p = new Child();
p.count();
}
}
A. 1
B. 1.0
C. 3
D. 3.3333333333333335
- 编译运行如下Java代码，输出结果是（ D ）。
class Base {
public void method(){
System.out.print ("Base method");
}
}
class Child extends Base{
public void methodB(){
System.out.print ("Child methodB");
}
}
class Sample {
public static void main(String[] args) {
Base base= new Child();
base.methodB();
}
}
A. Base method
B. Child methodB
C. Base method Child MethodB
D. 编译错误
- 在Java接口中，下列选项中属于有效的方法声明是（A ）。
A. public void aMethod();
B. final void aMethod();
C. void aMethod(){}
D. private void aMethod();
- 给定如下Java程序代码，在_____横线处加入（ A）语句，可以使这段代码编译通过。
interface Parent{
public int count(int i);
}
public class Test implements Parent {
public int count(int i){
return i % 9;
}
public static void main(String[] args){
int i = p.count(20);
}
}
A. Test p = new Test();
B. Parent p;
C. Parent p = new Parent();
D. Test p = new Parent();
- 下面说法中错误的是D
A. 静态代码块类一加载只执行一次,以后再创建对象的时候不执行
B. 局部代码块的作用是为了限制变量的生命周期
C. 构造代码块在每创建一次对象就执行一次
D. 以上都不对
- 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（ C ）关键字来声明父类的这些方法。
A. final
B. static
C. abstract
D. void
- 给定两个java程序，如下：
public interface Face{
int counter = 40;
}
public class Test implements Face{
private static int counter;
public static void main(String[]args){
System.out.println(++counter);
}
} Test.java 的编译运行结果是（D ）。
A. 40
B. 41
C. 0
D. 1
- 给定java代码，如下：
public class Test{
static int i;
public int aMethod( ){
i++;
return i;
}
public static void main(String [] args){
Test test = new Test( );
test.aMethod( );
System.out.println(test.aMethod( ));
}
}编译运行后，输出结果是（C ）。
A. 0
B. 1
C. 2
D. 3
- 给定java程序，如下：
public class Test{
private static final int counter=10;
public static void main(String [] args){
System.out.println(++counter);
}
}
编译运行Test.java，结果是 （ C）
A. 10
B. 11
C. 编译错误
D. 运行时出现异常
- 给定一个Java程序代码，如下：
public class Test{
int count = 9;
public void count1(){
int count =10;
System.out.println("count1="+count);
}
public void count2(){
System.out.println("count2="+count);
}
public static void main(String args[]){
Test t=new Test();
t.count1();
t.count2();
}
}
编译运行后，输出结果是B
A. count1=9 count2=9
B. count1=10 count2=9
C. count1=10 count2=10
D. count1=9 count2=10
- 给定java代码，如下：编译运行，结果是A
public static void main (String [] args){
String s;
System.out.println(“s=”+s);
}
A. 编译错误
B. 编译通过，但出现运行时错误
C. 正常运行，输出s=null
D. 正常运行，输出s=
- 在java中，以下程序的输出结果是（C）。
class Point {
int x;
boolean y;
void output() {
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
Point pt =new Point();
pt.output();
}
}
A. 运行错误
B. 0 ture
C. 0 false
D. 0 0
多选择题：
- 给定如下 java 代码， 以下（ AD ）访问控制修饰符可以填入下划线处。
class Parent{
protected void eat(){
}
}
class Child extends Parent {
_______ void eat(){
}
}
A. protected
B. private
C. 什么也不填 //及默认修饰符
D. public
- 给定如下Java代码 , 以下（ ABC ）AB方法可以加入Child类中。
public class Parent{
int change(){
…
}
}
Class Child extends Parent{
(此处可以放入下面哪个选项)
}
A. public int change(){}
B. int show(int i){}
C. private int change(){}//private的权限低于默认修饰符
D. abstract int change(){}
- 下面对static的描述正确的是 ACD
A. 静态修饰的成员变量和成员方法随着类的加载而加载
B. 静态修饰的成员方法可以访问非静态成员变量
C. 静态修饰的成员可以被整个类对象所共享
D. 静态修饰的成员变量和成员方法随着类的消失而消失
- 给定java代码，如下：
abstract class Shape {
abstract void draw( );
}
要创建Shape类的子类Circle，以下代码正确的是（BD）。
A. class Circle extends Shape{ int draw( ){} }
B. abstract class Circle extends Shape{ }
C. class Circle extends Shape{ void draw( ); }
D. class Circle extends Shape{ void draw( ){} }
- 在Java中，下面关于抽象类的描述正确的是（BD）。
A. 抽象类可以被实例化
B. 如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类
C. 抽象类中的方法必须都是抽象的
D. 声明抽象类必须带有关键字abstract
- 在java中，已定义了两个接口B和C以下语句正确的是 （ AC）
A. interface A extends B,C
B. interface A implements B,C
C. class A implements B,C
D. class A implements B,implements C
- 关于abstract不能和哪些关键字共用正确的是(ABC)
A. abstract不可以和private共用
B. abstract不可以和static共用
C. abstract不可以和final共用
D. abstract不可以和public共用
- 下面关于Java接口的说法正确的是（ABD ）。
A. Java接口中定义的是扩展功能
B. Java接口中可以被多个子类实现,一个类也可以同时实现多个接口
C. Java接口中可以声明私有成员
D. Java接口不能被实例化
- 分析如下Java代码，如果想在控制台上输出“B类的test()方法”，则在主函数应填入（ AD）。
class A {
public void test() {
System.out.println("A类的test()方法");
}
}
class B extends A {
public void test() {
System.out.println("B类的test()方法");
}
public static void main(String args[]) {
}
}
A. A a = new B();
a.test();
B. A a = new A();
a.test();
C. B b = new A();
b.test();
D. new B().test();
- 在Java接口中定义常量，下面语法正确的是（ABC ）。
A. static int MALE = 1;
B. final int MALE = 1;
C. int MALE = 1;
D. private int MALE = 1;
