Herança e classes derivado (versus translation from VPE for Csharp Java)

Artigo
08/25/2010

Você pode estender a funcionalidade de uma classe existente, criando uma nova classe que deriva da classe existente.A classe derivada herda sistema autônomo propriedades da classe base, e você pode adicionar ou substituir sistema autônomo métodos e propriedades conforme necessário.

Em translation from VPE for Csharp, herança e a implementação de interface são definidos pelo : operador, equivalente a extends e implements em Java. A classe base deve ser sempre mais à esquerda na declaração da classe.

Como Java, translation from VPE for Csharp não oferece suporte à herança múltipla, o que significa que classes não podem herdar de mais de uma classe.No entanto, você pode usar interfaces para essa finalidade da mesma forma sistema autônomo em Java.

O código a seguir define uma classe chamada CoOrds com duas variáveis de membro privado x e y que representa a posição do ponto. Essas variáveis são acessadas por meio de propriedades chamadas X e Y respectivamente:

public class CoOrds
{
    private int x, y;

    public CoOrds()  // constructor
    {
        x = 0;
        y = 0;
    }

    public int X
    {
        get { return x; }
        set { x = value; }
    }

    public int Y
    {
        get { return y; }
        set { y = value; }
    }
}

Você derivar uma nova classe, chamada ColorCoOrds, da CoOrds classe, da seguinte maneira:

public class ColorCoOrds : CoOrds

ColorCoOrds em seguida, herda todos os campos e métodos da classe base, para que você pode adicionar novos para fornecer recursos adicionais na classe derivada de acordo com a nossas necessidades. Neste exemplo, você pode adicionar um membro particular e acessadores para adicionar cor à classe:

public class ColorCoOrds : CoOrds
{
    private System.Drawing.Color screenColor;


    public ColorCoOrds()  // constructor
    {
        screenColor = System.Drawing.Color.Red;
    }

    public System.Drawing.Color ScreenColor
    {
        get { return screenColor; }
        set { screenColor = value; }
    }
}

O construtor da classe derivada implicitamente chama o construtor para a classe base ou a superclasse na terminologia do Java.Em herança, todos os construtores de classe base são chamados antes de construtores de classe derivada na ordem em que as classes aparecem na hierarquia de classes do.

Typecasting para uma classe base

sistema autônomo em Java, você não pode usar uma referência a uma classe base para acessar sistema autônomo membros e métodos de uma classe derivada, mesmo se a referência de classe base pode conter uma referência válida a um objeto do tipo derivado.

Você pode referenciar uma classe derivada implicitamente com uma referência para o tipo derivado:

ColorCoOrds color1 = new ColorCoOrds();
CoOrds coords1 = color1;

Esse código, a referência da classe base, coords1, contém uma cópia das color1 referência.

A palavra-chave base

Você pode acessar membros de classe base em uma subclasse mesmo quando esses membros base são substituídos na superclasse usando o base palavra-chave.Para instância, você pode criar uma classe derivada que contém um método com a mesma assinatura sistema autônomo na classe base.Se antecedido esse método com o novo palavra-chave, que você indica que esse é um novo método pertencentes à classe derivada.Ainda é possível fornecer um método para acessar o método original na classe base com a palavra-chave base.

Por exemplo, digamos que seu base CoOrds classe tivesse um método chamado Invert(), que as trocas de x e y coordenadas. Você poderia fornecer um substituto para este método no seu derivada ColorCoOrds classe com código como este:

public new void Invert()
{
    int temp = X;
    X = Y;
    Y = temp;
    screenColor = System.Drawing.Color.Gray;
}

sistema autônomo você pode ver, esse método troca x e ye, em seguida, define cor sistema autônomo coordenadas cinza. Você pode fornecer acesso a implementação base para este método, criando outro método em ColorCoOrds, sistema autônomo este:

public void BaseInvert()
{
    base.Invert();
}

