Condividi tramite

classe (Riferimenti per C#)

Le classi vengono dichiarate usando la parola chiave class, come illustrato nell'esempio seguente:

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

Osservazioni:

In C# è consentita solo l'ereditarietà singola. In altre parole, una classe può ereditare l'implementazione da una sola classe di base. Tuttavia, una classe può implementare più interfacce. La tabella seguente illustra esempi di implementazione dell'ereditarietà della classe e dell'interfaccia:

Ereditarietà Esempio
Nessuno class ClassA { }
Singolo class DerivedClass : BaseClass { }
Nessuno, implementa due interfacce class ImplClass : IFace1, IFace2 { }
Single, implementa un'interfaccia class ImplDerivedClass : BaseClass, IFace1 { }

Le classi dichiarate direttamente all'interno di uno spazio dei nomi, non annidate all'interno di altre classi, possono essere pubbliche o interne. Le classi sono internal per impostazione predefinita.

I membri della classe, incluse le classi annidate, possono essere pubblici, protetti interni, protetti, interni, privati o privati protetti. I membri sono private per impostazione predefinita.

Per altre informazioni, vedere Modificatori di accesso.

È possibile dichiarare classi generiche con parametri di tipo. Per altre informazioni, vedere Classi generiche.

Una classe può contenere dichiarazioni dei membri seguenti:

Esempio

Nell'esempio seguente viene illustrata la dichiarazione di campi di classe, costruttori e metodi. Illustra anche la creazione di istanze di oggetti e la stampa dei dati dell'istanza. In questo esempio vengono dichiarate due classi. La prima classe, Child, contiene due campi privati (name e age), due costruttori pubblici e un metodo pubblico. La seconda classe, StringTest, viene usata per contenere 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.
*/

Commenti

Si noti che nell'esempio precedente è possibile accedere ai campi privati (name e age) solo tramite il metodo pubblico della Child classe . Ad esempio, non è possibile stampare il nome dell'elemento figlio dal Main metodo usando un'istruzione simile alla seguente:

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

L'accesso ai membri privati di Child da Main sarebbe possibile solo se Main fosse membro della classe .

I tipi dichiarati all'interno di una classe senza un modificatore di accesso predefinito su private, quindi i membri dati in questo esempio sarebbero private ancora se la parola chiave fosse stata rimossa.

Si noti infine che per l'oggetto creato usando il costruttore senza parametri (child3), il age campo è stato inizializzato su zero per impostazione predefinita.

Specificazione del linguaggio C#

Per altre informazioni, vedere la specifica del linguaggio C#. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.

Vedere anche

  • Last updated on