Compartilhar via

Programação orientada a objeto (C# e Visual Basic)

  • Artigo

Todos os idiomas gerenciados no .NET Framework, como o Visual Basic e o C#, oferecem suporte completo para a programação orientada a objetos que inclui encapsulamento, herança e polimorfismo.

Encapsulamento significa que um grupo de propriedades, métodos e outros membros relacionados são tratados como uma unidade ou um objeto único.

Herança descreve a habilidade de se criarem novas classes baseadas em uma classe existente.

Polimorfismo significa que você pode ter múltiplas classes que podem ser usadas intercambiavelmente, mesmo que cada classe implemente as mesmas propriedades e métodos de modos diferentes.

Esta seção descreve os seguintes conceitos:

  • Classes e Objetos

    • Membros de Classe

      Propriedades e campos

      Métodos

      Construtores

      Destruidores

      Eventos

      Classes Aninhadas

    • Modificadores de acesso e níveis de acesso

    • Instanciar Classes

    • Classes e membros estáticos (compartilhados)

    • Tipos anônimos

  • Herança

    • Substituindo membros

  • Interfaces

  • Genéricos

  • Delegados

Classes e Objetos

Os termos classe e objeto são às vezes usados representando a mesma coisa, mas na verdade, classes descrevem o tipo de objetos, enquanto objetos são instâncias úteis de classes. Dessa forma, o ato de criar um objeto é chamado de instanciação. Usando a analogia da planta, a classe é a planta, e o objeto é a construção feita daquela planta.

Definindo uma classe:

Class SampleClass
End Class

class SampleClass
{
}

O Visual Basic e o C# também fornecem uma versão light de classes chamadas estruturas que são úteis quando você precisa criar uma grande matriz de objetos e não deseja consumir muita memória para isso.

Definindo uma estrutura:

Structure SampleStructure
End Structure

struct SampleStruct
{
}

Para obter mais informações, consulte:

Membros de Classe

Cada classe pode ter membros de classe diferentes que incluem propriedades que descrevem dados de classe, métodos que definem o comportamento da classe e eventos que fornecem comunicação entre classes e objetos diferentes.

Propriedades e campos

Campos e propriedades representam informações que um objeto contém. Campos são como variáveis, porque eles podem ser lidos ou definidos diretamente.

Para definir um campo:

Class SampleClass
    Public SampleField As String
End Class

Class SampleClass
{
    public string sampleField;
}

As propriedades têm procedimentos get e set, o que oferece mais controle sobre como os valores são definidos e retornados.

C# e Visual Basic permitem que você crie um campo particular para armazenar o valor da propriedade ou use as propriedades autoimplementadas para chamadas que criam este campo automaticamente em segundo plano e fornecem lógica básica para os procedimentos de propriedade.

Para definir uma propriedade implementada automaticamente:

Class SampleClass
    Public Property SampleProperty as String
End Class

class SampleClass
{
    public int SampleProperty { get; set; }
}

Se você precisar realizar algumas operações adicionais para leitura e gravação do valor da propriedade, defina um campo para armazenar o valor da propriedade e forneça a lógica básica para armazenar e recuperá-lo:

Class Samplelass
    Private m_Sample As String
    Public Property Sample() As String
        Get
            ' Return the value stored in the field.
            Return m_Sample
        End Get
        Set(ByVal Value As String)
            ' Store the value in the field.
            m_Sample = Value
        End Set
    End Property
End Class

class SampleClass
{
    private int _sample;
    public int Sample
    {
        // Return the value stored in a field.
        get { return _sample; }
        // Store the value in the field.
        set { _sample = value; }
    }
}

A maioria das propriedades possuem métodos ou procedimentos para definir e obter o valor da propriedade. No entanto, você pode criar propriedades somente leitura ou somente gravação para impedir que elas sejam modificadas ou lidas. No Visual Basic você pode usar as palavras-chave ReadOnly e WriteOnly . Em C#, é possível omitir o método de propriedade get ou set . No entanto, no Visual Basic e no C#, as propriedades implementadas automaticamente não podem ser somente leitura ou somente gravação.

Para obter mais informações, consulte:

Métodos

Método é uma ação que um objeto pode executar.

Dica

No Visual Basic, há duas maneiras para criar um método: a declaração Sub é usada se o método não retorna um valor; a declaração Function é usada se um método retorna um valor.

Para definir um método de uma classe:

Class SampleClass
    Public Function SampleFunc(ByVal SampleParam As String)
        ' Add code here
    End Function
End Class

class SampleClass
{
    public int sampleMethod(string sampleParam)
    {
        // Insert code here
    }
}

Uma classe pode ter várias implementações ou sobrecargas do mesmo método que diferem no número de parâmetros ou tipos de parâmetro.

Para sobrecarregar um método:

Overloads Sub Display(ByVal theChar As Char)
    ' Add code that displays Char data.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
    ' Add code that displays Integer data.
End Sub

public int sampleMethod(string sampleParam) {};
public int sampleMethod(int sampleParam) {}

Na maioria dos casos, você declara um método em uma definição de classe. No entanto, o Visual Basic e o C# também suportam os métodos de extensão que permitem que você adicione métodos a uma classe existente fora da definição real da classe.

Para obter mais informações, consulte:

Construtores

Construtores são os métodos da classe que são executados automaticamente quando um objeto de um determinado tipo é criado. Os construtores geralmente inicializam os membros de dados do novo objeto. Um construtor pode executar apenas uma vez quando uma classe é criada. Além disso, o código no construtor é sempre executado antes de qualquer outro código em uma classe. No entanto, você pode criar várias sobrecargas de construtor da mesma maneira que cria para qualquer outro método.

Para definir um construtor para uma classe:

Class SampleClass
    Sub New(ByVal s As String)
        // Add code here.
    End Sub
End Class

public class SampleClass
{
    public SampleClass()
    {
        // Add code here
    }
}

Para obter mais informações, consulte:

Destruidores

Os destruidores são usados para destruir instâncias de classes. No .NET Framework, o coletor de lixo gerencia automaticamente a alocação e a liberação de memória para os objetos gerenciados em seu aplicativo. No entanto, você ainda pode precisar de destruidores para limpar os recursos não gerenciados que seu aplicativo criar. Pode haver apenas um destrutor para uma classe.

Para obter mais informações sobre destruidores e coleta de lixo no .NET Framework, consulte Coleta de Lixo.

Eventos

Os eventos permitem que uma classe ou um objeto notifiquem outros objetos ou classes quando algo interessante ocorre. A classe que envia (ou gera) o evento é chamada de editor e as classes que recebem (ou manipula) o evento são chamadas de assinantes. Para obter mais informações sobre eventos, como são gerados e manipulados, consulte Manipulando e acionando eventos.

Classes Aninhadas

Uma classe definida dentro de outra classe é chamada aninhada. Por padrão, a classe aninhada é privada.

Class Container
    Class Nested
    ' Add code here.
    End Class
End Class

class Container
{
    class Nested
    {
        // Add code here.
    }
}

Para criar uma instância da classe aninhada, use o nome da classe contêiner seguido pelo ponto e seguida pelo nome da classe aninhada:

Dim nestedInstance As Container.Nested = New Container.Nested()

Container.Nested nestedInstance = new Container.Nested()

Modificadores de acesso e níveis de acesso

Todas as classes e membros de classe podem especificar o nível de acesso que eles fornecem a outras classes usando modificadores de acesso.

Os modificadores de acesso a seguir estão disponíveis:

Modificador do Visual Basic

Modificador C#

Definição

Público (Visual Basic)

Público

O tipo ou membro pode ser acessado por qualquer outro código no mesmo assembly ou em outro assembly que faça referência a ele.

Particular (Visual Basic)

Particular

O tipo ou membro só pode ser acessado por código na mesma classe.

Protegido (Visual Basic)

protected

O tipo ou membro só pode ser acessado por código na mesma classe ou em uma classe derivada.

Friend (Visual Basic)

internal

O tipo ou membro pode ser acessado por qualquer código no mesmo assembly, mas não de outro assembly.

Protected Friend

protected internal

O tipo ou membro pode ser acessado por qualquer código no mesmo assembly ou por qualquer classe derivada em outro assembly.

Para obter mais informações, consulte Níveis de acesso no Visual Basic e Modificadores de acesso (Guia de Programação em C#).

Instanciar Classes

Para criar um objeto, você precisa instanciar uma classe ou criar uma instância de uma classe.

Dim sampleObject as New SampleClass()

SampleClass sampleObject = new SampleClass();

Depois de instanciar uma classe, você pode atribuir valores para as propriedades e os campos de instância e chamar métodos da classe.

' Set a property value.
sampleObject.SampleProperty = "Sample String"
' Call a method.
sampleObject.SampleMethod()

// Set a property value.
sampleObject.sampleProperty = "Sample String";
// Call a method.
sampleObject.sampleMethod();

Para atribuir valores a propriedades durante o processo de instanciação de classe, usa inicializadores de objeto:

Dim sampleObject = New SampleClass With 
    {.FirstProperty = "A", .SecondProperty = "B"}

// Set a property value.
SampleClass sampleObject = new SampleClass 
    { FirstProperty = "A", SecondProperty = "B" };

Para obter mais informações, consulte:

Classes e membros estáticos (compartilhados)

Um membro estático (compartilhado no Visual Basic) da classe é uma propriedade, um procedimento ou um campo compartilhado por todas as instâncias de uma classe.

Para definir um membro estático (compartilhado):

Class SampleClass
    Public Shared SampleString As String = "Sample String"
End Class

static class SampleClass
{
    public static string SampleString = "Sample String";
}

Para acessar o membro estático (compartilhado), use o nome da classe sem criar um objeto dessa classe:

MsgBox(SampleClass.SampleString)

Console.WriteLine(SampleClass.SampleString);

As classes estáticas (compartilhadas) no C# e os módulos no Visual Basic só têm membros estáticos (compartilhados) e não podem ser instanciados. Os membros estáticos (compartilhados) também não podem acessar propriedades, campos ou métodos não estáticos (não compartilhados)

Para obter mais informações, consulte:

Tipos anônimos

Tipos anônimos permitem que você crie objetos sem escrever uma definição de classe para o tipo de dados. Em vez disso, o compilador gera uma classe para você. A classe não possui um nome utilizável e contém as propriedades especificadas na declaração do objeto.

Para criar uma instância de um tipo anônimo:

' sampleObject is an instance of a simple anonymous type.
Dim sampleObject = 
    New With {Key .FirstProperty = "A", .SecondProperty = "B"}

// sampleObject is an instance of a simple anonymous type.
var sampleObject = 
    new { FirstProperty = "A", SecondProperty = "B" };

Para obter mais informações, consulte:

Herança

A herança permite que você crie uma nova classe que reutiliza, estende e altera o comportamento que é definido em outra classe. A classe cujos membros são herdados é chamada de classe base e a classe que herda os membros é chamada de classe derivada. No entanto, todas as classes no C# e no Visual Basic são implicitamente herdadas da classe Object que oferece suporte à hierarquia de classe .NET e fornece serviços de baixo nível a todas as classes.

Dica

Idiomas gerenciados no .NET Framework não oferecem suporte a várias heranças, ou seja, você pode especificar somente uma classe base para uma classe derivada.

Herdando de uma classe base:

Class DerivedClass
    Inherits BaseClass
End Class

class DerivedClass:BaseClass{}

Por padrão, todas as classes podem ser herdadas. No entanto, você pode especificar se uma classe não deve ser usada como uma classe base ou criar uma classe que pode ser usada somente como uma classe base.

Para especificar que uma classe não pode ser usada como classe base:

NotInheritable Class SampleClass
End Class

public sealed class A { }

Para especificar que uma classe pode ser usada apenas como uma classe base e não pode ser instanciada:

MustInherit Class BaseClass
End Class

public abstract class B { }

Para obter mais informações, consulte:

Substituindo membros

Por padrão, uma classe derivada herda todos os membros da classe base. Se quiser alterar o comportamento do membro herdado, você precisará substituí-lo. Ou seja, você pode definir uma nova implementação do método, propriedade ou evento na classe derivada.

Os modificadores a seguir são usados para controlar como as propriedades e métodos são substituídos:

Modificador do Visual Basic

Modificador C#

Definição

Substituível (Visual Basic)

virtual (Referência de C#)

Permite que um membro da classe seja substituído em uma classe derivada.

Substituições (Visual Basic)

override (Referência de C#)

Substitui um membro virtual (substituível) definido na classe base.

NotOverridable (Visual Basic)

Sem suporte

Impede que um membro seja substituído em uma classe herdeira.

MustOverride (Visual Basic)

abstract (Referência de C#)

Exige que um membro da classe seja substituído na classe derivada.

Sombras (Visual Basic)

Modificador new (Referência de C#)

Oculta um membro herdado de uma classe base

Interfaces

Interfaces, como classes, definem um conjunto de propriedades, métodos e eventos. Mas, ao contrário das classes, as interfaces não fornecem implementação. São implementados por classes e definidos como entidades separadas de classes. Uma interface representa um contrato, em que uma classe que implementa uma interface deve implementar cada aparência da interface exatamente como é definida.

Definindo uma interface:

Public Interface ISampleInterface
    Sub DoSomething()
End Interface

interface ISampleInterface
{
    void doSomething();
}

Para implementar uma interface em uma classe:

Class SampleClass
    Implements ISampleInterface
    Sub DoSomething
        ' Method implementation.
    End Sub
End Class

class SampleClass : ISampleInterface
{
    void ISampleInterface.doSomething()
    {
        // Method implementation.
    }
}

Para obter mais informações, consulte:

Genéricos

Classes, estruturas, interfaces e métodos no .NET Framework podem incluir parâmetros de tipo que definem tipos de objetos que podem armazenar ou usar. O exemplo mais comum de genéricos é uma coleção, onde você pode especificar o tipo de objetos a serem armazenados em uma coleção.

Definindo uma classe genérica:

Class SampleGeneric(Of T)
    Public Field As T
End Class

Public class SampleGeneric<T> 
{
    public T Field;
}

Para criar uma instância de uma classe genérica:

Dim sampleObject As New SampleGeneric(Of String)
sampleObject.Field = "Sample string"

SampleGeneric<string> sampleObject = new SampleGeneric<string>();
sampleObject.Field = "Sample string";

Para obter mais informações, consulte:

Delegados

Um representante é um tipo que define uma assinatura de método e pode fornecer uma referência a qualquer método com uma assinatura compatível. É possível chamar o método através do delegate. Representantes são usados para passar métodos como argumentos para outros métodos.

Dica

Os manipuladores de eventos nada mais são do que métodos chamados por meio dos representantes.Para obter mais informações sobre o uso de delegados na manipulação de eventos, consulte Manipulando e acionando eventos.

Para criar um representante:

Delegate Sub SampleDelegate(ByVal str As String)

public delegate void SampleDelegate(string str);

Para criar uma referência a um método que corresponda à assinatura especificado pelo delegado:

Class SampleClass
    ' Method that matches the SampleDelegate signature.
    Sub SampleSub(ByVal str As String)
        ' Add code here.
    End Sub
    ' Method that instantiates the delegate.
    Sub SampleDelegateSub()
        Dim sd As SampleDelegate = AddressOf SampleSub
        sd("Sample string")
    End Sub
End Class

class SampleClass
{
    // Method that matches the SampleDelegate signature.
    public static void sampleMethod(string message)
    {
        // Add code here.
    }
    // Method that instantiates the delegate.
    void SampleDelegate()
    {
        SampleDelegate sd = sampleMethod;
        sd("Sample string");
    }
}

Para obter mais informações, consulte:

Consulte também

Conceitos

Guia de Programação em C#

Outros recursos

Guia de programação do Visual Basic