VB.NET - Revisitando conceitos OOP

Você compreende bem os conceitos básicos da programação orientada a objetos ?

Esta a par dos conceitos de classe pai , classe filha , classe abstrata , sobrecarga e sobrescrita ?

Sabe implementar herança no VB.NET ?


 

Acompanhe o artigo e verifique como andam os seus conhecimentos sobre OOP.

- Para começar vou criar uma classe Pai com alguns métodos conforme abaixo:

Public MustInherit Class ClassePai

Public Function somar(ByVal a As Integer, ByVal b As Integer) As String
   Soma = a + b
End Function

Public Function somar(ByVal a As Integer) As String
   somar = a
End Function

Public Overridable Function subtrair(ByVal a As Integer, ByVal b As Integer) As String
  subtrair = a - b
End Function

Public Overridable Function subtrair(ByVal a As Integer) As String
   subtrair = a
End Function

Public MustOverride Function multiplicar(ByVal a As Integer, ByVal b As Integer) As String

Function expoente(ByVal a As Integer) As Integer
    expoente = a * a
End Function

Function expoente(ByVal a As Integer, ByVal b As Integer) As Integer
    expoente = a * b
End Function

End Class

Antes uma palavrinha sobre convenção usada para dar nome a classes e métodos.

No VB.NET eu utilizo a mesma convenção usada no Java : Nome de classes iniciam com letras Maiúsculas e nome de métodos com letras minúsculas.

Observando o código da classe ClassePai definida . Notamos que :

Quais as consequências disto ?

A utilização do modificador MustInherit indica que a classe esta destinada apenas a servir como base para a criação de outras classes , ou seja , não é possível criar instâncias direta desta classe. Se você tentar vai obter uma mensagem de erro conforme abaixo:

Uma classe declarada com o modificador MustInherit é também conhecida como classe abstrata ( Em Java usamos o modificador abstract )

Utilizando classes abstratas você pode declarar classes que definam apenas parte de uma implementação, deixando que as classes estendidas forneçam a implementação específica de alguns ou de todos os métodos. É o que vamos fazer neste exemplo...

Observe agora que a classe possui dois métodos chamados somar . O código esta abaixo :

Public Function somar(ByVal a As Integer, ByVal b As Integer) As String
   somar = a + b
End Function

Public Function somar(ByVal a As Integer) As String
   somar = a
End Function

Mas eu posso ter dois métodos com o mesmo nome ? Como o compilador vai saber qual deles chamar ?

Este é um exemplo de Sobrecarga (Overloading) . Na sobrecarga podemos criar dentro de uma classe diversos procedimentos (métodos) ou propriedades com o mesmo nome. O que distingue um método do outro é a sua lista de argumentos.

No exemplo temos dois métodos chamados somar que utilizam um número de argumentos diferentes.

A seguir temos dois métodos chamados subtrair .

Public Overridable Function subtrair(ByVal a As Integer, ByVal b As Integer) As String
  subtrair = a - b
End Function

Public Overridable Function subtrair(ByVal a As Integer) As String
   subtrair = a
End Function

Os dois métodos subtrair possuem o modificador Overridable e são também métodos públicos (Public)

A regra geral é que métodos públicos em uma classe são NotOverridable e para permitir que os métodos sejam sobrepostos você precisa indicar isto usando o modificador Overridable. Com isto estamos indicando que estes métodos poderão ser sobrepostos na classe-Filha.

O método multiplicar é interessante além de apenas conter a assinatura do método ele possui o modificador - MustOverride.

Obs: Assinatura é o nome do método e o número e os tipos dos parâmetros do método.

Quando você usa o modificador MustOverride você esta sinalizando de que vai precisar de uma classe herdada para sobrepor a propriedade ou método. Assim a definição do método consiste apenas de uma declaração Function (poderia ser Sub ou Property) sem um End Function ou End Sub.

As classes que possuem métodos declarados como MustOverride deve ser declaradas com o modificador MustInherit.

Neste caso você apenas declarou o método , obrigando assim a classe herdada a ter que definir o método.

Vou agora criar a classe-Filha

Public Class ClasseFilha
          Inherits ClassePai

Overloads Function subtrair(ByVal a As Integer, ByVal b As Integer, ByVal c As Integer) As String
   subtrair = 5 + (a)
End Function

Overrides Function multiplicar(ByVal a As Integer, ByVal b As Integer) As String
   multiplicar = a * b
End Function

Shadows Function expoente() As String
    expoente = "Chamado a partir da classe Filha"
End Function

End Class
 

A classe ClasseFilha estende da classe - ClassePai - é isto que indica a declaração Inherits. Ela identifica a classe base da qual esta herdando os métodos e propriedades.

Obs: Quando você estende uma classe para criar uma nova classe , a nova classe estendida herda todos os campos e métodos da classe que foi estendida. A classe original na qual a extensão é baseada é conhecida como  classe Pai , classe base ou superclasse.

A classe ClasseFilha possui três métodos.

O método subtrair possui o modificador Overloads que indica que o método esta sobrecarregado , ou seja , existe outro método com o mesmo nome mas com argumentos diferentes. Temos dois métodos subtrair na classe Pai e o método definido na classe filha todos utilizam argumentos diferentes e o compilador vai chamar o método de acordo com os argumentos que você usar.

A classe multiplicar possui o modificador Overrides ele  permite que você sobreponha o método definido na classe base. Aliás você é obrigado a definir a classe multiplicar na classe Filha se não fizer isto o VB.NET vai reclamar conforme indica a figura abaixo:

Para encerrar vejamos o método expoente que é definido assim :

Shadows Function expoente() As String
  expoente = "Chamado a partir da classe Filha"
End Function
 

O que significa o modificador Shadows no método ?

A palavra chave Shadows significa que quando um membro de uma classe derivada possuir o mesmo nome que um membro do mesmo tipo em uma classe Pai , o membro na classe derivada substitui inteiramente todas as variações do método da classe Pai deixando a classe derivada com somente uma versão do método : aquele que foi definida na classe derivada.

Shadows também indica que o  nome de um membro da classe Pai ou classe Base pode ser reutilizado na classe herdada mesmo que por outro tipo de membro. Assim você pode usar o nome de uma propriedade definida na classe Pai como um método na classe Filha. O método definido com o modificador Shadows vai 'encobrir'  o método da classe Pai.

No nosso exemplo o método expoente definido na classe Filha com o modificador Shadows irá substituir os métodos definidos na classe Pai. Haverá apenas um único método expoente: o definido na classe Filha.

E por hoje é só ,  aguarde mais artigos sobre conceitos OOP no VB.NET ...

 

Referências:

José Carlos Macoratti