Java基础选择题——1

1、引用数据类型变量具有基本属性为（ABCD）

A、变量名

B、数据类型

C、存储单元

D、变量值。

2、面向对象技术的特性是（ACD）

A、继承性

B、有效性

C、多态性

D、封装性。

3、下列哪个命题为真？（C）

A、所有类都必须定义一个构造函数。

B、构造函数必须有返回值。

C、构造函数可以访问类的非静态成员。

D、构造函数必须初始化类的所有数据成员。

因此，正确答案是 C。

A、 - 这个命题是不正确的，因为编译器会为没有显式定义构造函数的类提供一个默认的构造函数。

B、 - 这个命题也是不正确的，因为构造函数没有返回值，也不能用void修饰（它们也不是void类型）。

C、这个命题是正确的，因为构造函数在对象被创建时调用，用于初始化对象的状态，因此它可以访问类的非静态成员。

（

类的成员可以分为两种：静态成员（static members）和非静态成员（non-static members，也叫实例成员）。

静态成员：属于类本身，而不是类的任何特定实例。静态成员变量在类的所有实例之间共享相同的值，静态方法则可以通过类名直接调用，而无需创建类的实例。
非静态成员（或实例成员）：属于类的每个单独实例。每个对象都有其自己的非静态成员变量的副本，并且非静态方法必须通过类的实例（即对象）来调用。
构造函数是用来初始化对象的非静态成员的。因为构造函数在创建对象时被调用，并且它的主要目的是设置对象的状态（即初始化其非静态成员），所以构造函数当然可以访问并设置类的非静态成员。

）

D、构造函数必须初始化类的所有数据成员。 - 这个命题不完全正确，因为虽然构造函数通常用于初始化类的成员，但编译器会确保基本数据类型的成员被赋予默认值（如果它们没有被显式初始化），而引用类型的成员会被初始化为null。

4、关于子类与父类关系的描述正确的是（ACD）

A、子类型的数据可以隐式转换为其父类型的数据；

B、父类型的数据可以隐式转换为其子类型的数据；

C、父类型的数据必须通过显示类型转换为其子类型的数据；

D、子类型实例也是父类型的实例对象。

A、子类型的数据可以隐式转换为其父类型的数据；
这是正确的。在面向对象的编程中，一个子类对象可以被视为其父类对象（通常称为向上转型或向上转型）。这是因为子类继承了父类的所有属性和方法，所以它可以被安全地视为父类的一个实例。这种转换通常是隐式的，不需要特别的类型转换操作。

B、父类型的数据可以隐式转换为其子类型的数据；
这是不正确的。父类对象通常不能直接被隐式转换为子类对象，因为子类可能包含父类所没有的额外属性和方法。如果尝试将一个父类对象隐式转换为子类对象，可能会丢失数据或引发错误。

C、父类型的数据必须通过显示类型转换为其子类型的数据；
这是正确的，但通常我们称之为向下转型或显式转换。由于子类可能包含父类所没有的额外属性和方法，所以这种转换不是自动的，必须明确进行，以确保类型转换是安全且合法的。这通常通过类型检查或类型断言来完成。

D、子类型实例也是父类型的实例对象；
这也是正确的。子类实例是父类的一个特殊实例，因为它继承了父类的所有属性和方法。因此，任何适用于父类实例的操作也适用于子类实例（除非子类覆盖了父类的方法）。

综上所述，正确的选项是A、C和D。

5、下列哪一项说法最好地描述了Java中的对象？（C）

A、对象是通过import命令引入到程序中的所有事情

B、对象是方法的集合，这些方法在小程序窗口或应用程序窗口中产生图形元素，或者计算和返回值

C、对象是一种数据结构，它具有操作数据的方法

D、对象是一组具有共同的结构和行为的类

A、
这个描述是不准确的。import命令用于导入Java包中的类和其他类型，但它并不直接引入对象。对象是根据类（class）创建的实例（instance）。

B、
这个描述虽然部分正确（对象确实包含方法），但它过于具体且不完全准确。对象不仅包含方法，还包含状态（即数据）。此外，它描述的更像是GUI编程中的组件，而不是Java中对象的普遍定义。

C、
这个描述准确地反映了Java中对象的本质。对象确实是一种数据结构（通常包含字段，用于存储数据），并且它还包含方法（即操作这些数据的函数）。

