Java构造函数面试题

2024年8月28日 | 阅读 15 分钟

Java 构造函数是面向对象编程中的一个关键概念，它允许我们初始化对象并设置其初始状态。它在创建类的实例时起着至关重要的作用，并且通常是 Java 面试中的一个关键主题。在本文中，我们将探讨一些与 Java 构造函数相关的常见和高级面试题，并提供详细的解释以及代码示例来说明其用法。无论您是准备面试的 Java 开发人员，还是只想增强知识，本指南都将帮助您更好地理解构造函数并在面试中取得好成绩。

什么是构造方法？

在深入讨论面试题之前，让我们简要回顾一下构造函数的概念。在 Java 中，构造函数是一个特殊的方法，它与它所属的类具有相同的名称。它用于创建和初始化该类的对象。当使用 new 关键字创建新对象时，会自动调用构造函数，以确保对象处于有效状态。构造函数没有返回类型，并且可以重载，这意味着一个类可以有多个具有不同参数列表的构造函数。如果您没有显式提供构造函数，Java 将提供一个不带参数的默认构造函数。但是，如果您定义了自己的构造函数，则不会自动添加默认构造函数。

1) 构造函数的作用是什么？

构造函数的主要作用是初始化对象的状态。它负责为对象的实例变量设置初始值，以便在创建对象后即可使用。当使用 Java new 关键字创建新对象时，会自动调用构造函数。

示例

class MyClass {
    int number;
    // Constructor
    public MyClass(int num) {
        number = num;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of MyClass using the constructor
        MyClass obj = new MyClass(42);
        System.out.println("Number: " + obj.number); 
    }
}

输出

Number: 42

2) 构造函数可以是私有的或最终的吗？

是的，构造函数可以是私有的或最终的。当构造函数被标记为私有时，意味着它无法从类外部访问，因此无法直接从类外部创建对象。此技术通常用于单例设计模式，在该模式中只允许类的单个实例。

示例

class SingletonClass {
    private static final SingletonClass instance = new SingletonClass(
    private SingletonClass() {
        // Private constructor
    }
    public static SingletonClass getInstance() {
        return instance;
    }
}
public class Main {
    public static void main(String[] args) {
        // Cannot create an object directly, instead use the getInstance() method
        // SingletonClass obj = new SingletonClass(); 
        SingletonClass obj = SingletonClass.getInstance();
    }
}

输出

This will give an error

3) 什么是构造函数链？

构造函数链是指在同一个类中从另一个构造函数调用构造函数，或者从超类调用构造函数的过程。这使我们能够重用代码并避免在存在多个构造函数时出现重复。

示例

class Person {
    String name;
    int age;
    // Constructor with name parameter
    public Person(String name) {
        this.name = name;
    }
    // Constructor with both name and age parameters
    public Person(String name, int age) {
        this(name); // Invoking the constructor with name parameter using 'this'
        this.age = age;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of Person using the constructor
        Person person = new Person("John", 30);
        System.out.println("Name: " + person.name + ", Age: " + person.age);
        
    }
}

输出

Name: John, Age: 30

4) 如何防止类的构造函数被继承？

默认情况下，Java 中的构造函数是不可继承的。但是，当创建子类时，它会在执行自身的构造函数之前隐式调用其超类的构造函数。如果超类具有带参数的构造函数且没有默认构造函数，则子类必须使用 super() 关键字显式调用适当的超类构造函数。

示例

class Superclass {
    int number;
    public Superclass(int number) {
        this.number = number;
    }
}
class Subclass extends Superclass {
    String message;
    public Subclass(int number, String message) {
        super(number); // Calling the constructor of the superclass
        this.message = message;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of Subclass
        Subclass obj = new Subclass(10, "Hello");
        System.out.println("Number: " + obj.number + ", Message: " + obj.message);      
    }
}

输出

Number: 10, Message: Hello

5) 默认构造函数和参数化构造函数有什么区别？

默认构造函数和参数化构造函数之间的关键区别在于它们的参数列表和行为。默认构造函数不接受任何参数，当类没有显式定义任何构造函数时，Java 会提供它。另一方面，参数化构造函数在其参数列表中包含参数，并允许您在创建对象时用特定值初始化实例变量。

示例

