Tengo dificultades para saber cuál de las siguientes clases / interfaces puedo instanciar en el método Main (qué clase / interfaz está completamente bien). El código es así para algunas de las clases e interfaces:

interface A {public void Method();}
class B {public static int b;}
abstract class C:B {public void Method1();}
sealed class D:B {} ;
class E:A {};
class F:A {public void Method();}
class G:C {};

Y luego, tenemos el método Main en otra clase, como este ...

class Program 
{
    static void Main(string[] args) 
    {
        A a = new A();
        B b = new B();
        A ab = new B();
        B ba = new A();
        C c = new C();
        D d = new D();
        E e = new E();
        F af = new A();
        A fa = new F();
        G g = new G();
    }
}

Entonces, ¿cuáles podemos usar desde arriba? Sé que es una pregunta tonta, pero esto es lo que realmente tenemos en la prueba en la Universidad.

-1
Srđan Todorović 8 sep. 2018 a las 19:21

3 respuestas

La mejor respuesta
  • Una clase abstract no puede ser instanciada.
  • El modificador sealed evita que se herede una clase y el modificador abstract requiere que se herede una clase.

Fuente: https://docs.microsoft.com/ es-es / dotnet / csharp / language-reference / keywords / abstract

  • Una interfaz no puede ser instanciada directamente.

Fuente: https://docs.microsoft.com/en -us / dotnet / csharp / programación-guía / interfaces /

Esto significa que:

class Program 
{
    static void Main(string[] args) 
    {
        A a = new A();  // ERROR: cannot instantiate interface
        B b = new B();  // OK
        A ab = new B(); // ERROR: class B doesn't implement interface A
        B ba = new A(); // ERROR: cannot instantiate interface
        C c = new C();  // ERROR: cannot instantiate abstract class
        D d = new D();  // OK
        E e = new E();  // OK
        F af = new A(); // ERROR: cannot instantiate interface
        A fa = new F(); // OK:    class F does implement interface A
        G g = new G();  // OK
    }
}
0
martijnn2008 8 sep. 2018 a las 16:45

No puede crear nuevas interfaces o clases abstractas, por lo que podrían causar errores.

Las interfaces son solo contratos. No son clases No puedes instanciarlos.

Las clases abstractas solo se pueden heredar. No se pueden crear por su cuenta.

Las clases selladas solo significan que no se pueden heredar. Todavía puedes instanciarlos.

0
Todd Skelton 8 sep. 2018 a las 16:38

La mayoría de sus declaraciones de clase no se compilarían. Solo se compilan las declaraciones para B, D y G.

interface A {public void Method();} // "public" cannot be used on interface members
class B {public static int b;}
abstract class C:B {public void Method1();} // method without body should be marked as "abstract"
sealed class D:B {} ;
class E:A {}; // interface methods not implemented
class F:A {public void Method();} // method does not have a body
class G:C {};

Para las declaraciones en Main, la mayoría de ellas tampoco compilan:

A a = new A(); // cannot instantiate interface A
B b = new B(); // OK because B is a normal class
A ab = new B(); // B can be instantiated for aforementioned reasons, but cannot be
                // assigned to A because they are unrelated types
B ba = new A(); // cannot instantiate interface A. A also cannot be assigned to
                // B because they are unrelated.
C c = new C(); // cannot instantiate abstract class C
D d = new D(); // OK, D is a normal class. It is sealed, but that just means no 
               // class can derive from it, nothing to do with instantiation
E e = new E(); // OK, E is a normal class
F af = new A(); // cannot instantiate interface A
A fa = new F(); // F is a normal class, and is assignable to A because F implements A
G g = new G(); // OK, G is a normal class

Patrones generales:

  • clases abstractas e interfaces no pueden ser instanciadas
  • La palabra clave sealed no tiene nada que ver con la creación de instancias
  • las clases con solo un constructor privado no se pueden instanciar
  • Se puede asignar una expresión de tipo T1 a una variable de tipo T2 si:
    • T1 y T2 son del mismo tipo, o;
    • T1 hereda T2, o;
    • T1 implementa T2, o;
    • T1 es implícitamente convertible a T2
1
Sweeper 8 sep. 2018 a las 16:48