Herança (Guia de programação C#)

Artigo
08/25/2010

Herança, juntamente com o encapsulamento e polimorfismo, é um dos três características primárias (ou "pilares") da programação orientada a objeto.A herança permite que você criar novas classes que reutilizar, estendem e modificam o comportamento é definido em outras classes.A classe cujos membros são herdados é chamada a classe basee a classe que herda esses membros é chamada a classe derivada.

Observação:
Estruturas não oferecem suporte a inheritanc e , mas eles podem implementar interfaces.Para obter mais informações, consulte Interfaces (guia de programação C#).

Conceitualmente, uma classe derivada é uma especialização da classe base.Por exemplo, se você tiver uma classe base Animal, você pode ter uma classe derivada chamada Mammal e outra classe derivada chamada Reptile. A Mammal é um Animale um Reptile é um Animal, mas cada classe derivada representa especializações em diferentes da classe base.

Quando você define uma classe para derivar de outra classe, a classe derivada implicitamente obtém todos os membros da classe base, exceto para seus construtores e destrutores.A classe derivada, assim, pode reutilizar o código na classe base sem ter de reimplementar a ele.Na classe derivada, você pode adicionar mais membros.Dessa forma, a classe derivada estende a funcionalidade da classe base.

A ilustração a seguir mostra uma classe WorkItem que representa um item de trabalho em algum processo de negócios. Como todas as classes, ele deriva de System.Object e herda todos os seus métodos. WorkItem adiciona cinco membros próprios. Isso inclui um construtor, porque os construtores não são herdadas.ChangeRequest herda do WorkItem e representa um determinado tipo de item. ChangeRequest adiciona dois membros mais os membros que ele herda de WorkItem e Object. Ele deve adicionar seu próprio construtor e ele também adiciona um membro que permita o ChangeRequest a ser associado ao original WorkItem para o qual a alterar se aplica.

Herança de classe

O exemplo a seguir mostra como as relações de classe demonstradas na ilustração anterior são expressas em translation from VPE for Csharp.O exemplo também mostra como WorkItem substitui o método virtual Object.ToString e como o ChangeRequest classe herda o WorkItem implementação do método.

// WorkItem implicitly inherits from Object class
public class WorkItem
{
    private static int nextID;
    protected int ID { get; set; }
    protected TimeSpan jobLength { get; set; }
    protected string Title { get; set; }
    protected string Description { get; set; }
    // Default constructor
    public WorkItem() 
    {
        ID = 0;
        Title = "Default title";
        Description = "Default description.";
        jobLength = new TimeSpan();
    }
    // Static constructor for static member.
    static WorkItem()
    {
        nextID = 0;
    }
    // Instance constructor.
    public WorkItem( string title, string desc, TimeSpan joblen)
    {
        this.ID = GetNextID();                
        this.Title = title;
        this.Description = desc;
        this.jobLength = joblen;
    }
    protected int GetNextID()
    {
       return ++nextID;
    }
    public void Update(string title, TimeSpan joblen)
    {
        this.Title = title;
        this.jobLength = joblen;
    }

    // Virtual method override.
    public override string ToString()
    {
        return String.Format("{0} - {1}", this.ID, this.Title); 
    }
}

// ChangeRequest derives from WorkItem and adds two of its own members.
public class ChangeRequest : WorkItem
{
    protected int originalItemID {get; set;}
    public ChangeRequest() { }
    public ChangeRequest(string title, string desc, TimeSpan jobLen, int originalID)
    {
        this.ID = GetNextID();
        this.Title = title;
        this.Description = desc;
        this.jobLength = jobLen;
        this.originalItemID = originalID;
    }
}

class Program
{
    static void Main()
    {
        WorkItem item = new WorkItem(                                
                        "Fix Bugs", 
                        "Fix all bugs in my source code branch",
                        new TimeSpan(3, 4, 0, 0));

        ChangeRequest change = new ChangeRequest("Change design of base class",
                                                 "Add members to base class",
                                                 new TimeSpan(4, 0, 0),
                                                 1);

        Console.WriteLine(item.ToString());

        // 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 design of base class
*/

Métodos abstratos e virtual

Quando uma classe base declara um método sistema autônomo virtual de uma classe derivada podeSubstituir o método com sua própria implementação.Se uma classe base declara um membro sistema autônomo Resumo, que método deve ser substituído diretamente em qualquer classe não abstrata herda da classe.Se uma classe derivada é abstrai, e, em seguida, ele herda membros abstratos sem implementá-las.Os membros abstratos e virtual são a base para polimorfismo, que é a segunda característica principal da programação orientada a objeto.Para obter mais informações, consulte Polymorphism (guia de programação C#).

Classes base abstratas

Você pode declarar uma classe sistema autônomo Resumo se desejar impedir a instanciação direta por meio do novo palavra-chave.Se você fizer isso, a classe pode ser usada somente se uma nova classe é derivada dela.Uma classe abstrata pode conter uma ou mais assinaturas de método que se estão declaradas sistema autônomo abstrato.Essas assinaturas de especificam os parâmetros e retornam valor mas nenhuma implementação (corpo de método).Não tem uma classe abstrata conter membros abstratos; no entanto, se uma classe contiver um membro abstract, a própria classe deve ser declarada sistema autônomo abstrato.Classes derivadas que não são abstratas próprios devem fornecer a implementação de quaisquer métodos abstratos de uma classe base abstrata.Para obter mais informações, consulte Abstrato e Sealed classes e membros de classe (guia de programação C#) e Design de classe abstrata.

Interfaces

An interface é um tipo de referência que é um pouco semelhante a uma classe base abstrata que consiste somente os membros abstratos.Quando uma classe deriva de uma interface, ele deve fornecer uma implementação para todos os membros da interface.Uma classe pode implementar várias interfaces, mesmo que ele pode derivam apenas uma única direta classe base.

Interfaces são usadas para definir os recursos específicos para as classes que não têm necessariamente um "é uma" relação.Por exemplo, a IEquatable[`1] a interface pode ser implementada por qualquer classe ou struct que deve permitir código de cliente determinar se dois objetos do tipo são equivalentes (no entanto, o tipo define equivalência). IEquatable<T>não implica o mesmo tipo de "é uma" relação existente entre uma classe base e uma classe derivada (por exemplo, um Mammal é um Animal). Para obter mais informações, consulte Interfaces (guia de programação C#).

Acesso de classe derivada para membros de classe base

Uma classe derivada tem acesso aos membros internos públicos, protegidos, internos e protegidos de uma classe base.Mesmo que herda de uma classe derivada de particular membros de uma classe base, não pode acessar esses membros.No entanto, todos os membros privado ainda estão presentes na classe derivada e pode fazer o mesmo trabalho seria fazem a própria classe base.Por exemplo, suponha que um método da classe base protegida acessa um campo particular.Esse campo precisa estar presente na classe derivada para que o método da classe base herdados funcionar corretamente.

Impedindo adicional de derivação

Uma classe pode impedir que outras classes herde dele ou qualquer um dos seus membros, declarando propriamente dito ou o membro sistema autônomo selado.Para obter mais informações, consulte Abstrato e Sealed classes e membros de classe (guia de programação C#).

Ocultar classe derivada de membros de classe base

Uma classe derivada pode ocultar membros de classe base, declarando os membros com o mesmo nome e assinatura.The novo modificador pode ser usado para indicar explicitamente que o membro não deve ser uma substituir do membro base.O uso de novo não é necessária, mas um aviso de compilação será gerado se novo não é usado.Para obter mais informações, consulte Versão com o substituição e palavras-chave new (guia de programação C#) e Sabendo quando usar substituir e palavras-chave New (guia de programação translation from VPE for Csharp).