Visual Basic 2005 - Polimorfismo com classes Abstratas

Enviado por Pedro Alves em dom, 23/09/2007 - 19:56.

Vamos supor que você precisa desenvolver um projeto para calculo de áreas e que de início deverá
calcular a área do retângulo, do triângulo e do quadrado.

Como um bom conhecedor dos conceitos da programação orientada a objetos (POO) você cria um
novo projeto no Visual Basic 2005 Express e imediatamente no menu Project inclui uma classe
usando a opção Add Class dando ao arquivo o nome Areas.vb.

A seguir você decide, baseado na sua experiência na POO, criar um classe chamada Retangulo com
as seguintes características:

 duas propriedades: Altura e Base

 um construtor: New (altura, base)
 um método chamado getArea()

O código da classe esta listado abaixo:

Public Class Areas

    Public Class Retangulo

        Private _altura As Double

        Private _base As Double

        Public Sub New(ByVal h As Double, Bl base As Double)

            Me.Altura = h
            Me.Base = b
        End Sub

        Public Property Altura() As Double

            Get
                Return _altura
            End Get
            Set(ByVal value As Double)
                _altura = value
            End Set
        End Property
    
       Public Property Base() As Double
            Get
                Return _base
            End Get
            Set(ByVal value As Double)
                _base = value
            End Set
        End Property

        Public Function getArea() As Double

            Return _altura * _base
        End Function
    End Class
End Class

Muito bem, você já pode obter a área do retângulo usando o método getArea() e definindo as
propriedades Altura e Base. Até aqui nada de especial.
Você parte então todo entusiasmado para criar sua segunda classe, a classe Triangulo, que irá
calcular a área do triângulo. O código usado esta mostrado a seguir:

    Public Class Triangulo

        Private _altura As Double

        Private _base As Double

        Public Sub New(ByVal base As Double, ByVal altura As Double)

           Me.Altura = h
            Me.Base = b
        End Sub

        Public Property Altura() As Double

            Get
                Return _altura
            End Get
            Set(ByVal value As Double)
                _altura = value
            End Set
        End Property
    
       Public Property Base() As Double
            Get
                Return _base
            End Get
            Set(ByVal value As Double)
                _base = value
            End Set
        End Property

        Public Function getArea() As Double

            Return ( _base * _altura) / 2
        End Function

    End Class

Para encerrar você cria a classe Quadrado contendo uma propriedade , o construtor e o método
getArea(), conforme código abaixo:

Public Class Quadrado

        Private _lado As Double

        Public Sub New(ByVal lado As Double)
            Me.Lado = lado
        End Sub

        Public Property Lado() As Double

            Get
                Return _lado
            End Get
            Set(ByVal value As Double)
                _lado = value
            End Set
        End Property

        Public Function getArea() As Double

            Return _lado * _lado
        End Function
End Class

Após terminar as classes você implementou em um formulário, Form1.vb do projeto, o código para
fazer os testes.
A interface criada usou apenas três botões conforme figura abaixo:

O código usado no formulário é mostrado a seguir:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button1.Click
        Dim r As New Areas.Retangulo(10, 20)
        MsgBox("Area do retangulo de base=10 e altura=20 : " & r.GetArea())
    End Sub

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button2.Click
        Dim r As New Areas.Triangulo(10, 20)
        MsgBox("Area do triangulo de base=10 e altura=20  : " & r.getArea())
    End Sub

    Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button3.Click
        Dim r As New Areas.Quadrado(10)
        MsgBox("Area do quadrado de lado 10 : " & r.getArea())
    End Sub

Após terminar todo este trabalho você analisou melhor o seu código e percebeu o seguinte:

 O método getArea() foi implementado em todas as classes;

 As classes Retangulo e Triangulo possuem duas propriedades com a mesma assinatura e o
mesmo construtor;

Atento a estes detalhes você se convenceu que pode otimizar o código usado. Você então resolveu
aplicar seus conhecimentos avançados de orientação a objeto e usar o conceito de classes abstratas.

No VB.NET uma classe é definida como abstrata através do uso do modificador MustInherit. Então
para criar uma classe abstrata do VB.NET você precisa preceder a palavra chave Class com o
modificador MustInherit.

Um método que possui somente a assinatura(declaração) sem qualquer implementação pode também
ser chamado de um método abstrato. Para declarar um método como abstrato no VB .NET você
precisa usar o modificador MustOverride pois os métodos abstratos precisam ser sobrescritos e
implementados nas classes filhas com a mesma assinatura com o qual foi definido na classe pai.

Uma classe precisa ser definida como abstrata se possuir pelo menos um método abstrato; ela pode
no entanto conter diversos métodos não abstratos. Lembre-se que você não pode instanciar uma
classe Abstrata como faz com uma classe comum visto que ela não esta totalmente implementada.
Com base nestes conceitos você definiu uma classe Forma com o seguinte código:

