Unlike C++, only single inheritance is allowed in C#. In other words, a class can inherit implementation from one base class only. However, a class can implement more than one interface. The following table shows examples of class inheritance and interface implementation:

The access levels protected and private are only allowed on nested classes.

You can also declare generic classes that have type parameters; see Generic Classes for more information.

A class can contain declarations of the following members:

• Constructors

• Destructors

• Constants

• Fields

• Methods

• Properties

• Indexers

• Operators

• Events

• Delegates

• Classes

• Interfaces

• Structs

The following example demonstrates declaring class fields, constructors, and methods. It also demonstrates object instantiation and printing instance data. In this example, two classes are declared, the Child class, which contains two private fields (name and age) and two public methods. The second class, StringTest, is used to contain 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.
*/

Notice, in the preceding example, that the private fields (name and age) can only be accessed through the public methods of the Child class. For example, you cannot print the child's name, from the Main method, using a statement like this:

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

Accessing private members of Child from Main would only be possible if Main were a member of the class.

Types declared inside a class without an Access Modifier default to private, so the data members in this example would still be private if the keyword were removed.

Finally, notice that for the object created using the default constructor (child3), the age field was initialized to zero by default.

For more information, see the C# Language Specification. The language specification is the definitive source for C# syntax and usage.

Reference

Concepts

Other Resources

A diferencia de C++, en C# sólo se permite la herencia simple. En otras palabras, una clase puede heredar la implementación de una sola clase base. Sin embargo, una clase puede implementar más de una interfaz. La siguiente tabla muestra ejemplos de herencia de clases e implementación de interfaces:

Los niveles de acceso protected y private sólo se permiten en clases anidadas.

También se pueden declarar clases genéricas que tengan parámetros de tipo; vea Clases genéricas (Guía de programación de C#) para obtener más información.

Una clase puede contener declaraciones de los siguientes miembros:

• Constructores

• Destructores

• Constantes

• Campos

• Métodos

• Propiedades

• Indizadores

• Operadores

• Eventos

• Delegados

• Clases

• Interfaces

• Structs

En el siguiente ejemplo se muestra la declaración de 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 clase Child, que contiene dos campos privados (name y age) y dos métodos públicos. La segunda clase, StringTest, se utiliza 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.
*/

En el ejemplo anterior, observe que sólo se puede obtener acceso a los campos privados (name y age) a través de los métodos públicos de la clase Child. Por ejemplo, no es posible imprimir el valor name de la clase child desde el método Main con una instrucción como ésta:

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

El acceso a los miembros privados de Child desde Main sólo sería posible si Main fuera un miembro de la clase.

Los tipos declarados en una clase sin un modificador de acceso tienen como valor predeterminado private, de modo que los miembros de datos de este ejemplo seguirían siendo private aunque se quite la palabra clave.

Por último, observe que, para el objeto creado mediante el constructor predeterminado (child3), el campo age se inicializó a cero de forma predeterminada.

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

Referencia

Conceptos

Otros recursos