class Car {
    String make;
    String model;
    int year;
    // Default constructor (provided by Java if not defined explicitly)
    public Car() {
        make = "Unknown";
        model = "Unknown";
        year = 0;
    }
    // Parameterized constructor
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating objects of Car with both constructors
        Car defaultCar = new Car();
        Car paramCar = new Car("Toyota", "Camry", 2022);
        System.out.println("Default Car: " + defaultCar.make + " " + defaultCar.model + " " + defaultCar.year);
        // Output: Default Car: Unknown Unknown 0
        System.out.println("Parameterized Car: " + paramCar.make + " " + paramCar.model + " " + paramCar.year);
Parameterized Car: Toyota Camry 2022
    }
}

输出

Parameterized Car: Toyota Camry 2022

6) 构造函数可以调用方法吗？

从技术上讲，构造函数可以调用方法，但通常不建议这样做。原因是构造函数旨在初始化对象的状态并设置其初始值。从构造函数调用方法可能会导致意外行为，特别是如果方法依赖于尚未初始化的实例变量。但是，在某些情况下，从构造函数调用方法可能是可以接受的，但开发人员应谨慎行事，并确保方法调用不会干扰对象的正确初始化。

示例

class Rectangle {
    int width;
    int height;
    int area;
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
        calculateArea(); // Calling a method to calculate the area from constructor (for demonstration purposes)
    }
    private void calculateArea() {
        area = width * height;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of Rectangle
        Rectangle rect = new Rectangle(5, 10);
        System.out.println("Area: " + rect.area);
        // Output: Area: 50
    }
}

7) 如果在一个带有其他构造函数的类中没有提供无参数构造函数，会发生什么？

当我们在类中定义构造函数时，Java 不会自动提供默认（无参数）构造函数。如果您已定义一个或多个参数化构造函数，但未显式提供无参数构造函数，Java 将不会为您生成它。因此，如果您尝试在不带参数的情况下创建对象，这将导致编译错误。

示例

class MyClass {
    int value;
    // No-argument constructor
    public MyClass() {
        value = 0;
    }
    public MyClass(int value) {
        this.value = value;
    }
}
public class Main {
    public static void main(String[] args) {
        // Now you can create an object of MyClass without any arguments
        MyClass obj = new MyClass();

        // Print the value of the object
        System.out.println("Value: " + obj.value);
    }
}

输出

要解决编译错误，我们可以显式提供无参数构造函数，或者使用现有的参数化构造函数之一来创建对象。

8) 同一个类中可以同时拥有默认构造函数和参数化构造函数吗？

是的，一个类可以同时拥有默认构造函数（无参数构造函数）和一个或多个参数化构造函数。如果您在类中定义了参数化构造函数，Java 不会自动提供默认构造函数。但是，您可以将其与参数化构造函数显式定义在一起。

示例

class MyClass {
    int value;
    // Default constructor
    public MyClass() {
        value = 0;
    }
    // Parameterized constructor
    public MyClass(int value) {
        this.value = value;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating objects of MyClass using both constructors
        MyClass obj1 = new MyClass(); // Using the default constructor
        MyClass obj2 = new MyClass(42); // Using the parameterized constructor
        System.out.println("Object 1 Value: " + obj1.value); // Output: Object 1 Value: 0
        System.out.println("Object 2 Value: " + obj2.value); // Output: Object 2 Value: 42
    }
}

9) 如果在类中不提供任何构造函数，会发生什么？

如果您没有在类中显式定义任何构造函数，Java 将自动提供一个默认（无参数）构造函数。此默认构造函数内部没有任何代码，等同于编写一个不带参数的空构造函数。重要的是要注意，一旦您显式定义了任何构造函数，就不会自动生成默认构造函数。

示例

class MyClass {
    int value;
    // No constructor defined in this class
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of MyClass using the default constructor
        MyClass obj = new MyClass();
    }
}

10) 可以使用 this() 关键字从一个构造函数调用另一个构造函数吗？

是的，在 Java 中，您可以使用 this() 关键字在同一个类中从一个构造函数调用另一个构造函数。此技术称为构造函数链。它允许您重用初始化逻辑并减少代码重复。

示例

class MyClass {
    int value;
    // Constructor with one argument
    public MyClass(int value) {
        this.value = value;
    }
    // Constructor with no arguments, calling the one-argument constructor using 'this()'
    public MyClass() {
        this(0); // Call the constructor with one argument
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of MyClass using the no-argument constructor
        MyClass obj = new MyClass();
        System.out.println("Value: " + obj.value); 
    }
}

输出

Value: 0

11) 构造函数可以是静态的吗？

否，构造函数不能是静态的。static 关键字用于定义类的静态成员（变量和方法），它不适用于构造函数。构造函数是实例级别的成员，用于初始化对象状态，因此不能与类本身关联。

示例

