Constructor abstracto en C # [duplicar]

No puede declararlo abstract, pero puede tener un constructor en su clase abstracta; simplemente elimine la palabra abstract y proporcione un cuerpo para ella.

Lo abstracto implica lo virtual. Un constructor no predeterminado nunca puede ser llamado polimórficamente, por lo que virtual y abstracto no están permitidos en los constructores.

SI en una versión futura de C#, los genéricos se mejoran para permitir llamar a constructores no predeterminados a través de un parámetro de tipo genérico, entonces las llamadas polimórficas a los constructores serían posibles y los constructores virtuales y abstractos también podrían agregarse.

Los constructores están más cerca de los métodos estáticos que de los métodos "regulares". Al igual que los métodos estáticos, pueden ser sobrecargados, pero no anulados. Es decir, no se heredan, sino que se pueden redefinir.

public BaseClass
{
   public BaseClass( String s ) { ... }
   public static void doIt ( String s ) { ... }
}

public SubClass extends BaseClass
{
   public SubClass( String s )  { ... }
   public static void doIt ( String s ) { ... }
}

public SubClass2 extends BaseClass
{
}

new SubClass( "hello" );
SubClass.doIt( "hello" ); 

new SubClass2( "hello" ); // NOK
SubClass2.doIt( "hello" ); // NOK

Los constructores y los métodos estáticos son nunca enviados dinámicamente (virtualmente) You Usted siempre sabe el tipo concreto que instanciaó o la clase concreta del método estático. Es por eso que no tiene sentido tener constructor abstracto y método estático abstracto. Es por eso que tampoco puede especificar constructor y método estático en interfaces.

Incluso puedes pensar en constructor como método estático de fábrica (y ver el patrón correspondiente):

  MyClass obj = new MyClass(); // the way it is
  MyClass obj = MyClass.new(); // think of it like this

El único caso que veo donde tendría sentido definir constructor abstracto o método estático abstracto sería si reflexión se utiliza. En este caso, podría asegurarse de que todas las subclases redefinirían el correspondiente método estático o constructor. Pero la reflexión es otro tema...

Nota: en lenguajes como Smalltalk donde las clases son objetos regulares, puede sobrescribir el método estático y tener constructor abstracto. Pero no se aplica a Java porque las clases no son objetos "regulares", incluso si se pueden obtener con reflexión.

Qué hay de malo en esto:

public abstract class MyClass {
    protected MyClass(int param)
    {
    }
}

En este caso se obliga a todas las clases derivadas a llamar al constructor de clase base.

Porque los constructores abstractos no son compatibles.

Pero una clase abstracta puede tener un constructor.

Un constructor no es un método ordinario. Tiene un propósito especial, y por lo tanto está restringido a las características del lenguaje que tienen sentido para ese propósito. Ver también: ¿Por qué los constructores no devuelven valores?

Por definición, la clase no puede ser instanciada directamente, así que en cierto sentido, ya es abstracta.