Dziedziczenie (Przewodnik programowania w języku C#)

Artykuł
06/10/2015

Dziedziczenie, wraz z hermetyzacji i polimorfizmu, jest jednym z trzech charakterystyki podstawowej (lub filarów) z programowaniem zorientowanym obiektowo.Dziedziczenie umożliwia tworzenie nowych klas, które ponownie używane, rozszerzenie i zmodyfikować zachowanie, które zdefiniowano w innych klasach.Klasa, której członkami są dziedziczone, jest nazywany klasy bazowej, i nosi nazwę klasy, która dziedziczy tych członków, klasy.Klasa pochodna może mieć tylko jeden bezpośrednia klasa podstawowa.Jednak dziedziczenie jest przechodnie.Jeśli klasa c wywodzi się z ClassB i ClassB jest pochodną ClassA, klasa c dziedziczy członków zadeklarowanych w ClassB i ClassA.

[!UWAGA]

Strukturach nie obsługuje dziedziczenia, ale mogą one zawierać interfejsy.Aby uzyskać więcej informacji, zobacz Interfejsy (Przewodnik programowania w języku C#).

Koncepcyjnie pochodna klasy jest klasą bazową.Na przykład, jeśli klasa podstawowa Animal, może mieć jedną klasę pochodnych, o nazwie Mammal i innym odziedziczonej z klasy o nazwie Reptile.A Mammal jest Animali Reptile jest Animal, ale każda Klasa pochodna reprezentuje różne kierunki klasy bazowej.

Podczas definiowania klasa pochodzi od klasy innej klasie pochodnej niejawnie zyski członków klasy podstawowej, z wyjątkiem dla jego konstruktory i destruktory.W klasie pochodnej tym samym kod można wykorzystywać w klasie bazowej bez konieczności jej CMC.W klasie pochodnej można dodać więcej członków.W ten sposób w klasie pochodnej rozszerza funkcjonalność klasy podstawowej.

Na poniższej ilustracji przedstawiono klasy WorkItem , oznaczającą element pracy procesu biznesowego, niektóre.Podobnie jak wszystkie klasy pochodzi od Object i dziedziczy jej metody.WorkItemdodaje pięciu członków własnej.Obejmują one konstruktora, ponieważ nie są dziedziczone przez konstruktorów.Klasa ChangeRequest dziedziczy z WorkItem i reprezentuje określonego rodzaju elementu pracy.ChangeRequestdodaje dwa więcej członków do członków, które dziedziczy z WorkItem i Object.Musi ona dodać własne konstruktora, a także dodaje originalItemID.Właściwość originalItemID umożliwia ChangeRequest instancji mają być skojarzone z oryginalnego WorkItem dotyczy żądanie zmiany.

Dziedziczenie klas

Dziedziczenie oparte na klasach

Poniższy przykład pokazuje, jak relacje klasy wykazane na poprzedniej ilustracji są wyrażone w języku C#.W przykładzie pokazano, również jak WorkItem zastępuje metodę wirtualnego Object.ToStringoraz sposób, w jaki ChangeRequest dziedziczy z klasy WorkItem implementacji metody.

// WorkItem implicitly inherits from the Object class. 
public class WorkItem
{
    // Static field currentID stores the job ID of the last WorkItem that 
    // has been created. 
    private static int currentID;

    //Properties. 
    protected int ID { get; set; }
    protected string Title { get; set; }
    protected string Description { get; set; }
    protected TimeSpan jobLength { get; set; }

    // Default constructor. If a derived class does not invoke a base- 
    // class constructor explicitly, the default constructor is called 
    // implicitly.  
    public WorkItem()
    {
        ID = 0;
        Title = "Default title";
        Description = "Default description.";
        jobLength = new TimeSpan();
    }

    // Instance constructor that has three parameters. 
    public WorkItem(string title, string desc, TimeSpan joblen)
    {
        this.ID = GetNextID();
        this.Title = title;
        this.Description = desc;
        this.jobLength = joblen;
    }

    // Static constructor to initialize the static member, currentID. This 
    // constructor is called one time, automatically, before any instance 
    // of WorkItem or ChangeRequest is created, or currentID is referenced. 
    static WorkItem()
    {
        currentID = 0;
    }


    protected int GetNextID()
    {
        // currentID is a static field. It is incremented each time a new 
        // instance of WorkItem is created. 
        return ++currentID;
    }

    // Method Update enables you to update the title and job length of an 
    // existing WorkItem object. 
    public void Update(string title, TimeSpan joblen)
    {
        this.Title = title;
        this.jobLength = joblen;
    }

    // Virtual method override of the ToString method that is inherited 
    // from System.Object. 
    public override string ToString()
    {
        return String.Format("{0} - {1}", this.ID, this.Title);
    }
}

// ChangeRequest derives from WorkItem and adds a property (originalItemID)  
// and two constructors. 
public class ChangeRequest : WorkItem
{
    protected int originalItemID { get; set; }

    // Constructors. Because neither constructor calls a base-class  
    // constructor explicitly, the default constructor in the base class 
    // is called implicitly. The base class must contain a default  
    // constructor. 

    // Default constructor for the derived class. 
    public ChangeRequest() { }

    // Instance constructor that has four parameters. 
    public ChangeRequest(string title, string desc, TimeSpan jobLen,
                         int originalID)
    {
        // The following properties and the GetNexID method are inherited  
        // from WorkItem. 
        this.ID = GetNextID();
        this.Title = title;
        this.Description = desc;
        this.jobLength = jobLen;

        // Property originalItemId is a member of ChangeRequest, but not  
        // of WorkItem. 
        this.originalItemID = originalID;
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of WorkItem by using the constructor in the  
        // base class that takes three arguments.
        WorkItem item = new WorkItem("Fix Bugs",
                                     "Fix all bugs in my code branch",
                                     new TimeSpan(3, 4, 0, 0));

        // Create an instance of ChangeRequest by using the constructor in 
        // the derived class that takes four arguments.
        ChangeRequest change = new ChangeRequest("Change Base Class Design",
                                                 "Add members to the class",
                                                 new TimeSpan(4, 0, 0),
                                                 1);

        // Use the ToString method defined in WorkItem.
        Console.WriteLine(item.ToString());

        // Use the inherited Update method to change the title of the  
        // ChangeRequest object.
        change.Update("Change the Design of the Base Class",
            new TimeSpan(4, 0, 0));

        // ChangeRequest inherits WorkItem's override of ToString.
        Console.WriteLine(change.ToString());

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    1 - Fix Bugs
    2 - Change the Design of the Base Class
*/

Metody abstrakcyjne i wirtualnych

Gdy klasa podstawowa deklaruje metody jako wirtualnego, klasy pochodnej można zastąpić z własną implementację metody.Jeśli klasa podstawowa deklaruje członka, jak abstrakcyjna, że metoda musi zostać zastąpiony w każda klasa nieabstrakcyjna, która bezpośrednio dziedziczy z klasy.Jeżeli sama jest pochodna klasy abstrakcyjne, dziedziczy ona abstrakcyjna członków bez ich wykonania.Abstrakcyjna i wirtualna członków są podstawy polimorfizmu, która jest drugim podstawowym cecha Programowanie zorientowane obiektowo.Aby uzyskać więcej informacji, zobacz Polimorfizm (Przewodnik programowania w języku C#).

Abstrakcyjne klasy podstawowej

Można zadeklarować klasy jako abstrakcyjna , jeśli chcesz zapobiec wystąpienia bezpośrednie za pomocą Nowy słowa kluczowego.Jeśli to zrobisz, klasa może być używana tylko wtedy, gdy nowa klasa pochodzi od niego.Klasa abstrakcyjna może zawierać jedną lub więcej podpisów metodę tym samych są deklarowane jako abstrakcyjne.Te podpisy określenia parametrów i zwraca wartość, ale nie implementacją (metoda treść).Klasa abstrakcyjna nie zawiera abstrakcyjny członków; Jednak jeśli klasa zawiera abstrakcyjny członek, ta sama klasa musi być zadeklarowany jako abstract.Klas pochodnych, które nie jest abstrakcyjna same musi zapewnić wprowadzenie w życie dla wszelkich metody abstrakcyjne z abstrakcyjna klasa podstawowa.Aby uzyskać więcej informacji, zobacz Klasy abstrakcyjne i zapieczętowane oraz członkowie klas (Przewodnik programowania w języku C#).

Interfejsy

Interfejsu jest typ odwołania, które przypomina nieco abstrakcyjna klasa podstawowa, która składa się tylko abstrakcyjna członków.Gdy klasy implementuje interfejs, musi zapewniać implementację, dla wszystkich członków interfejsu.Klasę można zaimplementować wiele interfejsów, mimo to można czerpać z tylko jednego bezpośredniego klasą bazową.

Interfejsy służą do definiowania określonych możliwości dla klas, które nie muszą koniecznie "jest" relacji.Na przykład IEquatable interfejsu może być implementowana przez wszystkie klasy lub struct, który ma umożliwić kod klienta określić, czy dwa obiekty tego typu są równoważne (Jednakże typ definiuje równoważności).IEquatablenie oznacza to samo kind of "jest" relacji między klasą bazową i klasy pochodne (na przykład, Mammal jest Animal).Aby uzyskać więcej informacji, zobacz Interfejsy (Przewodnik programowania w języku C#).

Dostęp do klas pochodnych członkom klasy podstawowej

Klasa pochodna ma dostęp do publicznych, chronione, wewnętrznego i chronione wewnętrznego członkowie klasy podstawowej.Mimo że pochodne klasa dziedziczy członków prywatnych klasy podstawowej, nie można uzyskać dostępu tych członków.Tych członków prywatnych są nadal obecne w klasie pochodnej i można wykonać tej samej pracy, może zrobić w samej klasy podstawowej.Załóżmy na przykład, metoda klasy bazowej chronionych uzyskuje dostęp do prywatnych pola.To pole musi być obecny w klasie pochodnej metody dziedziczone klasy podstawowej, która ma działać poprawnie.

Zapobieganie dalsze wyznaczania informacji pochodnych

Klasę można zapobiec dziedziczeniu z go lub któregokolwiek z członków, oświadczając, sam lub jako członek innych klas zamkniętych.Aby uzyskać więcej informacji, zobacz Klasy abstrakcyjne i zapieczętowane oraz członkowie klas (Przewodnik programowania w języku C#).

Pochodne ukrywanie klasy członków klasy podstawowej

Klasy pochodnej można ukryć składniki klasy podstawowej, oświadczając członków o tej samej nazwie i podpisie.Nowy modyfikator może służyć do wyraźnie wskazują, że członek nie ma być przesłonięcie podstawowego elementu członkowskiego.Wykorzystania nowych nie jest wymagane, ale jeśli zostanie wygenerowany przez kompilator ostrzeżenia nowych nie jest używany.Aby uzyskać więcej informacji, zobacz Przechowywanie wersji zastępowania i nowych słów kluczowych (Przewodnik programowania w języku C#) i Użycie zastępowania i nowych słów kluczowych (Przewodnik programowania w języku C#).