class MyClass {
    static int value; // This is a static variable
    // This is a constructor (non-static method)
    public MyClass(int value) {
        MyClass.value = value;
    }
    // This is a static method
    public static void staticMethod() {
        // Code for the static method
    }
}
public class Main {
    public static void main(String[] args) {
        // Cannot call the constructor using the class name like a static method
        // MyClass(42); // This will cause a compilation error
        // Correct way to call the constructor is by creating an object
        MyClass obj = new MyClass(42);
    }
}

12) 如果为构造函数定义了返回类型，会发生什么？

构造函数没有返回类型，甚至没有 void。如果您尝试为构造函数提供返回类型，它将被视为常规方法，编译器也会将其视为常规方法。这将导致编译错误。

示例

class MyClass {
    int value;
    // This will cause a compilation error as constructors cannot have a return type
    // public void MyClass(int value) {
    //     this.value = value;
    // }
}

13) 构造函数可以在 Java 中被继承吗？

构造函数在 Java 中不被继承。虽然子类在其构造函数执行之前会隐式调用其超类的构造函数，但构造函数本身并不被继承。每个类，包括子类，都必须独立定义其构造函数。

示例

class Superclass {
    public Superclass() {
        System.out.println("Superclass constructor");
    }
}
class Subclass extends Superclass {
    // Subclass does not define any constructors explicitly
}
public class Main {
    public static void main(String[] args) {
        // Output: Superclass constructor
        Subclass obj = new Subclass();
    }
}

14) super() 关键字在构造函数中的作用是什么？

super() 关键字用于从子类构造函数调用超类构造函数。它用于构造函数链，确保在子类初始化开始之前执行超类的初始化逻辑。

示例

class Superclass {
    int number;
    public Superclass(int number) {
        this.number = number;
    }
}
class Subclass extends Superclass {
    String message;
    public Subclass(int number, String message) {
        super(number); // Calling the constructor of the superclass
        this.message = message;
    }
}
public class Main {
    public static void main(String[] args) {
        Subclass obj = new Subclass(10, "Hello");
        System.out.println("Number: " + obj.number + ", Message: " + obj.message);
        // Output: Number: 10, Message: Hello
    }
}

15) 可以将构造函数设为 final 吗？

否，构造函数不能被标记为 final。final 关键字用于指示方法、类或变量不能被覆盖或更改。由于构造函数不能像常规方法那样被覆盖，因此无需将 final 与构造函数一起使用。

class MyClass {
    // This will cause a compilation error as constructors cannot be final
    // public final MyClass() {
    //     // Constructor logic
    // }
}

16) 可以为构造函数使用访问修饰符（如 private、protected 或 public）吗？

是的，构造函数可以像其他类成员一样具有访问修饰符。访问修饰符决定了构造函数在不同上下文中的可见性。

示例

class MyClass {
    private int value; // Private instance variable
    // Private constructor
    private MyClass(int value) {
        this.value = value;
    }
    // Public method to create an object using the private constructor
    public static MyClass createInstance(int value) {
        return new MyClass(value);
    }
}
public class Main {
    public static void main(String[] args) {
        // Cannot directly create an object using the private constructor
        // MyClass obj = new MyClass(42); // This will cause a compilation error
        // Instead, use the public method to create an object
        MyClass obj = MyClass.createInstance(42);
        System.out.println("Value: " + obj.value); // Output: Value: 42
    }
}

17) this 关键字在构造函数中的作用是什么？

Java this 关键字用于在构造函数或任何其他实例方法中引用类的当前实例。它通常用于区分同名的实例变量和参数。

示例

class MyClass {
    int value;
    // Constructor with a parameter named 'value'
    public MyClass(int value) {
        this.value = value; // 'this.value' refers to the instance variable, and 'value' refers to the parameter
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass(42);
        System.out.println("Value: " + obj.value);
    }
}

输出

Value: 42

18) 可以在构造函数中使用 new 关键字创建另一个类的对象吗？

是的，我们可以在构造函数中使用 new 关键字来创建另一个类的对象。构造函数可以包含任何有效的 Java 代码，包括对象创建。

示例

class Student {
    String name;
    public Student(String name) {
        this.name = name;
    }
}
class School {
    Student student;
    public School(String studentName) {
        student = new Student(studentName); // Creating an object of Student inside the School constructor
    }
}
public class Main {
    public static void main(String[] args) {
        School school = new School("John Doe");
        System.out.println("Student Name: " + school.student.name); 
    }
}

输出

Student Name: John Doe

19) 可以从构造函数中抛出异常吗？