D、
这个描述混淆了对象和类的概念。类（class）是一组具有共同的结构和行为的对象的模板或蓝图。对象是类的实例。

因此，正确答案是C：对象是一种数据结构，它具有操作数据的方法。

6、下面哪个关键字不是用来控制对类成员的访问的？（C）

A、public

B、protected

C、default

D、private

答案是C，因为default在Java中并不是一个用于控制访问权限的关键字。

7、Java语言正确的常量修饰符应该是（D）

A、final

B、static final

C、static

D、public static final；

8、接口的所有成员域都具有public、static和final属性。

9、接口的所有成员方法都具有public和abstract属性。

10、编译下列源程序会得到哪些文件?（C）

class A1{

}

class A2{

}

public class B{

public static void main(String args[]){

}

}

A)只有B.class

B）只有A1.class和A2.class文件

C）有A1.class、A2.class和B.class文件

D)编译不成功

当你编译包含多个类的Java源文件时，编译器会为每个类生成一个.class文件（除非该类是嵌套的或内部的，并且没有被单独声明为静态的）。在这个例子中，你有三个类定义：A1、A2和B。

A1 和 A2 是普通的类定义，它们没有嵌套在任何其他类中，所以它们各自都会生成一个.class文件。
B 是一个公共类，并且它包含了main方法，这是Java应用程序的入口点。它也会生成一个.class文件。

因此，当你编译这个源文件时，会生成三个.class文件：A1.class、A2.class和B.class。

答案是C）有A1.class、A2.class和B.class文件。

D选项“编译不成功”是不正确的，因为源文件本身在语法上是正确的，并且没有理由导致编译失败（除非存在外部因素，如编译器错误或文件系统问题）。

11、下列哪种说法是正确的？（A）

A、私有方法不能被子类覆盖。

B、子类可以覆盖超类中的任何方法。

C、覆盖方法可以声明自己抛出的异常多于那个被覆盖的方法。

D、覆盖方法中的参数清单必须是被覆盖方法参数清单的子集。

让我们来分析这些选项：

A、。
这个说法是正确的。在Java中，私有方法（使用private修饰符定义的方法）是隐式的final的，这意味着它们不能被覆盖（即重写）。私有方法仅在其定义它们的类中可见，并且子类无法访问或覆盖它们。

B、
这个说法是不正确的。子类不能覆盖超类中的私有方法（因为私有方法不可见），也不能覆盖超类中的final方法（因为final方法不能被重写）。子类只能覆盖那些非私有、非final、非静态的方法。

C、
这个说法也是不正确的。根据Java的覆盖规则（也称为重写规则），覆盖方法（儿子）不能抛出比被覆盖方法（父亲）更广泛的检查型异常（checked exceptions）。覆盖方法可以抛出与被覆盖方法相同的异常，或者不抛出任何异常，或者抛出被覆盖方法异常列表中的异常的子类。但是，它不能抛出新的、未被被覆盖方法声明的检查型异常。

（子类的权限大于等于父类，子类抛出的异常小于等于父类，子父类方法名和参数列表相同）

D、
这个说法也是不正确的。覆盖方法（重写方法）的参数列表必须与被覆盖方法的参数列表完全相同，包括参数的类型、顺序和数量。

因此，正确答案是A。

12、关于类继承的说法，正确的是（B）。

A、Java类允许多重继承

B、Java接口允许多继承

C、接口和类都允许多继承

D、接口和类都不允许多继承

在Java中，类不支持多重继承，即一个类不能直接继承多个父类。但是，Java提供了接口（interface）作为多重继承的一种替代方案，允许一个类实现多个接口。
类不允许多重继承，但接口是允许多重继承的。

13、使用以下哪个保留字可以使只有在定义该类的包中的其他类才能访问该类？（D）

A）abstract

B）private

C）protected

D）不使用保留字

A）abstract - abstract是一个修饰符，用于声明一个类或者方法是抽象的。它并不控制类的访问级别。

B）private - private是一个访问修饰符，但它只能用于类的成员（变量、方法、内部类），不能用于类本身。

C）protected - protected也是一个访问修饰符，它可以用于类的成员，表示这个成员可以在同一个包中的类或者在其他包中的子类中被访问。但它同样不能用于类本身。

D）不使用保留字 - 在Java中，如果一个类没有使用任何访问修饰符（public, private, protected），那么它默认是包私有的（package-private）。这意味着该类只能在其定义的包内被其他类访问。

