究竟什么是默认构造函数——你能告诉我以下哪一个是默认构造函数，以及它与任何其他构造函数的区别是什么？
public Module() {
this.name = "";
this.credits = 0;
this.hours = 0;
}
public Module(String name, int credits, int hours) {
this.name = name;
this.credits = credits;
this.hours = hours;
}
他们都不是。如果您定义它，则它不是默认值。
默认构造函数是自动生成的无参数构造函数，除非您定义另一个构造函数。任何未初始化的字段都将设置为其默认值。对于您的示例，假设类型为String,int和int, 并且类本身是公共的，它看起来像这样：
public Module()
{
super();
this.name = null;
this.credits = 0;
this.hours = 0;
}
这与
public Module()
{}
和完全没有构造函数完全一样。但是，如果您定义了至少一个构造函数，则不会生成默认构造函数。
参考： Java 语言规范
如果一个类不包含构造函数声明，则隐式声明一个没有形式参数且没有 throws 子句的默认构造函数。
从技术上讲，默认初始化字段的不是构造函数（默认或其他）。但是，我将其保留为答案，因为
如果您没有在类中定义任何构造函数，则会创建默认构造函数。它只是一个无参数构造函数，什么都不做。编辑：除了调用 super()
public Module(){
}
如果您没有在类中明确定义至少一个构造函数，则编译器会自动生成默认构造函数。您已经定义了两个，因此您的类没有默认构造函数。
根据Java 语言规范第三版：
8.8.9 默认构造函数
如果类不包含构造函数声明，则自动提供不带参数的默认构造函数...
你好。据我所知，让我清楚默认构造函数的概念：
编译器会自动为任何没有构造函数的类提供无参数的默认构造函数。此默认构造函数将调用超类的无参数构造函数。在这种情况下，如果超类没有无参数构造函数，编译器会报错，因此您必须验证它是否存在。如果你的类没有显式的超类，那么它有一个 Object 的隐式超类，它确实有一个无参数的构造函数。
我从Java 教程中阅读了这些信息。
当没有提供显式构造函数时，Java 提供了一个默认构造函数，它不接受参数并且不执行特殊操作或初始化。
隐式默认构造函数采取的唯一动作是使用 super() 调用来调用超类构造函数。构造函数参数为您提供了一种为对象初始化提供参数的方法。
下面是一个包含 2 个构造函数的多维数据集类的示例。（一个默认构造函数和一个参数化构造函数）。
public class Cube1 {
int length;
int breadth;
int height;
public int getVolume() {
return (length * breadth * height);
}
Cube1() {
length = 10;
breadth = 10;
height = 10;
}
Cube1(int l, int b, int h) {
length = l;
breadth = b;
height = h;
}
public static void main(String[] args) {
Cube1 cubeObj1, cubeObj2;
cubeObj1 = new Cube1();
cubeObj2 = new Cube1(10, 20, 30);
System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());
System.out.println("Volume of Cube1 is : " + cubeObj2.getVolume());
}
}
一般术语是，如果您未在对象中提供任何构造函数，则会自动放置无参数构造函数，称为默认构造函数。
如果您确实定义了一个与不提供任何构造函数时所放置的构造函数相同的构造函数，则通常将其称为无参数构造函数。尽管有些程序员更喜欢将此显式定义的无参数构造函数称为默认构造函数，但这只是一种约定。但是，如果我们通过命名来明确定义一个，那么它不会使其成为默认值。
根据文档
如果一个类不包含构造函数声明，则隐式声明一个没有形式参数且没有 throws 子句的默认构造函数。
例子
public class Dog
{
}
将自动修改（通过添加默认构造函数）如下
public class Dog{
public Dog() {
}
}
当你创建它的对象
Dog myDog = new Dog();
调用此默认构造函数。
默认构造函数是指在没有任何程序员定义的构造函数的情况下由编译器自动生成的构造函数。
如果程序员没有提供构造函数，编译器会隐式声明一个调用的默认构造函数super()，没有 throws 子句，也没有形参。
例如
class Klass {
// Default Constructor gets generated
}
new Klass(); // Correct
-------------------------------------
class KlassParameterized {
KlassParameterized ( String str ) { //// Parameterized Constructor
// do Something
}
}
new KlassParameterized(); //// Wrong - you need to explicitly provide no-arg constructor. The compiler now never declares default one.
--------------------------------
class KlassCorrected {
KlassCorrected (){ // No-arg Constructor
/// Safe to Invoke
}
KlassCorrected ( String str ) { //// Parameterized Constructor
// do Something
}
}
new KlassCorrected(); /// RIGHT -- you can instantiate
如果一个类没有程序员提供的任何构造函数，那么java编译器将添加一个不带参数的默认构造函数，该构造函数将在内部使用 super() 调用调用超类构造函数。这被称为默认构造函数。
在您的情况下，没有默认构造函数，因为您以编程方式添加它们。如果您没有添加任何构造函数，那么编译器生成的默认构造函数将如下所示。
public Module()
{
super();
}
注意：在默认构造函数中，它也会添加 super() 调用，以调用超类构造函数。
添加默认构造函数的目的：
构造函数的职责是初始化实例变量，如果没有实例变量，您可以选择从类中删除构造函数。但是，当您继承某个类时，您的类有责任调用超类构造函数以确保超类正确初始化其所有实例变量。
这就是为什么如果没有构造函数，java编译器会添加一个默认构造函数并调用超类构造函数。
当我们没有为类显式定义构造函数时，java 会为该类创建一个默认构造函数。它本质上是一个非参数化的构造函数，即它不接受任何参数。
默认构造函数的工作是调用超类构造函数并初始化所有实例变量。如果超类构造函数不存在，那么它会自动将实例变量初始化为零。因此，这服务于使用构造函数的目的，即初始化对象的内部状态，以便创建实例的代码将具有完全初始化的可用对象。
一旦我们为类定义了自己的构造函数，就不再使用默认构造函数。因此，它们实际上都不是默认构造函数。
当您创建一个新的 Module 对象时，java 编译器会为您添加一个默认构造函数，因为根本没有构造函数。
class Module{} // you will never see the default constructor
如果您添加任何类型的构造函数，甚至是非 arg 构造函数，那么您将拥有自己的 java 东西，并且不再添加默认构造函数。
这是一个非 arg 构造函数，即使您没有父类，也会从其父类内部调用 super() 构造函数。（如果您的类没有父类，则将调用 Object.Class 构造函数）
class Module{
Module() {} // this look like a default constructor but in not.
}
当您没有在类中定义任何构造函数时，编译器会为您定义默认构造函数，但是当您声明任何构造函数时（在您的示例中，您已经定义了参数化构造函数），编译器不会为您执行此操作。
由于您在类代码中定义了构造函数，编译器没有创建默认构造函数。在创建对象时，您正在调用默认对象，该对象在类代码中不存在。然后代码给出了编译错误。
默认构造函数不接受任何参数：
public class Student {
// default constructor
public Student() {
}
}
我希望你能得到关于哪个是默认构造函数的答案。但我给出以下声明以纠正给出的评论。
Java 不会将任何局部变量初始化为任何默认值。因此，如果您正在创建一个类的对象，它将调用默认构造函数并向对象提供默认值。
默认构造函数根据类型为对象提供默认值，例如 0、null 等。
请参阅以下链接了解更多详情。