Public MustInherit Class Forma

        Private _x As Double

        Private _y As Double

        Public Sub New()

        End Sub

        Public Sub New(ByVal valor As Double)

            Me.X = valor
        End Sub

        Public Sub New(ByVal valor1 As Double, ByVal valor2 As Double)

            Me.X = valor1
            Me.Y = valor2
        End Sub

        Public Property X() As Double

            Get
                Return _x
            End Get
            Set(ByVal value As Double)
                _x = value
            End Set
        End Property

        Public Property Y() As Double

            Get
                Return _y
            End Get
            Set(ByVal value As Double)
                _y = value
            End Set
        End Property

        Public MustOverride Function GetArea() As Double

End Class

A classe Forma é uma classe abstrata(MustInherit) e possui as seguintes características:

 3 Construtores
 2 Propriedades
 1 método abstrato (MustOverride)

Note que o método foi definido sem qualquer implementação e deverá ser sobrescrito nas classes
filhas.

Agora podemos redefinir a classe Retangulo que deverá herdar da classe Forma. Ao final a classe
deverá ficar assim:

    Public Class Retangulo

        Inherits Forma

        Public Sub New(ByVal lado As Double, ByVal base As Double)

            MyBase.New(lado, base)
        End Sub

        Public Overrides Function getArea() As Double

            Return Me.X * Me.Y
        End Function
    End Class

A nova classe Retangulo agora possui um construtor contendo a seguinte instrução:

MyBase.New(lado, base)

Esta instrução chama o construtor da super classe (a classe Forma).

A nova classe Retangulo sobrescreve o método getArea() e foi implementando com a mesma
assinatura da classe abstrata (Forma) e retornando o valor da área do retângulo.

Vamos fazer o mesmo com a classe Triangulo que deverá ficar com o seguinte código:

    Public Class Triangulo

        Inherits Forma

        Public Sub New(ByVal base As Double, ByVal altura As Double)

            MyBase.New(base, altura)
        End Sub

        Public Overrides Function getArea() As Double

            Return (Me.X * Me.Y) / 2
        End Function

    End Class

A nova classe Triangulo também possui um construtor que chama o construtor da classe Pai e
implementa o método getArea() com a mesma assinatura da classe abstrata Forma, mas retornando o
valor da área do triângulo.

A classe Quadrado também deve ser alterada. Veja como ficou o seu código:

    Public Class Quadrado

        Inherits Forma

        Public Sub New(ByVal lado As Double)

            MyBase.New(lado)
        End Sub

        Public Overrides Function getArea() As Double

            Return Me.X * Me.X
        End Function
    End Class

Na classe Quadrado temos o método getArea() também sobrescrevendo o método definido na classe
Pai e definido com a mesma assinatura mas retornando o valor da área do quadrado.

Agora só falta alterar o código do formulário para testar cada uma das classes que agora herdam da
classe abstrata Forma. O código deverá ser alterado conforme abaixo:

Public Class Form1

    Dim f As Areas.Forma = Nothing

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button1.Click
        f = New Areas.Retangulo(10, 20)
        MsgBox("Area do retangulo de base=10 e altura=20 : " & f.getArea())
    End Sub
    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button2.Click
        f = New Areas.Triangulo(10, 20)
        MsgBox("Area do triangulo de base=10 e altura=20  : " & f.getArea())
    End Sub

    Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button3.Click
        f = New Areas.Quadrado(10)
        MsgBox("Area do quadrado de lado 10 : " & f.getArea())
    End Sub
End Class

Uma observação importante que deve ser feita ao código acima é que agora estamos sempre usando a
mesma variável (variável de referência e não um objeto concreto) para tratar as instâncias de todas
as classes filhas: Retangulo, Triangulo e Quadrado; a variável f.

Note também que a mesma variável f agora é usada para chamar o mesmo método getArea() obtendo
resultados diferentes.

Quando você usa o mesmo método com a mesma assinatura e com diferentes implementações e
diferentes execuções obtendo resultados diferentes você tem o que chamamos de Polimorfismo.

Definição Acadêmica:

O termo polimorfismo, etimologicamente, quer dizer "várias formas"; todavia, na Informática, e em

particular no universo da OOP, é definido como sendo um código que possui "vários
comportamentos" ou que produz "vários comportamentos"; em outras palavras, é um código que
pode ser aplicado à várias classes de objetos. De maneira prática isto quer dizer que a operação em
questão mantém seu comportamento transparente para quaisquer tipos de argumentos; isto é, a
mesma mensagem é enviada a objetos de classes distintas e eles poderão reagir de maneiras
diferentes. Um método polimórfico é aquele que pode ser aplicado à várias classes de objetos sem
que haja qualquer inconveniente.

Nelson Abu Sanra Rahal Júnior

Mestre em Ciência da Computação (UFSC),
Doutorando em Ciência da Computação (UFSC)

Outra definição:

Polimorfismo, originário do grego, significa "muitas formas" (poli = muitas, morphos = formas).
Ele permite que referências de tipos de classes mais abstratas representem o comportamento das
classes concretas que referenciam. Assim, um mesmo método pode apresentar várias formas, de
acordo com seu contexto. O polimorfismo é importante pois permite que a semântica de uma
interface seja efetivamente separada da implementação que a representa.
http://pt.wikipedia.org/wiki/Polimorfismo

Então, sem querer querendo, você acabou usando um recurso muito valioso da programação
orientada a objetos: a reutilização de código com encapsulamento e herança.

José Carlos Macoratti