14、为了区分重载多态中同名的不同方法，要求(A)。

A.采用不同的参数列表

B.返回值类型不同

C.调用时用类名或对象名做前缀

D.参数名不同

15、下述概念中不属于面向对象方法的是（D）。

A．对象、消息

B．继承、多态

C．类、封装

D．过程调用

过程调用（或函数调用）是许多编程范式（包括面向过程编程）中的基本概念，但它不是面向对象编程所特有的。在面向过程编程中，程序被组织为一组函数的集合，这些函数通过参数和返回值进行通信。

16、下列关于构造方法的叙述中，错误的是（C）

A．Java语言规定构造方法名与类名必须相同

B．Java语言规定构造方法没有返回值，但不用void声明

C．Java语言规定构造方法不可以重载

（C． 这是错误的。在Java中，构造方法是可以重载的。这意味着一个类可以有多个构造方法，只要它们的参数列表不同（参数类型、数量或顺序）。）

D．Java语言规定构造方法只能通过new自动调用

（D．Java语言规定构造方法只能通过new自动调用 - 这是正确的。构造方法是在使用new关键字创建对象时自动调用的，你不能直接调用一个构造方法（除非在另一个构造方法中使用this()）。）

17、如果str表示一个String对象“73”，那么以下哪些表达式将会把这个字符串转换为int 值73？请选出正确答案。（C）

A）Integer.getInt(str)      //这个方法并不存在。Java的Integer类中没有getInt方法。

B）((int)str)                  //这是尝试进行类型强制转换，但Java中字符串不能直接转换为整数类型。这会引发编译错误。

C）(new Integer(str)).intValue()

//new Integer(str)会创建一个新的Integer对象，其值等于字符串str所表示的整数。然后，intValue()方法会返回这个Integer对象的原始int值。但是，请注意，从Java 9开始，Integer类中的Integer(String s)构造函数已被标记为已弃用，建议使用Integer.parseInt(String s)代替

D）Integer.intValue(str)    // 这个方法也不存在。Integer类没有静态的intValue方法，它只有实例方法intValue()。

更常见的写法是：

int num = Integer.parseInt(str);
 

18、下列哪个类的声明是正确的？（D）

A．abstract final class HI{}  //

B．abstract private move(){}

C．protected private number;

D．public abstract class Car{}

A．abstract final class HI{} - 这是错误的。abstract类意味着这个类不能被实例化，只能被继承。而final类则不能被继承。这两个修饰符是互斥的，因此不能同时用于一个类。

B．abstract private move(){} - 这是错误的。abstract方法是没有方法体的，它只能声明在abstract类或接口中。而private方法只能在当前类中被访问，这意味着子类无法覆盖（override）它，因此private方法不能是abstract的。

C．protected private number; - 这是错误的。Java中的访问修饰符（如public、protected、private）不能同时用于一个成员变量或方法。你只能选择其中一个。

D．public abstract class Car{} - 这是正确的。public意味着这个类可以被任何其他类访问，而abstract则意味着这个类不能被实例化，只能被继承。

因此，正确的选项是D。

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

A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类

B．可以被两种类访问和引用：该类本身、该类的所有子类

C．只能被该类自身所访问和修改

D．只能被同一个包中的类访问

20、在Java中，关于final关键字的说法正确的是（AD）。应该A C

A、如果修饰变量，则一旦赋了值，就等同一个常量。

B、如果修饰类，则该类只能被一个子类继承。

C、如果修饰方法，则该方法不能在子类中被覆盖。

D、如果修饰方法，则该方法所在的类不能被继承。

关于Java中final关键字的说法，让我们再次确认一下：

A、

这是正确的。final变量（无论是基本数据类型还是引用类型）在初始化后就不能再被修改。对于基本数据类型，这意味着值不能变；对于引用类型，这意味着引用本身（即它指向的地址）不能变，但对象的内容仍然可以变（除非对象本身是不可变的）。

B、

这是错误的。实际上，如果一个类被声明为final，那么它不能被任何类继承。

C、

这是正确的。final方法不能被重写（即子类不能提供一个具有相同名称、参数列表和返回类型的方法）。

D、

这是错误的。final修饰的是方法，而不是类。一个类能否被继承取决于类本身是否被声明为final。

