Compartir vía

clase (Referencia de C#)

Las clases se declaran mediante la palabra clave class, como se muestra en el ejemplo siguiente:

class TestClass
{
    // Methods, properties, fields, events, delegates
    // and nested classes go here.
}

Observaciones

Solo se permite la herencia única en C#. Es decir, una clase solo puede heredar la implementación de una clase base. Sin embargo, una clase puede implementar más de una interfaz. En la tabla siguiente se muestran ejemplos de implementación de interfaz y herencia de clases:

Herencia Ejemplo
Ninguno class ClassA { }
Soltero class DerivedClass : BaseClass { }
Ninguno, implementa dos interfaces class ImplClass : IFace1, IFace2 { }
Única, implementa una interfaz class ImplDerivedClass : BaseClass, IFace1 { }

Las clases que se declaran directamente dentro de un espacio de nombres, no anidadas dentro de otras clases, pueden ser públicas o internas. Las clases son internal de forma predeterminada.

Los miembros de clase, incluidas las clases anidadas, pueden ser públicos, internos protegidos, protegidos, internos, privados o privados protegidos. Los miembros son private de forma predeterminada.

Para obtener más información, vea Modificadores de acceso.

Puede declarar clases genéricas que tengan parámetros de tipo. Para obtener más información, vea Clases genéricas.

Una clase puede contener declaraciones de los miembros siguientes:

Ejemplo

En el ejemplo siguiente se muestra cómo declarar campos de clase, constructores y métodos. También muestra la creación de instancias de objetos y la impresión de datos de instancia. En este ejemplo, se declaran dos clases. La primera clase, Child, contiene dos campos privados (name y age), dos constructores públicos y un método público. La segunda clase, StringTest, se usa para contener Main.

class Child
{
    private int age;
    private string name;

    // Default constructor:
    public Child()
    {
        name = "N/A";
    }

    // Constructor:
    public Child(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // Printing method:
    public void PrintChild()
    {
        Console.WriteLine("{0}, {1} years old.", name, age);
    }
}

class StringTest
{
    static void Main()
    {
        // Create objects by using the new operator:
        Child child1 = new Child("Craig", 11);
        Child child2 = new Child("Sally", 10);

        // Create an object using the default constructor:
        Child child3 = new Child();

        // Display results:
        Console.Write("Child #1: ");
        child1.PrintChild();
        Console.Write("Child #2: ");
        child2.PrintChild();
        Console.Write("Child #3: ");
        child3.PrintChild();
    }
}
/* Output:
    Child #1: Craig, 11 years old.
    Child #2: Sally, 10 years old.
    Child #3: N/A, 0 years old.
*/

Comentarios

Observe que en el ejemplo anterior solo se puede tener acceso a los campos privados (name y age) a través del método público de la Child clase . Por ejemplo, no puede imprimir el nombre del elemento secundario, desde el Main método , mediante una instrucción como esta:

Console.Write(child1.name);   // Error

El acceso a miembros privados de desde ChildMain solo sería posible si Main fuera miembro de la clase .

Los tipos declarados dentro de una clase sin un modificador de acceso tienen como valor predeterminado private, por lo que los miembros de datos de este ejemplo seguirían siendo private si se quitara la palabra clave .

Por último, observe que para el objeto creado con el constructor sin parámetros (child3), el age campo se inicializó en cero de forma predeterminada.

Especificación del lenguaje C#

Para obtener más información, consulte la Especificación del lenguaje C#. La especificación del lenguaje es el origen definitivo de la sintaxis y el uso de C#.

Consulte también

  • Last updated on