题目整理来源 —— 恒骊学堂 ，更加体系化的视频请点击
1、 面向对象编程的三大特性是（ ）
A) 封装，继承，多态
B) 封装，重用，继承
C) 继承，抽象，多态
D) 封装，灵活，抽象
2、 下面关于构造方法的说法正确的是（ ）
A. 构造方法不能被继承
B. 构造方法不能被重写
C. 构造方法不能被重载
D. 构造方法不能声明为private
3、 下面关于类的说法，不正确的是（ ）
A) 类是同种对象的集合和抽象
B) 类属于Java语言中的引用数据类型
C) 对象是类的实例
D) 类就是对象
4、 Java语言中哪个包是被自动导入的（）
A) java.util
B) java.lang
C) java.default
D) java.io
5、 有一个类MyClass，它的构造方法声明正确的是（ ）
A) void MyClass(int x) {...}
B) Myclass(int x){...}
C) public MyClass(int x){…}
D) public void MyClass(int x){…}
6、 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要由子类重写，应该使用
（ ）关键字来声明父类的这些方法
A) final
B) abstract
C) static
D) void
7、 下面关于接口说法不正确的是( )
A) 接口的所有方法都是抽象的
B) 接口所有的方法一定都是public的
C) 用于定义接口的关键字是implements
D) 接口是一组行为的集合
8、 为了区分类中重载的同名不同方法，要求( )
A) 参数的类型或个数不同
B) 使用不同的参数名
C) 修改访问权限
D) 方法返回值数据类型不同
9、 不能用在类上的修饰符是（ ）
A) final
B) public
C) abstract
D) protected
10、 当编译并运行下面程序时会出现什么结果（ ）
public class MyAr{
public static void main(String argv[]){
int[] i = new int[5];
System.out.println(i[5]);
}
}
A) 编译出错
B) 运行出错
C) 输出0
D) 输出“null”
11、 已定义两个接口B和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
12、 下面关于继承的叙述正确的是（ ）
A. 在JAVA里只允许单一继承
B. 在JAVA里一个类只能实现一个接口
C. JAVA可以多继承
D. JAVA的单一继承避免了菱形继承的危险
13、 研究下面的JAVA代码，输出结果将是（ ）
public class Test {
String s = "nba";
public void test(String s) {
System.out.println("s:"+s);
System.out.println("this.s:"+this.s);
this.s=s;
System.out.println("s:"+s);
System.out.println("this.s:"+this.s);
}
public static void main(String[] args) {
new Test().test("cba");
}
}
A. s:cba this.s:nba s:cba this.s:nba
B. s:nba this.s:nba s:nba this.s:nba
C. s:cba this.s:nba s:cba this.s:cba
D. s:nba this.s:cba s:cba this.s:cba
14、 给定JAVA代码如下，关于super的用法，以下描述正确的是（ ）
class C extends B {
public C() {
super();
}
}
A、用来调用类B中定义的super()方法
B、用来调用类C中定义的super()方法
C、用来调用类B中的无参构造方法
D、用来调用类B中第一个出现的构造方法
15. 对于任意一个类，用户所能定义的构造方法的个数至多为（）
A. 0个
B. 1个
C. 2个
D. 任意个
16．关于实例方法和类方法，以下描述正确的是（）
A. 实例方法只能访问实例变量
B. 类方法既可以访问类变量，也可以访问实例变量
C. 类方法只能通过类名来调用
D. 实例方法只能通过对象来调用
17．接口是Java面向对象的实现机制之一，以下说法正确的是：（）
A. Java支持多重继承，一个类可以实现多个接口；
B. Java只支持单重继承，一个类可以实现多个接口；
C. Java只支持单重继承，一个类只可以实现一个接口；
D. Java支持多重继承，但一个类只可以实现一个接口。
18. 关于接口的定义和实现，以下描述正确的是：（）
A. 接口定义中的方法都只有定义没有实现
B. 接口定义中的变量都必须写明final和static
C. 如果一个接口由多个类来实现，则这些类在实现该接口中的方法时应采用统一的代码
D. 如果一个类实现一个接口，则必须实现该接口中的所有方法，但方法未必声明为public.
19.下列关于抽象类的说法四个是正确的？（）
A．某个抽象类的父类是抽象类，则这个子类必须重写父类的所有抽象方法；
B．接口和抽象类是同一回事；
C．绝对不能用抽象类去创建对象；
D．抽象类中不可以有非抽象方法。
20、以下描述不正确的是？（）
A. final class不能被继承
B. final变量不能被修改
C. final成员变量不可以在构造方法中赋值
D. final方法不能被覆盖(override)
21、以下描述不正确的是（）
A. abstract class一定有abstract method(s)
B. abstract class可以没有abstract method(s)
C. 定义abstract class的目的是为了被继承
D. interface中定义的方法全是abstract methods
E. interface中定义的变量全部是final static变量
22、下面关于java语言中方法的说法错误的是： （）
A.方法调用时参数类型必须符合方法的定义
B.参数传递是值传递的方式
C.如果方法没有返回值必须声明返回为void
D.如果方法定义为返回void，则方法中不能出现return语句
23. 在Java类中，使用以下（ ）声明语句来定义公有的int型常量MAX。
A. public int MAX = 100;
B. final int MAX = 100;
C. public static int MAX = 100;
D. public static final int MAX = 100;
24. 在Java中，下列关于方法重载的说法中错误的是（ ）。
A. 方法重载要求方法名称必须相同
B. 重载方法的参数列表必须不一致
C. 重载方法的返回类型必须一致
D. 一个方法在所属的类中只能被重载一次
25. 给定Java代码如下所示，在横线处新增下列（ ）方法，是对cal方法的重载。
public class Test{
public void cal(int x, int y, int z) {}
_____________
}
A. public int cal(int x, int y, float z){ return 0; }
B. public int cal(int x, int y, int z){ return 0; }
C. public void cal(int x, int z){ }
D. public void cal(int z, int y, int x){ }
26. 在Java中，下面对于构造函数的描述正确的是（ ）。
A. 类必须显式定义构造函数
B. 构造函数的返回类型是void
C. 构造函数和类有相同的名称，并且不能带任何参数
D. 一个类可以定义多个构造函数
27. 下面Java代码的运行结果是（ ）。
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，性别是雄。
28. 下列选项中关于Java中封装的说法错误的是（ ）。
A. 封装就是将属性私有化，提供公有的方法访问私有属性
B. 属性的访问方法包括setter方法和getter方法
C. setter方法用于赋值、getter方法用于取值
D. 类的属性必须进行封装，否则无法通过编译
29. 使用Java实现封装，第一步是修改属性可见性来限制对属性的访问，第二步是创建赋值和取值方法，用于对属性的访问，第三步应该是（ ）。
A. 使用赋值和取值方法访问属性
B. 编写常规方法访问属性
C. 在赋值和取值方法中，加入对属性的存取限制
D. 编写main方法创建对象，调用赋值和取值方法访问属性
30. 在Java中，以下程序编译运行后的输出结果为（ ）。
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
31.给定一个Java程序Test.java的代码如下所示，编译时，会出现以下（ ）情况。
class Parent {
public int count() { // 第1行
return 0;
}
}
public class Test extends Parent {
private int i;
public int count() { // 第2行
return i % 9; // 第3行
}
}
A. 编译通过
B. 在第1行引发编译错误
C. 在第2行引发编译错误
D. 在第3行引发编译错误
32.给定如下一个Java源文件Child.java，编译并运行Child.java，以下结果正确的是（ ）。
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
33. 分析如下所示的Java代码，则选项中的说法正确的是（ ）。
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. 程序编译通过，无错误
34. 下面关于Java接口的说法错误的是（ ）。
A. 一个Java接口是一些方法特征的集合，但没有方法的实现
B. Java接口中定义的方法在不同的地方被实现，可以具有完全不同的行为
C. Java接口中可以声明私有成员
D. Java接口不能被实例化
35. 在Java接口中定义常量，下面语法错误的是（ ）。
A. static int MALE = 1;
B. final int MALE = 1;
C. int MALE = 1;
D. private int MALE = 1;
36. 关于下列代码说法正确的是：（）。
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异常
37、请看下列代码
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;
38、程序输出的结果是 （）。
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
39、下面代码运行结果是： （）
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.抛出运行时异常
40、下面代码运行结果是： （）
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
**41、请看下列代码： **
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()
42、程序执行的结果是：（）
package com.rl;
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
43、程序运行结果 （）
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.子类无参构造函数 子类有参构造函数 父类无参构造函数
44.下列代码的运行结果是： （）
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
45. 下列关于修饰符混用的说法，错误的是（）
A. abstract不能与final并列修饰同一个类
B. abstract类中不可以有private的成员
C. abstract方法必须在abstract类中
D. static方法中能处理非static的属性