所以，关于final关键字正确的说法是A和C。\

21、在Java中，下面关于包的陈述中正确的是（AD）。

A、包的声明必须是源文件的第一句代码。

B、包的声明必须紧跟在import语句的后面。

C、只有公共类才能放在包中。

D、可以将多个源文件中的类放在同一个包中。

A、

这是正确的。在Java源文件中，包声明（如果有的话）必须位于所有import语句和类定义之前。

B、

这是错误的。如A所述，包声明必须位于所有import语句之前。

C、

这是错误的。任何类（公共的、默认的、受保护的或私有的）都可以放在包中。但是，如果一个类没有指定任何访问修饰符（即默认访问修饰符），并且它位于包内，那么只有同一包中的其他类才能访问它。公共类（用public修饰的类）可以从任何其他包中访问。

D、

这是正确的。多个源文件（即.java文件）中的类可以属于同一个包，只要每个源文件都有正确的包声明。

因此，正确的选项是A和D。

22、下面有关私有变量和私有方法的声明，哪些叙述是对的？（AD）

A、用关键字private修饰的成员变量和方法，称为私有变量和私有方法。

B、用关键字protected修饰的成员变量和方法，称为私有变量和私有方法。

C、用关键字public修饰的成员变量和方法，称为私有变量和私有方法。

D、私有变量不能通过对象直接访问，只有在本类中创建的自己对象，才能访问自己的私有变量。

(//这个选项的核心意思是正确的：私有变量不能从类的外部直接访问。)

23、下面有关变量及其作用域的陈述哪些是对的？（ABC）

A、在方法里面定义的局部变量在方法退出的时候被撤销。

B、局部变量只在定义它的方法内有效。

C、在方法外面定义的变量（即实例变量）在对象被构造时创建。

D、在方法中定义的方法的参变量只要该对象被需要就一直存在。

A、

这是正确的。局部变量是在方法被调用时创建的，并在方法执行完成后（无论是正常返回还是抛出异常）被撤销（即它们不再占用内存空间）。

B、

这是正确的。局部变量的作用域仅限于声明它的代码块（例如方法或循环体），并且它们只能在该代码块内被访问。

C、

这是正确的。实例变量（也称为成员变量）是在对象被创建（即调用其构造函数）时初始化的。这些变量属于对象的实例，并在整个对象的生命周期内都存在。

D、。

这是错误的。方法的参数不是对象的状态（即它们不是实例变量），而是局部变量。它们只在方法执行期间存在，并在方法退出时被撤销。对象的状态由实例变量表示，这些变量在对象被构造时创建，并在对象被垃圾回收之前都存在。

因此，正确的选项是A、B和C。

24、下面关于继承的叙述哪些是正确的？（AD）

A、在java中只允许单一继承。

B、在java中一个类只能实现一个接口。

C、在java中一个类不能同时继承一个类和实现一个接口。

D、java的单一继承使代码更可靠。

A、

这是正确的。Java不支持多重继承（即一个类继承自多个父类），但允许单一继承（一个类继承自一个父类）。

B、

这是错误的。Java中一个类可以实现多个接口，只需在类声明中使用implements关键字并列出所有要实现的接口即可。

C、

这是错误的。Java中一个类可以同时继承一个类（作为其父类）并实现一个或多个接口。

D、

这通常被认为是正确的。虽然单一继承在某些情况下可能限制了代码的灵活性，但它也减少了由于多重继承可能导致的复杂性（如钻石问题），从而提高了代码的可读性和可维护性。

因此，正确的选项是A和D。

25、以下声明合法的是（B）

A．default String s；

B．public final static native int w()

C．abstract double d；

D．abstract final double hyperbolicCosine()

在分析这些声明时，我们需要根据Java的语法规则来判断哪些是合法的。

A．default String s；
这是不合法的。在Java中，default是一个访问修饰符，但它只能用于接口中的方法，而不能用于类变量或实例变量的声明。

B．public final static native int w()
这是合法的。这个声明定义了一个公共的（public）、静态的（static）、最终的（final）且本地方法（native）w，该方法返回一个整型（int）。虽然final通常与不可覆盖的方法（非本地方法）一起使用，但在声明本地方法时，它是允许的，尽管这样做没有实际意义，因为本地方法总是由本地代码（如C/C++代码）实现，不会被Java代码覆盖。

C．abstract double d；
这是不合法的。abstract修饰符只能用于类（表示该类是抽象的）或方法（表示该方法没有实现体，需要在子类中提供具体实现），不能用于变量。

D．abstract final double hyperbolicCosine()
这是不合法的。abstract和final修饰符在方法声明中是互斥的。abstract表示该方法没有实现体，而final表示该方法不能被覆盖（即子类不能提供该方法的另一个实现）。一个方法不能同时是抽象的（没有实现体）和最终的（不能被覆盖）。

因此，正确答案是B。

26、类Test1定义如下：

1．public class Test1{

2．public float aMethod（float a，float b）{}

3．

4．}

将以下哪种方法插入行3是不合法的。（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）{}

在Java中，一个类不能有两个签名完全相同的方法（即方法名相同且参数列表也相同，包括参数的类型和顺序）。现在我们来分析每个选项：

A、public float aMethod（float a，float b，float c）{}
这是合法的，因为它是一个新的方法，参数列表与Test1类中已存在的方法aMethod(float a, float b)不同，因为多了第三个参数float c。

B、public float aMethod（float c，float d）{}
这是不合法的，因为它与已存在的aMethod(float a, float b)方法在同一个类中，但参数列表不同（尽管都是两个float类型的参数，但参数名不同并不影响方法的签名）。Java不允许在同一个类中有两个方法名相同但参数列表不同的重载方法（这被称为方法重载，但重载要求参数列表必须不同）。

C、public int aMethod（int a，int b）{}
这是合法的，因为它是一个新的方法，尽管方法名相同，但参数列表的类型和返回类型都不同，这符合Java的方法重载规则。

D、private float aMethod（int a，int b，int c）{}
这也是合法的，因为它是一个私有方法（private），这意味着它只能被当前类访问，并且它的参数列表与已存在的方法不同。

因此，不合法的选项是B。

27、下面是Example.java文件的完整代码，请找出会产生编译错误的行（C）。

1)class BaseClass{

2)public String str;