是的，构造函数可以像任何其他方法一样抛出异常。如果从构造函数中抛出异常，对象创建将被中止，异常将传播到调用代码。

示例

class MyClass {
    int value;
    public MyClass(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Value cannot be negative");
        }
        this.value = value;
    }
}
public class Main {
    public static void main(String[] args) {
        try {
            MyClass obj = new MyClass(-42); // This will throw an IllegalArgumentException
        } catch (IllegalArgumentException e) {
            System.out.println("Exception: " + e.getMessage()); 
        }
    }
}

输出

Exception: Value cannot be negative

20) 可以将构造函数定义为抽象的吗？

否，构造函数不能定义为抽象的。抽象方法是没有主体的方法，只能存在于抽象类或接口中。另一方面，构造函数必须有一个主体来初始化对象。因此，它们不能是抽象的。

示例

abstract class MyClass {
    // This will cause a compilation error as constructors cannot be abstract
    // public abstract MyClass();
}

21) 可以将 final 关键字用于构造函数参数吗？

是的，我们可以将 final 关键字用于构造函数参数，以指示这些参数的值在对象创建期间被分配后不能被更改。当您希望确保特定实例变量的不可变性时，这很有用。

示例

class Point {
    final int x;
    final int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Main {
    public static void main(String[] args) {
        Point p = new Point(10, 20);
        // p.x = 5; // This will cause a compilation error as 'x' is final
    }
}

22) 可以在同一个构造函数中使用 this() 关键字和 super() 关键字吗？

是的，您可以在同一个构造函数中使用 this() 关键字和 super() 关键字，但必须确保它们是构造函数体中的第一条语句。这是因为 this() 和 super() 都必须是构造函数中的第一条语句，以避免歧义。

示例

class Parent {
    int x;
    public Parent(int x) {
        this.x = x;
    }
}
class Child extends Parent {
    int y;
    public Child(int x, int y) {
        super(x); // Call the constructor of the superclass
        this.y = y;
    }
}
public class Main {
    public static void main(String[] args) {
        Child obj = new Child(10, 20);
        System.out.println("X: " + obj.x + ", Y: " + obj.y); // Output: X: 10, Y: 20
    }
}

23) 构造函数可以是递归的吗？

是的，构造函数可以是递归的，这意味着构造函数可以调用自身。但是，您应该谨慎使用递归构造函数，确保有一个基本情况来停止递归，以避免无限递归。

示例

class MyClass {
    int value;
    // Recursive constructor
    public MyClass(int value) {
        if (value <= 0) {
            this.value = 0; // Base case: Stop recursion when value is less than or equal to 0
        } else {
            this.value = value;
            new MyClass(value - 1); // Recursive call
        }
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass(5);
        System.out.println("Value: " + obj.value); 
    }
}

输出

Value: 0

24) 构造函数可以是同步的吗？

是的，构造函数可以是同步的。当构造函数被标记为同步时，它确保一次只有一个线程可以进入构造函数并创建一个对象。这在多线程环境中很有用，可以避免并发对象创建问题。

示例

class MyClass {
    int value;
    // Synchronized constructor
    public synchronized MyClass(int value) {
        this.value = value;
    }
}

25) 构造函数中实例变量的默认初始化和显式初始化有什么区别？

默认初始化在声明实例变量时为它们分配默认值（例如，数值类型为 0，对象引用为 null）。另一方面，显式初始化允许您在构造函数中为实例变量设置自定义值，从而使您能够更好地控制对象的初始状态。

示例

class MyClass {
    int defaultVar; // Default initialization
    int explicitVar;
    public MyClass(int value) {
        explicitVar = value; // Explicit initialization within the constructor
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass(42);
        System.out.println("Default Var: " + obj.defaultVar); // Output: Default Var: 0
        System.out.println("Explicit Var: " + obj.explicitVar); // Output: Explicit Var: 42
    }
}

26) 构造函数可以在同一个构造函数中同时调用 this() 和 super() 吗？

是的，构造函数可以在同一个构造函数中同时调用 this() 和 super()，但需要遵循某些规则。this() 和 super() 调用必须是构造函数中的第一条语句，并且不能在同一个构造函数中一起使用。但是，您可以使用 this() 调用同一类中的另一个构造函数，并使用 super() 调用直接超类中的构造函数。

示例