Você então chama o método base em um ColorCoOrds objeto chamando o BaseInvert() método.

ColorCoOrds color1 = new ColorCoOrds();
color1.BaseInvert();

Lembre-se de que você obteria o mesmo efeito se você tiver atribuído uma referência à classe base a uma instância de ColorCoOrdse, em seguida, acessado seus métodos:

CoOrds coords1 = color1;
coords1.Invert();

Selecionando construtores

Objetos de classe base são sempre construídos antes de qualquer classe deriving.Assim, o construtor da classe base será executado antes o construtor da classe derivada.Se a classe base tiver mais de um construtor, a classe derivada pode decidir o construtor deve ser chamado.Por exemplo, você poderia modificar o seu CoOrds classe para adicionar um segundo construtor, da seguinte maneira:

public class CoOrds
{
    private int x, y;

    public CoOrds()
    {
        x = 0;
        y = 0;
    }

    public CoOrds(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

Em seguida, você poderia alterar o ColorCoOrds classe para usar um determinado dos construtores disponível usando a palavra-chave base:

public class ColorCoOrds : CoOrds
{
    public System.Drawing.Color color;

    public ColorCoOrds() : base ()
    {
        color = System.Drawing.Color.Red;
    }

    public ColorCoOrds(int x, int y) : base (x, y)
    {
        color = System.Drawing.Color.Red;
    }
}

Em Java, essa funcionalidade é implementada usando o super palavra-chave.

Substituição do método

Uma classe derivada pode substituir o método de uma classe base, fornecendo uma nova implementação do método declarado.Uma distinção importante entre Java e translation from VPE for Csharp é que por padrão, sistema autônomo métodos Java são marcados sistema autônomo virtual, ao mesmo tempo em translation from VPE for Csharp, métodos devem ser explicitamente marcados sistema autônomo virtual usando o virtualmodificador de .Acessadores de propriedade, bem sistema autônomo métodos, podem ser substituídos da mesma maneira.

Métodos virtual

Um método a ser substituído em uma classe derivada é declarado com o virtual modificador. Em uma classe derivada, o método substituído é declarado usando a Substituirmodificador de .

The override modificador indica um método ou propriedade de uma classe derivada que substitui uma com o mesmo nome e assinatura na classe base. O método base, que é para ser substituído, deve ser declarado sistema autônomo virtual, Resumo, or override: não é possível substituir um método estático ou não-virtual dessa maneira.Tanto a substituição e a substituição de método ou propriedade deve ter os modificadores de nível de acesso mesmos.

O exemplo a seguir mostra um método virtual chamado StepUp que é substituída em uma classe derivada com o modificador de substituir:

public class CountClass 
{
    public int count; 

    public CountClass(int startValue)  // constructor
    {
        count = startValue;
    }

    public virtual int StepUp()
    {
        return ++count;
    }
}

class Count100Class : CountClass 
{
    public Count100Class(int x) : base(x)  // constructor 
    {
    }

    public override int StepUp()
    {
        return ((base.count) + 100);
    }
}

class TestCounters
{
    static void Main()
    {
        CountClass counter1 = new CountClass(1);
        CountClass counter100 = new Count100Class(1);

        System.Console.WriteLine("Count in base class = {0}", counter1.StepUp());
        System.Console.WriteLine("Count in derived class = {0}", counter100.StepUp());
    } 
}

Quando você executa esse código, verá que construtor a classe derivada do usa o corpo do método fornecido na classe base, permitindo que você inicializar o membro contagem sem duplicar esse código.Aqui está a saída:

Count in base class = 2

Count in derived class = 101

Classes abstratas

Uma classe abstrata declara um ou mais métodos ou propriedades sistema autônomo abstrato.Esses métodos não possuem uma implementação fornecida na classe que declara, embora uma classe abstrata também pode conter métodos não-abstrata, ou seja, os métodos para o qual foi fornecida uma implementação.Uma classe abstrata não pode ser instanciada diretamente, mas somente sistema autônomo uma classe derivada.Essas classes derivadas devem fornecer implementações para todos os métodos abstratos e propriedades, usando o override palavra-chave, a menos que o membro derivado é declarado como abstrato.

O exemplo a seguir declara um abstrata Employee classe. Você também cria uma classe derivada chamada Manager que fornece uma implementação do resumo Show() método definido no Employee classe:

public abstract class Employee 
{ 
    protected string name;

    public Employee(string name)  // constructor
    { 
        this.name = name;
    }

    public abstract void Show();  // abstract show method
}

public class Manager: Employee
{ 
    public Manager(string name) : base(name) {}  // constructor

    public override void Show()  //override the abstract show method
    {
        System.Console.WriteLine("Name : " + name);
    }
}

class TestEmployeeAndManager
{ 
    static void Main()
    { 
        // Create an instance of Manager and assign it to a Manager reference:
        Manager m1 = new Manager("H. Ackerman");
        m1.Show();

        // Create an instance of Manager and assign it to an Employee reference:
        Employee ee1 = new Manager("M. Knott");
        ee1.Show();  //call the show method of the Manager class
    } 
}

Este código chama a implementação de Show() fornecido pela Manager classe e imprime os nomes dos funcionários na tela. Aqui está a saída:

Name : H. Ackerman

Name : M. Knott

Interfaces

Uma interface é uma espécie de classe de esqueleto, que contêm assinaturas de método, mas não há implementações do método.Dessa forma, as interfaces são como classes abstratas que contêm apenas métodos abstratos.Interfaces translation from VPE for Csharp são muito semelhantes às interfaces de Java e funcionam praticamente da mesma forma.

Todos os membros de uma interface são públicos por definição e uma interface não pode conter campos (membros de dados particulares), constantes, construtores, destruidores ou qualquer tipo de membro estático.O compilador gerará um erro se for especificado nenhum modificador para os membros de uma interface.

É possível derivar classes a partir de uma interface para implementar essa interface.Essas classes derivadas devem fornecer implementações para todos os método da interface, a menos que a classe derivada está declarado como abstrata.

Uma interface é declarada forma idêntica para Java.Em uma definição de interface, uma propriedade indica somente seu tipo, e se ele é somente leitura, somente gravar ou de leitura/gravar por obter and conjunto as palavras-chave no sozinhas.A interface abaixo declara uma propriedade somente leitura:

public interface ICDPlayer
{ 
    void Play();  // method signature
    void Stop();  // method signature

    int FastForward(float numberOfSeconds);

    int CurrentTrack  // read-only property
    {
        get;
    } 
}

Uma classe pode herdar desta interface com dois-pontos em vez de implements palavra-chave. A implementação da classe deve fornecer definições para todos sistema autônomo métodos e qualquer necessário acessadores de propriedade, da seguinte maneira:

public class CDPlayer : ICDPlayer
{
    private int currentTrack = 0;

    // implement methods defined in the interface
    public void Play()
    {
        // code to start CD...
    }

    public void Stop()
    {
        // code to stop CD...
    }

    public int FastForward(float numberOfSeconds)
    {
        // code to fast forward CD using numberOfSeconds...

        return 0;  //return success code
    }

    public int CurrentTrack  // read-only property
    { 
        get 
        { 
            return currentTrack; 
        } 
    }

    // Add additional methods if required...
}

Implementar várias interfaces

Uma classe pode implementar várias interfaces usando a seguinte sintaxe:

public class CDAndDVDComboPlayer : ICDPlayer, IDVDPlayer

Se uma classe implementa a interface mais de um onde não há ambigüidade nos nomes de membros, ele é resolvido usando o qualificador completo para o nome de propriedade ou método.Em Outros palavras, a classe derivada pode resolver o conflito, utilizando o nome totalmente qualificado para o método para indicar que interface ele pertence, sistema autônomo em ICDPlayer.Play().

Consulte também

Partilhar via