3)public BaseClass（）{

4)System.out.println(“ok”);}

5)public BaseClass(String s){

6)str=s;}}

7)class SubClass extends BaseClass{

8)}

9)public class Example{

10)public void method（）{

11)SubClass s=new SubClass(“hello”);  

//这里尝试使用带参数的构造函数来实例化SubClass对象，但是SubClass并没有定义这样的构造函数。因此，尝试调用new SubClass("hello")会导致编译错误，因为SubClass没有接受String参数的构造函数。

12)BaseClass b=new BaseClass(“world”);

13)}

14)}

A、7

B、10

C、11

D、12

28、下面关于类的说法错误的是（B）。

A、类是Java语言中的一种复合数据类型。

B、Java语言的类支持单继承和多继承。

C、类是对所有具有一定共性的对象的抽象。

D、类中包含数据变量和方法。

29、下列关于变量的叙述哪个是错的？（C）

A、实例变量是类的成员变量。

B、在方法中定义的局部变量在该方法被执行时创建。//

局部变量是定义在方法、构造器或块内部的变量。当方法或构造器被调用时，它们会被创建，并且在方法或构造器执行完毕后（或在其作用域结束后）被销毁。

C、实例变量用关键字static声明。

(C、实例变量用关键字static声明。
这是错误的。实例变量不是用static关键字声明的。相反，static关键字用于声明类变量（也称为静态变量）。静态变量属于类本身，而不是类的实例（对象）。实例变量和静态变量在内存中的存储方式和生命周期都是不同的。)

D、局部变量在使用前必须被初始化。

(D、局部变量在使用前必须被初始化。
这是正确的。局部变量在使用前必须被明确初始化，否则编译器会报错。这是因为局部变量没有默认值，而且它们的生命周期只存在于方法或构造器的执行期间。)

30、已知A类被打包在packageA,B类被打包在packageB，且B类被声明为public，且有一个成员变量x被声明为protected控制方式。C类也位于packageA包，且继承了B类。则以下说法正确的是（C）。????

A、A类的实例不能访问到B类的实例

B、A类的实例能够访问到B类一个实例的x成员

C、C类的实例可以访问到B类一个实例的x成员

D、C类的实例不能访问到B类的实例

protected 成员变量或方法可以在同一个包中的类中被访问，也可以被不同包中的子类访问。
public 类可以在任何包中被访问。
默认情况下（没有指定访问修饰符），类、变量和方法是包私有的，即只能在同一个包中被访问。