class Parent {
    int x;
    public Parent(int x) {
        this.x = x;
    }
}
class Child extends Parent {
    int y;
    public Child(int x, int y) {
        super(x); // Call the constructor of the superclass
        this.y = y;
    }
    public Child(int y) {
        this(0, y); // Call another constructor within the same class using 'this()'
    }
}
public class Main {
    public static void main(String[] args) {
        Child obj1 = new Child(10, 20);
        System.out.println("X: " + obj1.x + ", Y: " + obj1.y); // Output: X: 10, Y: 20
        Child obj2 = new Child(30);
        System.out.println("X: " + obj2.x + ", Y: " + obj2.y); // Output: X: 0, Y: 30
    }
}

在此示例中，Child 类有两个构造函数：一个带两个参数，另一个带一个参数。带一个参数的构造函数使用 this() 调用另一个构造函数，带两个参数的构造函数使用 super() 调用超类的构造函数。通过遵循这些规则，您可以有效地使用 this() 和 super() 来创建更灵活的 Java 类构造函数。

Java构造函数面试题

什么是构造方法？

1) 构造函数的作用是什么？

2) 构造函数可以是私有的或最终的吗？

3) 什么是构造函数链？

4) 如何防止类的构造函数被继承？

5) 默认构造函数和参数化构造函数有什么区别？

6) 构造函数可以调用方法吗？

7) 如果在一个带有其他构造函数的类中没有提供无参数构造函数，会发生什么？

8) 同一个类中可以同时拥有默认构造函数和参数化构造函数吗？

9) 如果在类中不提供任何构造函数，会发生什么？

10) 可以使用 this() 关键字从一个构造函数调用另一个构造函数吗？

11) 构造函数可以是静态的吗？

12) 如果为构造函数定义了返回类型，会发生什么？

13) 构造函数可以在 Java 中被继承吗？

14) super() 关键字在构造函数中的作用是什么？

15) 可以将构造函数设为 final 吗？

16) 可以为构造函数使用访问修饰符（如 private、protected 或 public）吗？

17) this 关键字在构造函数中的作用是什么？

18) 可以在构造函数中使用 new 关键字创建另一个类的对象吗？

19) 可以从构造函数中抛出异常吗？

20) 可以将构造函数定义为抽象的吗？

21) 可以将 final 关键字用于构造函数参数吗？

22) 可以在同一个构造函数中使用 this() 关键字和 super() 关键字吗？

23) 构造函数可以是递归的吗？

24) 构造函数可以是同步的吗？

25) 构造函数中实例变量的默认初始化和显式初始化有什么区别？

26) 构造函数可以在同一个构造函数中同时调用 this() 和 super() 吗？

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

所有面试

公司面试

Technical Interview

Web Interview

PHP面试

.Net面试

Java Interview

Database Interview

Java构造函数面试题

什么是构造方法？

1) 构造函数的作用是什么？

2) 构造函数可以是私有的或最终的吗？

3) 什么是构造函数链？

4) 如何防止类的构造函数被继承？

5) 默认构造函数和参数化构造函数有什么区别？

6) 构造函数可以调用方法吗？

7) 如果在一个带有其他构造函数的类中没有提供无参数构造函数，会发生什么？

8) 同一个类中可以同时拥有默认构造函数和参数化构造函数吗？

9) 如果在类中不提供任何构造函数，会发生什么？

10) 可以使用 this() 关键字从一个构造函数调用另一个构造函数吗？

11) 构造函数可以是静态的吗？

12) 如果为构造函数定义了返回类型，会发生什么？

13) 构造函数可以在 Java 中被继承吗？

14) super() 关键字在构造函数中的作用是什么？

15) 可以将构造函数设为 final 吗？

16) 可以为构造函数使用访问修饰符（如 private、protected 或 public）吗？

17) this 关键字在构造函数中的作用是什么？

18) 可以在构造函数中使用 new 关键字创建另一个类的对象吗？

19) 可以从构造函数中抛出异常吗？

20) 可以将构造函数定义为抽象的吗？

21) 可以将 final 关键字用于构造函数参数吗？

22) 可以在同一个构造函数中使用 this() 关键字和 super() 关键字吗？

23) 构造函数可以是递归的吗？

24) 构造函数可以是同步的吗？

25) 构造函数中实例变量的默认初始化和显式初始化有什么区别？

26) 构造函数可以在同一个构造函数中同时调用 this() 和 super() 吗？

相关帖子

数据建模面试题

2025年顶尖20+应付账款面试题及答案

2025年顶尖50项Salesforce面试题及答案

React面试题

2025年顶尖50+Xamarin面试题

IIS面试题

最常问的Active Directory面试题 (2025)

2025年顶尖30项PowerShell面试题

2025年顶尖50+Angular面试题及答案

2025年顶尖30项前端开发工程师面试题及答案

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器