为什么构造函数在Java中不能是最终的、静态的或抽象的？

先决条件： Java中的继承

Java中的构造函数是一种特殊类型的方法，它不同于普通的Java方法/普通方法。构造函数用于初始化对象。创建类的对象时会自动调用构造函数。它在语法上类似于方法，但它与它的类同名，并且构造函数没有返回类型。

Java构造函数不能是final

Java构造函数的一个重要特性是它不能是final。正如我们所知，构造函数在Java中不是继承的。因此，构造函数不受隐藏或覆盖的影响。当没有机会覆盖构造函数时，也没有机会进行修改。当没有修改的机会时，就没有限制修改的意义。我们知道 final 关键字限制了进一步的修改。因此， Java构造函数不能是最终的，因为它本质上不能被修改。此外， Java构造函数在内部是最终的。因此，无需进一步进行最终声明。

示例：假设我们将一个Java构造函数声明为 final，现在让我们看看发生了什么。

Java

// Java Constructor as final
 
import java.io.*;
class GFG {
 
    // GFG() constructor is declared final
    final GFG()
    {
        // This line can not be executed as compile error
        // will come
        System.out.print(
            "Hey you have declared constructor as final, it's error");
    }
}
class Main {
    public static void main(String[] args)
    {
        // Object of GFG class created
        // Automatically GFG() constructor called
        GFG obj = new GFG();
    }
}

输出：

prog.java:4: error: modifier final not allowed here
final GFG( )
      ^
1 error

从上面的例子也很明显，如果我们将构造函数定义为 final，编译器将给出一个 错误作为修饰符 final 不允许。

Java构造函数不能是静态的

Java构造函数的重要属性之一是它不能是静态的。我们知道 static 关键字属于类而不是类的对象。创建类的对象时会调用构造函数，因此不使用静态构造函数。另一件事是，如果我们将声明静态构造函数，那么我们将无法从子类访问/调用构造函数。因为我们知道静态在类中是允许的，但在子类中是不允许的。

例子：

Java

// java class and a subclass
 
import java.io.*;
 
class GFG {
    public GFG()
    {
        // Constructor of GFG class
        System.out.println("GFG Constructor");
    }
}
class SubClass extends GFG {
 
    SubClass()
    {
        // Constructor of SubClass class
        // By default super() is hidden here
        // So Super class i.e GFG class constructor called
        System.out.println("Subclass Constructor");
    }
    public static void main(String args[])
    {
        // SubClass class object created
        // Automatically SubClass() constructor called
        SubClass obj = new SubClass();
    }
}

输出

GFG Constructor
Subclass Constructor

上面的例子表示，当创建子类的对象时，子类构造函数通过构造函数链接调用超类构造函数。但是，如果我们将超类构造函数设为静态，则它不能被子类调用，如上所述静态它可以在类内访问，但不能被子类访问。

不将构造函数声明为静态的一个更重要的原因是，我们知道静态成员在程序中首先执行，就像 main 方法是静态的并首先执行一样。但是每次创建对象时都会调用构造函数。但是如果我们将它声明为静态，那么构造函数将在对象创建之前被调用。所以一般来说，如果我们会看到静态和构造函数彼此相反，如果我们想为实例变量分配初始值，我们可以使用构造函数，如果我们想分配静态变量，我们可以使用静态块。

示例：假设我们将一个Java构造函数声明为静态，现在让我们看看发生了什么。

Java

// java constructor as static
 
import java.io.*;
 
class GFG {
   
    // GFG() constructor is declared static
    static GFG()
    {
        // This line can not be executed as it compile error
        // will come
        System.out.print(
            "Hey you have declared constructor as static, it's error");
    }
}
class Main {
    public static void main(String[] args)
    {
        // Object of GFG class created
        // Automatically GFG() constructor called
        GFG obj = new GFG();
    }
}

输出

prog.java:5: error: modifier static not allowed here
 static GFG( )
        ^
1 error

从上面的例子也很明显，如果我们将构造函数定义为 static 编译器将给出一个错误，因为修饰符 static 不允许。

Java构造函数不能是抽象的

Java构造函数的重要特性之一是它不能是抽象的。如果我们将构造函数声明为抽象的，因为我们必须在子类中实现它，但是我们知道在使用 new 关键字时隐式调用构造函数，因此它不能缺少主体，也不能作为正常方法。此外，如果我们使构造函数抽象，那么我们必须稍后提供主体。但是我们知道构造函数不能被覆盖，所以提供主体是不可能的。因此，当我们无法为其提供实现时，我们将如何处理这个抽象构造函数。

示例：假设我们将一个Java构造函数声明为抽象的，现在让我们看看发生了什么。

Java

// java constructor as static
 
import java.io.*;
abstract class GFG {
   
    // GFG() constructor is declared abstract
    abstract GFG()
    {
        // This line can not be executed as compile error
        // will come
        System.out.print(
            "Hey you have declared constructor as abstract, it's error");
    }
}
class Main {
    public static void main(String[] args)
    {
        // Object of GFG class created
        // Automatically GFG() constructor should be called
        // But object creation in abstract class is error
        GFG obj = new GFG();
    }
}

输出

prog.java:5: error: modifier abstract not allowed here
 abstract GFG( )
          ^
prog.java:17: error: GFG is abstract; cannot be instantiated
   GFG obj = new GFG();
             ^
2 errors

从上面的例子也很明显，如果我们将构造函数定义为静态的，编译器将给出一个错误，因为修饰符抽象是不允许的。

注意： Java接口不能有构造函数，但抽象类可以有构造函数。