Java面向对象练习题

1、构造方法可以是静态的。(F)
2、元注解可用于注解Java程序中的类的成员方法。（F）
3、类在实现接口方法时必须给出方法体，并且一定要用public来修饰（T）
4、接口中的方法默认是public abstract方法。接口中的常量默认是public static final的常量（T）
5、如果一个类声明实现一个接口，但没有实现接口中的所有方法，那么这个类必须是abstract类。（T）
6、接口中的属性，都是静态常量。(T)
7、抽象类中不能有private的成员，所有的抽象方法必须存在于抽象类中。(T)
8、抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。(F)
9、abstract类中定义的方法只能是abstract方法。(F)
10、可以重写在超类中定义的静态方法(F)
11、接口可以有静态方法(F)
12、非抽象超类的子类不能是抽象的。(F)
13、抽象方法必须是非静态的(T)
14、接口可以扩展抽象类。（F）
15、子类不继承父类的构造方法（T）
16、抽象类是不能实例化的。（T）
17、有两个引用变量t1和t2，如果 t1 == t2为true, 那么t1.equals(t2)也一定为true（T）
18、已知name，age是Person类的成员属性，关于构造方法，下面哪个描述是正确的？(1分)（D）

A.
public void Person(String name){
this.name=name;
} //这是Person类中的构造方法

B.
public Person(){
name="";
age=10;
}
public Person(String name){
Person();
this.name=name;
} //这是Person类中两个构造方法

C.
public Person(String name){
this();
this.name=name;
} //这是Person类中唯一的构造方法

D.
public Person(){
name="";
age=10;
}
public Person(String name){
this();
this.name=name;
} //这是Person类中两个构造方法

19、以下（）不是Object类的方法(1分)（C）

A.
clone（）

B.
finalize（）

C.
hasNext（）

D.
toString（）

20、关于下面的类描述中正确的是：（C）

class Test{
void test(int i){
System.out.println(“I am an int.”);
}
void test(String s){
System.out.println(“I am a char”);
}
public static void main(String args[]){
Test t=new Test();
t.test(‘a’);
}
}
(1分)

A.
编译出错

B.
编译通过，运行出错

C.
编译通过，运行时输出“I am an int”

D.
编译通过，运行时输出“I am a char"

21、在Java中，负责对不再使用的对象自动回收的是（ A）(2分)

A.
垃圾回收器

B.
虚拟机

C.
编译器

D.
多线程机制
22*、以下说法错误的是（B ）

A.
静态方法可以直接访问本类的静态变量和静态方法

B.
静态方法可以直接访问本类的非静态变量和非静态发方法

C.
非静态方法可以直接访问本类的静态变量和静态方法

D.
非静态方法可以直接访问本类的非静态变量和非静态方法
23、将以下哪种方法插入行6是不合法的。（ A ）

1．public class Test1 {
2． public float aMethod（float a，float b） throws
3． IOException { }
4． }
5．public class Test2 extends Test1{
6．
7．}
(2分)

A.
float aMethod（float a，float b）{ }

B.
public int aMethod（int a，int b）throws Exception{ }

C.
public float aMethod（float p，float q）{ }

D.
public int aMethod（int a，int b）throws IOException{ }
24、下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child(“mike”)的时候都有哪些构造方法被顺序调用？请选择输出结果 ( D )

class People {
String name;
public People() {
System.out.print(1);
}
public People(String name) {
System.out.print(2);
this.name = name;
}
}
class Child extends People {
People father;
public Child(String name) {
System.out.print(3);
this.name = name;
father = new People(name + “:F”);
}
public Child(){
System.out.print(4);
}
}
(2分)

A.
312

B.
32

C.
432

D.
132
25、设有如下代码段:

class A {
int i, j;
public void fun() {
i++;
j++;
}
}

