本篇还有3篇相关文章->
2023年11月15号期中测验判断题（Java）-CSDN博客
单选题-> A B C D
2-1
以下程序运行结果是
public class Test extends Father{
private String name="test";
public static void main(String[] args){
Test test = new Test();
System.out.println(test.getName());
}
}
class Father{
private String name="father";
public String getName() {
return name;
}
}
A. father
B. 编译出错
C. test
D. 运行出错，无输出
正确答案：A
解释：
本题主要考查继承的重写（override）知识点，详见此篇标题五->Java继承(extends)上-CSDN博客
其中，Father是父类，Test继承Father，也就继承了其中的getName方法，但是继承后并未重写该方法，因此用Test类示例化的对象调用getName方法时本质上调用的是未重写的Father类中的方法，也就获取到Father类中的name变量的值，即"father"。
2-2
If a method defined in a derived class has the same name, return type and parameters with the base one, we call this situation as: (____)
A. overload
B. override
C. inheritance
D. construction
正确答案：B
解释：
题目翻译->如果在派生类（即子类）中定义的方法与基类（即父类）具有相同的名称、返回类型和参数，我们将这种情况称为：
A->重载，B->重写，C->继承，D->构造
显然正确答案是B
2-3
如下代码的输出是（ ）。
public class Test {
public static void main(String[] args) {
new Person().printPerson();
new Student().printPerson();
}
}
class Student extends Person {
private String getInfo() {
return "Student";
}
}
class Person {
private String getInfo() {
return "Person";
}
public void printPerson() {
System.out.println(getInfo());
}
}
A. Person Person
B. Person Student
C. Stduent Student
D. Student Person
正确答案：A
解释：
本题和本篇第一题的意思一样，Student类继承了Person类但未对其中的printPerson方法进行重写操作，因此子类实例化的对象调用的printPerson方法本质上是Person这个父类里的方法。
另外主类的main方法中涉及到匿名对象的知识点，即不声明（定义）对象而直接用new 类名()的方法创建一个匿名对象，这样的对象只能使用一次，除此之外和正常声明的对象没有其它区别。
2-4
设类B是类C的父类，下列声明对象x1的语句中不正确的是?
A. B x1 = new B( );
B. B x1 = new C( );
C. C x1 = new C( );
D. C x1 = new B( );
正确答案：D
解释：
本题的A，C选项可直接排除，
除非你面向对象零基础。。。对于B选项，其格式->父类类型 上转型对象 = new 子类类型();符合对象向上转型的语法。
对于D选项，其格式属于语法错误，即便写成子类类型A 子类对象 = (子类类型A)new 父类类型();也是错误，因为右边new出来的对象没有经过向上转型，不要错误认为是对象向下转型，对象向下转型必须先经过对象向上转型！
详细知识点可移步本篇标题④、⑤学习->Java多态-CSDN博客
2-5
如下在一个Java抽象类中对抽象方法的声明哪个是正确的？
A. public abstract method();
B. public abstract void method();
C. public void abstract method();
D. public abstract void method() {}
正确答案：B
解释：
本题两个关键点，
①abstract必须写在void前面，由此排除选项C。
②抽象方法不允许有方法体，即便花括号里面没有任何代码！由此排除选项D。
对于选项A，没有声明方法的类型，肯定错误。
口说无凭，以图为证——
2-6
有如下程序代码，程序执行的结果是：（ ）。
class Base {
static void test() {
System.out.println("Base.test()");
}
}
class Child extends Base {
static void test() {
System.out.println("Child.test()");
Base.test(); // Call the parent method
}
}
public class Main {
public static void main(String[] a) {
Child.test();
}
}
A.
Child.test() Base.test()B.
Base.test() Base.test()C.
Base.test() Child.test()D.
Runtime error. Cannot override a static method by an instance method
正确答案：A
解释：
本题主要考察静态成员方法如何调用（应该是。。。）
类的静态成员方法在堆区中的地址是唯一的，也就是说不管实例化多少对象，这些对象的某个静态方法都指向堆区同一块地址，因此允许直接用类名去调用静态成员方法。
有关静态成员方法详细见本篇->详解Java中静态方法_java中静态的方法案里-CSDN博客
2-7
有如下程序代码，执行的结果是（ ）。
class Father {
int a = 100;
int b = 200;
public void print() {
System.out.println(a + " " + b);
}
}
class Child extends Father {
int b = 300;
int c = 400;
public void print() {
System.out.println(a + " " + b + " " + c);
}
public void printExtend() {
System.out.println(c);
}
}
public class Main {
public static void main(String[] a) {
Father obj = new Child();
System.out.println(obj.a + " " + obj.b);
obj.print();
}
}
A.
100 200 100 200 400B.
100 300 100 300 400C.
100 300 100 200 400D.
100 200 100 300 400
正确答案：D
解释：
本题与本篇2-1和2-3考察点相同，均为对象向上转型知识点。
Father obj = new Child();满足语法格式->父类类型 上转型对象 = new 子类类型();
对于向上转型的对象，调用的成员变量一定是父类中的，调用的成员方法优先用子类继承父类并重写后的（如果子类没重写，本质上就是调用父类原有的），特别的，子类中独有的（即不是从父类继承过来的）方法，不允许调用！
- 自编顺口溜(*^_^*)->"变量只用老子的，方法先看儿子的，儿子独有的不用"
理解这个知识点后，再看题目就透彻了——
System.out.println(obj.a + " " + obj.b);obj是向上转型对象，调用的成员变量a和b一定是父类里面的，即100和200；
obj.print();obj是向上转型对象，调用的成员方法优先看子类的，由于child子类有重写print这个方法，所以就是调用child类的print方法，在子类的print方法中，System.out.println(a + " " + b + " " + c);这句代码，访问到的a是父类继承过来的，访问到的b，c是子类重写后的，分别是100，300，400.
对象向上转型知识点详细见本篇标题④->Java多态-CSDN博客
2-8
有如下代码，程序执行结果是：（ ）。
abstract class Person {
public abstract void eat();
}
public class Main {
public static void main(String[] a) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
A. 空字符串
B. 编译错误
C. eat something
D. 运行错误
正确答案：C
解释：
main方法中，这是Java的匿名内部类的语法。
创建了一个继承Person类的匿名内部类，并重写了eat()方法。然后我们将这个匿名内部类的实例赋值给了一个Person类型的变量p。最后调用p的eat()方法，输出"eat something"。
有关匿名内部类知识点详见本篇标题二的子标题④->Java内部类-CSDN博客
2-9
父类的引用指向自己子类的对象是（）的一种体现形式。
A. 封装
B. 继承
C. 多态
正确答案：C
解释：
前面好几题都涉及这玩意了，再解释一遍吧——
- 父类类型 上转型对象 = new 子类类型();
左边是父类的引用，右边实例化的是子类的对象
这个语法是对象向上转型，是面向对象程序中多态的典型体现。
详见本篇标题④->Java多态-CSDN博客
2-10
请问以下哪个程序代码体现了对象之间的 IS-A关系？
A.
public interface Color { } public class Shape { private Color color; }B.
interface Component { } public class Container implments Component { private Component[] children; }C.
public class Species { } public class Animal { private Species species; }
正确答案：B
解释：
Is-A：“表示类与类之间的继承关系、接口与接口之间的继承的关系以及类对接口实现的关系”。
根据题目给出的代码，显然只有B选项中，Container类实现了Component这个接口。
拓展内容——
Is-A，Has-A，Use-A则是用来描述类与类之间关系的。简单的说Is-A代表继承，Has-A代表合成，Use-A代表依赖。
详见本篇->https://blog.csdn.net/liKeQing1027520/article/details/134472962
2-11
给出以下Java程序代码，请问运行结果是（）？
interface Base {
int k = 0;
}
public class Test implements Base {
public static void main(String[] args){
int i;
Test obj = new Test();
i = obj.k;
i = Test.k;
i = Base.k;
System.out.println(i);
}
}A. 无内容输出。
B. 代码编译失败。
C. 代码输出0
D. 代码输出1
正确答案：C
解释：
看到这题就来气，原题中static漏了第二个t，String漏了g，导致我秒选B，也是本篇我唯一错的一题了(╯▔皿▔)╯。Test类实现了Base这个接口，因此Test类也拥有k（被赋初始值0）这个成员变量，然后用Test类实例化了对象obj，接着对整型变量i进行了三次赋值操作，分别是——
i = obj.k;// i = Test.k; i = Base.k;第一行是最好理解的，直接用实例化对象obj访问
第二行和第三行，为什么可以分别用类名和接口名访问成员变量k？
原因在于，接口中的变量，默认是被public static final修饰的，是不是瞬间大彻大悟了，静态变量当然可以用类名和接口名直接访问咯。
有关接口的其它知识点详见本篇，本题知识点直接见标题③->Java继承(extends)下-CSDN博客
2-12
可以用于在子类中调用被重写父类方法的关键字是()
A. this
B. implements
C. extends
D. super
正确答案：D
解释：
突然来这么一道简单题还挺惊喜（bushi）super关键字有两个主要作用，
①在子类的构造方法中，调用父类的构造方法，语法格式为super(参数列表)，且必须写在首行！
详见本篇标题六的子标题②->Java继承(extends)上-CSDN博客
②在子类中调用被重写的父类方法，语法格式为super().方法名()，没有要求必须写在第一行！
对于A选项，this可以用来特别声明引用为该类对象的成员，this()还可以用来在同一个类中的A构造方法里调用B构造方法（严格注意区分super()）！
对于B选项，implements是实现接口的关键字；
对于C选项，extends是类继承父类，或接口继承接口（接口无法继承类）的关键字。
代码示例：
public class Main {
public static void main(String[] args) {
}
}
class Parent {
int age;
String name;
Parent() {//父类的无参构造
}
Parent(int age, String name) {//父类的有参构造
}
void parent_test() {
System.out.println("这是父类的方法");
}
}
class Child extends Parent {
Child() {//子类的无参构造
super();//super关键字调用父类无参构造，必须写在第一行！
}
Child(int age, String name) {
super(age, name);//super关键字调用父类有参构造，必须写在第一行！
}
void parent_test() {//重写父类的parent_test方法
super.parent_test();//这个不要求必须写在第一行
}
}2-13
Java中（ ） 。
A. 一个子类可以有多个父类，一个父类也可以有多个子类
B. 一个子类可以有多个父类，但一个父类只可以有一个子类
C. 一个子类可以有一个父类，但一个父类可以有多个子类
D. 上述说法都不对
正确答案：C
解释：
A，B选项：一个子类只能有一个父类，一个父类可以被多个子类继承
详解本篇->Java继承(extends)上-CSDN博客
2-14
将以下哪种方法插入行3是不合法的。
public class Test1{
public float aMethod（float a，float b）{ }
}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
解释：
本题考察方法重载的知识点。
抓住重载要求的两个关键点->
- 方法类型必须相同
- 方法的参数列表必须不同（不同类型的参数顺序不同也是符合要求的！）
选项A：类型相同，与已有方法相比，参数列表多了float c,符合重载；
选项B：类型相同，但参数列表和已有方法完全一致（不要被变量名骗了！），不符合重载的条件②；
选项C：类型相同，且参数列表是int a， int b，与已有方法不同，符合重载；
选项D：类型相同，且参数列表是int a， int b，int c，与已有方法不同，符合重载；
2-15
若A1、A2为已定义的接口 ,以下接口定义中没有语法错误的是（ ） 。
A. interface B { void print() { } }
B. abstract interface B { void print() }
C. abstract interface B extends A1,A2 { abstract void print(){ };}
D. interface B { void print();}
正确答案：D
解释：
选项A：接口中的方法默认是public abstract修饰的，也就是说->接口中的方法默认是抽象方法，抽象方法不允许有方法体（花括号里什么代码都没有也不行！本篇2-5是同类型题目）；
选项B：就 void print() 后面漏了个分号；
选项C：和选项A错一样；
2-16
以下关于继承的叙述正确的是（ ）。
A. 在Java中类只允许单一继承
B. 在Java中一个类只能实现一个接口
C. 在Java中一个类不能同时继承一个类和实现一个接口
D. 在Java中接口只允许单一继承
正确答案：A
解释：
选项A，很正确的说法，一个类就是只能继承一个父类（理解为儿子只能有一个亲爹）！
选项B，错误，一个类可以实现多个接口（理解为徒弟可以拜多个师父）；
选项C，类可以同时继承类和实现接口，且需要注意必须先继承（extends）后实现（implements）!
选项D，接口可以继承多个接口。
示例代码：
2-17
下面说法不正确的是( )
A. 一个子类的对象可以接收父类对象能接收的消息；
B. 当子类对象和父类对象能接收同样的消息时，它们针对消息产生的行为可能不同；
C. 父类比它的子类的方法更多；
D. 子类在构造函数中可以使用super( )来调用父类的构造函数；
正确答案：C
解释：
选项A：子类继承（extends）父类，因此拥有父类的所有属性（包括成员变量和成员方法），自然父类对象能接收的，子类对象也能接收，故正确；
选项B：因为子类可能存在对父类的成员变量或成员方法进行重写的行为，重写过后，子类的对象产生的行为也就和父类对象不同了，故正确；
选项C：子类拥有父类的所有属性，还可以在此基础上衍生自己的方法，所以子类方法一定多于父类方法，故错误；
选项D：正确，详见本篇标题六的子标题②->Java继承(extends)上-CSDN博客
2-18
下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child("mike")的时候都有哪些构造方法被顺序调用？请选择输出结果 ( )
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);
}
}A. 312
B. 32
C. 432
D. 132
正确答案：D
解释：
执行new Child("mike");时，
①调用Child类的有参构造方法，一定会执行一个隐式的super()（详见本篇标题六的子标题②->Java继承(extends)上-CSDN博客），而且这个super()一定在Child有参构造的第一行执行，也就是调用了父类的无参构造，打印了整数1
②正常执行Child有参构造方法中的语句，打印了整数3
③new People(name + ":F");这行代码调用了People这个父类的有参构造，打印了整数2
故答案为132
2-19
下面哪个对类的声明是错误的？
A. class MyClass extends MySuperClass1, MySupperClass2 {}
B. public class MyClass{}
C. abstract class MyClass implements YourInterface1, Youriterface2 {}
D. private class MyClass {}
E. class MyClass extends MySuperClass implements YourInterface {}
正确答案：A
解释：
只有A是错误的，因为一个类只能继承一个父类！
选项B：定义了一个public权限MyClass类；
选项C：定义了一个MyClass抽象类并实现两个接口（类允许实现多个接口）；
选项D：定义了一个private权限MyClass类；
选项E：定义了一个MyClass类，继承MySuperClass这个父类并实现YourInterface这个接口（类是允许先继承后实现的，先实现后继承就是语法错误了）。
2-20
在Java中，能实现多重继承效果的方式是（ ）。
A. 接口
B. 继承
C. 内部类
D. 适配器
正确答案：A
解释：
只有接口能继承多个接口（接口不能继承类），从而实现多继承效果。
2-21
下列选项中，用于定义接口的关键字是（ ）。
A. interface
B. implements
C. abstract
D. class
正确答案：A
解释：
送分题。
2-22
对于下列代码:
class Parent {
public int addValue( int a, int b) {
int s;
s = a+b;
return s;
}
}
class Child extends Parent { }
下述哪个方法可以加入类Child?
A. int addValue( int a,int b ){// do something...}
B. public void addValue (int a,int b ){// do something...}
C. public int addValue( int a ){// do something...}
D. public int addValue( int a,int b )throws MyException {//do something...}
正确答案：C
解释：
在Java中，子类可以重写父类的方法，但是必须满足以下条件：
- 方法名、参数列表必须与父类方法完全相同。
- 返回类型必须与父类方法相同或者是其子类。
- 访问权限不能比父类方法更严格（例如，如果父类方法是public，那么子类重写的方法也必须是public）。
选项A：父类中的addValue方法是public修饰的，在子类中重写这个方法时也必须用public修饰；
选项B：子类重写父类方法，方法类型必须一致，这里的修改方法有两个方法，可以把void改成int，即重写父类中的addValue方法，还可以把这个方法名改掉，作为子类里独有的方法；
选项C：从这段代码来看，子类的addValue方法只接收一个参数
a，这与父类的addValue方法完全不同，因此它不能被视为重写（override），方法名相同，但由于参数不同，这两个方法被视为重载（overloaded）关系。选项D：这里我也挺懵的不太懂题目的意思，测试后感觉应该是要求父类中的addValue也必须抛出异常，即在父类的addValue参数列表后面加上throws MyException，下面有代码示例。有关异常类的知识点详见本篇->Java异常-CSDN博客
class Parent {
public int addValue(int a, int b) throws MyException {
int s;
s = a + b;
return s;
}
}
class Child extends Parent {
public int addValue(int a, int b) throws MyException {
if (a < 0) {
throw new MyException("a是负数");
}
int res = a / b;
return res;
}
}
class MyException extends Exception {//自定义异常子类继承Exception类
public MyException() {
super(); // 调用Exception无参的构造方法
}
public MyException(String message) {
super(message); // 调用Exception有参的构造方法
}
}
782
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