31、下面关于Java语言中实例方法和类方法的说法，哪几项是对的？（BC）

A、实例方法可以直接通过类名调用

B、类方法可以直接通过类名调用。

C、实例方法可以操作实例变量也可以操作类变量。

D、类方法可以操作实例变量也可以操作类变量。

A、

这是错误的。实例方法需要通过类的实例（对象）来调用，而不能直接通过类名调用。

B、

这是正确的。类方法（也称为静态方法）是绑定到类而不是类的实例的，因此可以直接通过类名来调用。

C、

这是正确的。实例方法可以访问类的实例变量（非静态变量）和类变量（静态变量）。

D、

这是错误的。类方法（静态方法）只能直接访问类变量（静态变量），而不能直接访问实例变量（非静态变量），因为它们是与具体的类实例绑定的。如果类方法需要访问实例变量，它需要通过类的实例（对象）来访问。

所以，正确的选项是B和C。

32、下面叙述哪些是正确的？（ABC）

A、java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。

B、在java中，可以用异常（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要花费更大的系统开销。

C、java接口包含函数声明和常量声明。

D、java中，子类不可以访问父类的私有成员和受保护的成员。

(//这个叙述是不正确的。子类不能直接访问父类的私有成员（在Java中，用private修饰符声明的成员），但是子类可以访问父类的受保护的成员（用protected修饰符声明的成员）)

33、下列说法正确的是(A)。

A.final可修饰类、属性、方法

B.abstract可修饰类、属性、方法

C.定义抽象方法需有方法的返回类型、名称、参数列表和方法体

D.用final修饰的变量，在程序中可对这个变量的值进行更改

A. 

这是正确的。final关键字在Java中有多种用途：
修饰类：表示该类不能被继承。
修饰属性（变量）：表示该变量的值在初始化后不能被改变（对于基本数据类型）或引用不能被重新指向其他对象（对于对象引用）。
修饰方法：表示该方法不能被重写（在子类中）。

B. abstract可修饰类、属性、方法

这是错误的。abstract关键字只能用于修饰类和方法：
修饰类：表示该类是抽象类，不能被实例化，但可以包含抽象方法和非抽象方法。
修饰方法：表示该方法是抽象方法，没有方法体，且必须在子类中被重写（除非子类也是抽象类）。
abstract不能修饰属性（变量）。

C. 

这是错误的。抽象方法没有方法体，只有返回类型、名称和参数列表。

D. 

这是错误的。对于基本数据类型，final修饰的变量在初始化后其值不能被改变。对于对象引用，final修饰的变量不能被重新指向其他对象，但对象的内部状态仍然可以改变（如果对象是可变的）。

因此，正确答案是A。

34、Java语言的类间的继承关系是(B)。

A.多重的

B.单重的

C.线程的

D.不能继承

35、下列有关子类继承父类构造函数的描述正确的是(C)。

A.创建子类的对象时，先调用子类自己的构造函数，然后调用父类的构造函数

B.子类无条件地继承父类不含参数的构造函数

C.子类必须通过super关键字调用父类的构造函数

D.子类无法继承父类的构造函数 ????

A. 

这是不准确的。实际上，当创建一个子类对象时，首先会调用父类的构造函数（如果子类构造函数没有显式地调用父类的构造函数，那么会默认调用父类的无参构造函数），然后再执行子类构造函数的代码。

B. 

这也是不准确的。子类并不直接“继承”父类的构造函数。但是，如果父类有一个无参构造函数并且子类没有使用super关键字明确指定要调用的父类构造函数，那么Java会默认调用父类的无参构造函数。但如果父类没有无参构造函数，并且子类没有使用super明确调用其他构造函数，那么编译会出错。

C. 子类必须通过super关键字调用父类的构造函数

这个描述不完全准确，但它是基于通常的情况。在Java中，如果子类需要调用父类的某个特定构造函数（而不是默认的无参构造函数），那么它确实需要使用super关键字来明确指定。但是，如果父类有一个无参构造函数，并且子类没有使用super明确调用其他构造函数，那么Java会默认调用父类的无参构造函数。

D. 子类无法继承父类的构造函数

这是准确的。子类并不直接继承父类的构造函数。但是，子类可以调用父类的构造函数（使用super关键字）来初始化从父类继承的字段。