class B extends A {
static int j;
public void func() {
int j = 2;
for (i = 0; i < 10; i++) {
j += 3;
fun();
}
System.out.println(super.i + this.j);
System.out.println(i + “” + j);
}

}
class Main {
public static void main(String[] args) throws Exception {
B b = new B();
b.func();
}
}
运行Main类，输出结果为（D）

A.
0 032

B.
0 1032

C.
10 27

D.
10 1017

E.
42 1032
26、下列关于抽象类的说法哪一个是错误的（B）

A.
含抽象方法的类为抽象类

B.
抽象类能创建(new)实例

C.
子类有未实现父类的抽象方法时仍为抽象类

D.
子类实现所有抽象方法时不再是抽象类
27、以下说法错误的是 （C）

(1分)

A.
super（）可以调用父类的所有非私有构造函数

B.
super.属性可以调用父类的所有非私有属性

C.
super.方法（）可以调用父类的所有非私有方法

D.
this和super关键字可以出现在同一个构造函数中

28、分析如下代码，正确的选项是（ D）。

public class Test {
public static void main(String[] args) {
new B();
}
}

class A {
int i = 7;

public A() {
setI(20);
System.out.println("i from A is " + i);
}

public void setI(int i) {
this.i = 2 * i;
}
}

class B extends A {
public B() {
// System.out.println("i from B is " + i);
}

@Override
public void setI(int i) {
this.i = 3 * i;
}
}
(2分)

A.
A的构造方法未被调用。

B.
A的构造方法被调用，并且输出 “i from A is 7”。

C.
A的构造方法被调用，并且输出 “i from A is 40”。

D.
A的构造方法被调用，并且输出 “i from A is 60”。
29、运行如下程序输出为：（D ）。

public class Test {
  public static void main(String[] args) {
    new Circle9();//找Circle类
  }
}

public abstract class GeometricObject {
  protected GeometricObject() {
    System.out.print("A");
  }

  protected GeometricObject(String color, boolean filled) {
    System.out.print("B");
  }
}

public class Circle9 extends GeometricObject {
  /** No-arg constructor */
  public Circle9() {//找到了Circle类的构造方法，若没有super,则先默认调用父类构造方法，但是注意，下面有个构造方法调用了super,则系统不会在默认调用了。
    this(1.0);//找本类含参的构造方法
    System.out.print("C");
  }

  /** Construct circle with a specified radius */
  public Circle9(double radius) {
    this(radius, "white", false);
    System.out.print("D");
  }

  /** Construct a circle with specified radius, filled, and color */
  public Circle9(double radius, String color, boolean filled) {
    super(color, filled);
    System.out.print("E");
  }
}

A.
ABCD

B.
BACD

C.
AEDC

D.
BEDC

//插入个知识点
import java.util.Scanner;
public class Main {
	public static void main(String [] args) {
	new B();
	new A();
}
}
class A{
	int a=1;
	 protected A() {
		s(10);//调用时先看本类有没有此方法，有的话调用本类的，
		//没有就调用父类的，尽管此语句在父类中
		System.out.println("我是A的无参构造方法");
	}
	public A(int x) {
		System.out.println("我是A的有参构造方法");
	}
	void s(int x) {
		a*=x;
		System.out.println("我是A的方法"+a);
	}
	
}
class B extends A {
	public B() {
		System.out.println("我是B的无参构造方法");
	}
	public B(int x) {
		System.out.println("我是B的you参构造方法");
	}
	void s(int x) {
		a*=x;
		System.out.println("我是B的方法"+a);
	}
}
/*
我是B的方法10
我是A的无参构造方法
我是B的无参构造方法
我是A的方法10
我是A的无参构造方法

*/

30、下列哪些叙述是错误的？（C）

(1)final类不能实现任何接口。

(2)public接口可以被任何一个类实现。

(3)友好类和它所实现的接口必须在一个包里。

(4)如果一个类和友好接口在同一个包里，就允许它实现该接口。

(1分)

A.
(1)(2)

B.
(2)(3)

C.
(1)(3)