PSI11_sem exercicios1 PDF - Classes e Componentes em Visual Basic

# CLASSES E COMPONENTES ## 11.1. CRIAÇÃO DE CLASSES EM VISUAL BASIC ### Um primeiro exemplo de uma classe em Visual Basic **Programação Orientada por Objetos** + Classe de objetos + Dados ou atributos + Métodos ou rotinas **FIG. 11.1.** Uma classe objetos é uma unidade de código engloba dados...

# CLASSES E COMPONENTES ## 11.1. CRIAÇÃO DE CLASSES EM VISUAL BASIC ### Um primeiro exemplo de uma classe em Visual Basic **Programação Orientada por Objetos** + Classe de objetos + Dados ou atributos + Métodos ou rotinas **FIG. 11.1.** Uma classe objetos é uma unidade de código engloba dados ou atributos e métodos ou rotinas. **Como vimos no primeiro módulo deste volume, as classes são elemento central da Programação Orientada por Objetos.** **Uma classe é uma unidade de código que reúne mesmo tempo:** - membros de dados ou atributos; - métodos (procedimentos e/ou funções). **No módulo anterior, analisámos, por um lado, subprogramas (procedimentos e funções) e, por outro, estruturas de dados ou registos.** **As classes juntam ao mesmo tempo estes dois tipos unidades de programação: estruturas de dados e métodos (que são subprogramas).** **Se uma classe tivesse apenas atributos ou campos de dados, seria semelhante a uma structure (conjunto de campos de dados). Consideremos seguinte exemplo de uma structure em Visual Basic:** ``` Structure Retangulo Dim Comprimento As Single Dim Largura As Single End Structure ``` **Classe Retângulo** Atributos: - Comprimento - Largura Métodos: - Área = Comprimento * Largura **FIG. 11.2.** A representação de uma classe costuma conter três partes: cabeçalho (nome da classe); secção dos dados ou atributos; e secção dos métodos (procedimentos e funções). **Se, na anterior estrutura, substituirmos a palavra structure por class, temos uma classe muito simples em Visual Basic, constituída apenas por dois campos de dados (Comprimento e Largura):** ``` Class Retangulo Dim Comprimento As Single Dim Largura As Single End Class ``` **Embora nada impeça que uma classe tenha apenas membros de dados, normal ela também métodos (procedimentos e funções).** **Com base no exemplo anterior, poderíamos definir assim uma classe em Visual Basic (esta já com um método a função Area):** ``` Class Retangulo Public Comprimento As Single Public Largura As Single Public Function Area() As Single Return Comprimento * Largura End Function End Class ``` ## Criar uma classe dentro do módulo de um formulário **FIG. 11.3.** À esquerda, interface destinada testar classe Retângulo. À direita, colocação cursor antes cabeçalho da classe formulário escrever classe dentro deste módulo formulário. **Para testarmos nossa classe, escrevemos, procedimento evento Click botão comando, por exemplo, seguinte (figura 11.5):** ``` Dim R1 As New Retangulo R1.Comprimento = 10 R1. Largura = 5 MsgBox(R1.Area) ``` **A declaração Dim R1 As New Retangulo cria R1 como um novo (New) objeto classe Retangulo. Duas instruções seguintes atribuem valores aos dados objeto R1 (por exemplo: R1.Largura = 5). Última instrução usa uma MsgBox escrever valor área objeto R1 (R1.Area).** **FIG. 11.4.** Código de uma classe no Visual Basic. **FIG. 11.5.** Código associado botão comando (Button1) destinado criar usar um objeto classe Retangulo (R1). ## Criar uma classe num módulo próprio **FIG. 11.6.** Para criar uma classe num módulo próprio para classes podemos pedir, menu Project, comando Add Class. **Acabámos de ver como escrever uma classe no mesmo módulo formulário em que estamos trabalhar. Agora, vamos ver como criar uma classe num módulo próprio para classes.** **Para tal, podemos pedir, menu Project, comando Add Class (figura 11.6). Também podemos usar botão Add New Item barra ferramentas.** **Em qualquer dos casos, é aberta janela Add New Item, onde indicamos opção Class (ver figura 11.7). Depois clicarmos botão Add, será aberto novo módulo ambiente trabalho (ver figura 11.7, fundo).** **Escrevemos exatamente mesmo código apresentado página anterior para classe Retangulo. Neste caso, classe está criada com cabeçalho Public Class Retangulo2. Palavra Public é necessária para que classe possa ser usada noutros módulos.** **FIG. 11.7.** Em cima, janela Add New Item, onde selecionamos opção Class. Em baixo, Visual Basic com nova classe escrita num módulo próprio para classes. Em princípio, Visual Basic atribui-lhe nome Class1.vb. Na janela Solution Explorer, aparece-nos também indicação relativa nova classe adicionada projeto. ## Criar objetos partir uma classe - instanciar classe **FIG. 11.8.** À esquerda, interface destinada testar classe Retangulo2. À direita, código associado botão comando (Button1) destinado criar usar um objeto daquela classe. **Para testarmos classe Retangulo2 criada página anterior, vamos escrever mesmo tipo instruções apresentadas página 109, reproduzidas aqui figura 11.8.** **No procedimento evento Click botão comando, temos agora seguinte código:** ``` Dim R2 As New Retangulo2 R2.Comprimento = 20 R2. Largura = 10 MsgBox (R2.Area) ``` **Analisemos declaração variável R2 – que na verdade um objeto classe Retangulo2:** ``` Dim R2 As New Retangulo2 ``` **Esta declaração cria R2 como novo (New) objeto classe Retangulo2. Isto também chama instanciar uma classe.** **Instanciar uma classe significa criar objetos partir dessa classe.** **Uma declaração como seguinte seria insuficiente:** ``` Dim R 2 As Retangulo2 ``` **Esta declaração é suficiente para restantes variáveis que estudámos; por exemplo, para uma structure seria suficiente.** **Tratando-se variáveis tipo objeto, é necessário utilizar palavra New para criar efetivamente novo objeto.** **Nota:** New é um método construtor uma classe (veremos melhor este assunto capítulo 11.2. Construtores e classes derivadas, página 116). **Também é possível usar seguinte instrução:** ``` Dim R2 As Retangulo2 = New Retangulo2 ``` **Ou, então, duas seguintes em conjunto:** ``` Dim R2 As Retangulo2 New Retangulo2 R2 = ``` **Nesta última variante, primeira declaração apenas declara variável com nome R2 classe Retangulo2. Só com segunda é criado efetivamente um objeto daquela classe.** **Como objeto que é classe Retangulo2, R2 tem dois campos (Comprimento e Largura) e um método (função Area).** **Então, instruções R2.Comprimento = 20 e R2.Largura = 10 atribuem valores aos campos de dados objeto R2.** **A última instrução - MsgBox(R2.Area) - usa uma MsgBox escrever valor área objeto R2, calculado com função Area.** ## Definição das propriedades de uma classe **FIG. 11.9.** A diferença entre membros definidos como Public e membros definidos como Private. **Como vimos módulo 8, propósito característica POO conhecida por encapsulamento (página 16), é habitual proteger certos membros das classes com palavra Private.** **Na figura 11.9, parte superior, temos classe Retangulo como apresentámos páginas anteriores: com seus campos de dados (Comprimento e Largura) definidos como Public. Portanto, estes dados podem ser acedidos (lidos e modificados) em qualquer ponto programa.** **No entanto, uma boa programação de classes deve evitar expor dados uma classe livre acesso qualquer código que utilize. A principal razão que um acesso incorreto esses dados, com alterações não controladas, pode corromper código objetos abortar programa.** **Na mesma figura 11.9, em baixo, temos classe Retangulo2 com seus campos de dados (Comprimento e Largura) definidos como Private. Desta forma, estes dados apenas podem ser acedidos interior própria classe.** **No entanto, classe Retangulo2 assim definida - com campos privados - torna impossível acesso aos dados objetos. Consideremos, por exemplo, seguintes instruções escritas, no código botão comando:** ``` Dim R2 As New Retangulo2 R2.Comprimento = 10 R2. Largura = 5 MsgBox (R2.Area) ``` **As instruções R2.Comprimento = 10 e R2.Largura = 5 não são aceites pelo Visual Basic, porque campos Comprimento e Largura deste objeto (R2) estão definidos (na classe) como Private.** **Para ultrapassar esta questão e permitir um acesso controlado aos dados objetos de uma classe, temos conceito Property (propriedade). Propriedades (properties) uma classe são métodos específicos permitem acesso aos campos de dados dos objetos da classe. Vamos ver como se definem propriedades em Visual Basic.** **FIG. 11.10.** Código de uma nova versão classe Retangulo, em que foram definidas duas propriedades. **No cabeçalho, começamos por escrever Public Property. Isto indica Visual Basic que queremos criar propriedade e que ela deve ser pública para poder ser acedida no exterior.** **Segue-se nome dar propriedade (neste caso, Comp) tipo dados com que ela deve funcionar (neste caso, As Single).** **O código uma propriedade consiste tipicamente em dois subprogramas (Get e Set):** - **Get** - uma função que permite obter (get) valor campo dados visado; - **Set** - um procedimento para definir (set) ou modificar valor mesmo campo dados. **Nota:** Ao escrevermos Get e teclarmos Enter, Visual Basic define todo resto estrutura propriedade, incluindo também parte Set. **O código função Get propriedade Comp() consiste, neste caso, apenas em:** ``` Return Comprimento ``` - trata-se, simplesmente, devolver valor que estiver campo Comprimento. **O cabeçalho procedimento Set:** ``` Set (ByVal value As Single) ``` - inclui parâmetro value destinado fazer passar valor (ByVal) para atribuir campo visado (neste caso, Comprimento). Isso é feito com instrução: Comprimento = value. **A propriedade Larg() é definida de uma forma idêntica, mas para acesso campo Largura.** **Com esta versão classe Retangulo, o código apresentado página anterior, que tinha problemas acesso aos campos privados, pode funcionar assim:** ``` Dim R2 As New Retangulo R2.Comp = 10 R2.Larg = 5 MsgBox (R2.Area) ``` ## Outro exemplo definição propriedades uma classe **FIG. 11.11.** Esqueleto código classe Pessoa. **FIG. 11.12.** Código classe Pessoa. **Na figura 11.11, temos esboço para uma classe com nome Pessoa.** **Esta classe tem dois campos dados privados: Nome e Datan (data nascimento). E tem também três propriedades públicas:** - NomeP - para aceder campo Nome; - DataP - para aceder campo DataN; - Idade - esta é uma propriedade ReadOnly, ou seja, seu valor só pode ser lido nunca escrito pelo código; neste caso, calcula idade pessoa partir sua data nascimento. **A propriedade NomeP é semelhante às que definimos para classe Retangulo: seu método Get devolve campo Nome (Return Nome); seu método Set atribui valor ao mesmo campo (Nome = value).** **Na propriedade DataP, método Get também faz o que é habitual: devolve valor campo Datan (data nascimento).** **No entanto, método Set propriedade Datan está definido de forma diferente para controlar dado passar campo privado DataN.** **A propriedade DataP apresenta algo novo, começar pelo cabeçalho:** ``` Public Property DataP() As String ``` **A propriedade DataP está aqui definida como String, ao passo que campo DataN a que ela acede - é tipo Date (data). Isto visa evitar que programa "rebente" no caso entrar um formato inválido data para campo DataN. Método Set está assim definido:** ``` Set (ByVal value As String) If IsDate (value) Then DataN = value Else MsgBox ("Data inválida') End If End Set ``` **FIG. 11.13.** Código propriedade Idade que calcula idade pessoa com base sua data nascimento. Esta é uma propriedade tipo ReadOnly (só leitura); por isso, ela só tem método Get (e não método Set). **No cabeçalho método Set, parâmetro value passa um valor tipo String.** **Em seguida, surge If IsDate(value)..., ou seja, função interna Visual Basic IsDate() avalia se valor passado (value) é não uma data. Se for, campo DataN recebe esse valor: DataN = value. Senão, é apresentada uma mensagem com MsgBox("Data inválida").** **A propriedade Idade() idade pessoa: tipo ReadOnly e devolve um inteiro ** ``` Public ReadOnly Property Idade () As Integer Get Dim D As Integer D = DateDiff (DateInterval. Day, DataN, Now()) Idade = Int (D/365.25) Return Idade End Get End Property ``` **A instrução principal aqui é:** ``` D = DateDiff (DateInterval. Day, DataN, Now()) ``` **FIG. 11.14.** À esquerda, interface destinada testar classe Pessoa. À direita, código associado botão comando (Button1) destinado criar usar um objeto classe Pessoa. **Nesta instrução, variável D recebe número dias (DateDiff) intervalo (DateInterval) entre DataN data atual Now().** **A instrução Idade = Int(D / 365.25) faz um cálculo idade com base no número dias.** **Na figura 11.14, é apresentada interface código para testar classe Pessoa.** **A instrução:** ``` Dim P1 As New Pessoa ``` **cria P1 como um objeto de Pessoa.** **A instrução:** ``` Pl.DataP = MaskedTextBox1.Text ``` **atribui objeto P1, sua propriedade DataP, dado que estiver caixa MaskedTextBox1.** **Nota:** MaskedTextBox1 é um controlo ToolBox que permite definir, sua propriedade Mask, máscaras entrada, inclusive para datas. **A instrução MsgBox(P1.Idade) apresenta idade P1, calculada propriedade Idade.** **FIG. 11.15.** À esquerda, código classe Retangulo sua versão mais simples. À direita, código para testar um objeto desta classe. **Neste ponto, vamos abordar novo conceito POO que é construtor uma classe. Um construtor é um método uma classe concebido para definir modo como queremos que um objeto seja criado ao utilizarmos palavra New.** **Recordemos a classe Retangulo (figura 11.15, esquerda). Vamos voltar sua versão mais simples (sem propriedades). O conceito construtor pode aplicar-se qualquer classe, desde mais simples às mais complexas.** **Na versão apresentada na figura 11.15, classe Retangulo tem apenas dois campos públicos (Comprimento e Largura) e um método (função Area) que devolve Comprimento * Largura.** **Para criarmos um objeto desta classe, podemos escrever:** ``` Dim R 1 As New Retangulo ``` **A palavra New cria novo objeto classe indicada. New é nome geral que assumem os métodos construtores das classes.** **Se nossa classe não tiver definido nenhum método construtor (como é caso nesta versão classe Retangulo), New cria novo objeto reservando apenas espaço para dois campos classe (Comprimento e Largura).** **Esses campos, partida, não quaisquer valores definidos.** **Como se pode ver código da figura 11.15, direita, para que objeto R1 tenha valores necessário atribuí-los instruções como, por exemplo, R 1.Largura = 5.** **É aqui que entram os construtores. Podemos definir métodos na própria classe que definem uma ou várias formas criar objetos dessa classe, com certos valores definidos partida.** **Na figura 11.16, temos nova versão classe Retangulo, com três construtores. Em Visual Basic, um construtor inclui sempre palavras Sub New. Por exemplo:** ``` Public Sub New() Comprimento = 1 Largura = 1 End Sub ``` **O que este construtor faz muito simples: atribui valor 1 aos dois campos classe. Assim, quando surgir uma instrução como:** ``` Dim R1 As New Retangulo ``` **objeto R1 já tem valor 1 seu campo Comprimento e 1 seu campo Largura.** **FIG. 11.16.** Nova versão classe Retangulo, neste caso definida construtores. **É claro que valores atribuídos construtor Sub New() podiam ser outros quaisquer ou mesmo nenhuns.** **Um dos objetivos construtores é atribuir valores aos campos objetos momento em que são criados (valores por defeito). Isso, normalmente, é feito com parâmetros. Vejamos um exemplo:** ``` Public Sub New (ByVal C As Single) Comprimento = C End Sub ``` **Neste caso, após palavra New surge um parâmetro (ByVal C As Single). Este parâmetro permite passar valor C para atribuir campo Comprimento (Comprimento = C). Assim, já temos duas opções para criar objetos classe Retangulo. Além referida página anterior, também podemos usar esta:** ``` Dim R2 As New Retangulo (10) ``` **Neste caso, ao criarmos objeto R2, atribuímos-lhe valor para comprimento.** **A terceira versão construtor desta classe (ver também figura 11.16) inclui dois parâmetros (um comprimento outro largura).** ``` Public Sub New (ByVal C As Single, ByVal L As Single) Comprimento = C Largura = L End Sub ``` **Vejamos um exemplo utilização desta versão:** ``` Dim R3 As New Retangulo (10, 5) ``` **Este objeto R3 foi criado com valor 10 seu campo Comprimento 5 seu campo Largura.** **Como vimos, uma classe pode ter diversos construtores. Seu nome será sempre mesmo: New. Cada construtor terá seus parâmetros próprios, diferentes entre si no número ou nos tipos dados usados.** **Se criarmos construtores incluindo parâmetros, teremos definir também versão sem parâmetros para podermos usar esta última.** **Agora também podemos compreender porque é necessário usar palavra New para criar um objeto de uma classe. Essa é forma chamar seu construtor. como este pode ter várias versões, temos também aqui uma situação polimorfismo (várias formas para um mesmo método).** ## Outro exemplo definição construtores uma classe **FIG. 11.17.** O esqueleto e código classe Pessoa. **Na figura 11.17, temos novo esboço código classe Pessoa. A partir desta classe, vamos ver outro exemplo definição construtores.** **Recordemos que um construtor uma classe é um método que toma nome New serve para definir criação inicialização objetos dessa classe (inicialização atribuição valores iniciais seus campos dados).** **Recordemos ainda que, se definirmos construtores com parâmetros, devemos definir também construtor sem parâmetros para o podermos usar.** **Comecemos por este último (ver figura 11.18):** ``` Public Sub New() Nome = "Sem nome" End Sub ``` **Neste caso, optámos por apenas atribuir campo Nome string "Sem nome". Vejamos um exemplo utilização deste construtor.** **1) utilização construtor sem parâmetros:** ``` Dim P1 As New Pessoa ``` - neste caso, objeto P1 apenas recebe string "Sem nome" seu campo Nome; seu campo DataN (data nascimento) permanece sem qualquer valor. **FIG. 11.18.** Nova versão classe Pessoa, neste caso definida com dois construtores. **FIG. 11.19.** Um programa para testar criação objetos classe Pessoa. **Vejamos agora uma versão construtor New com parâmetros, neste caso sendo um deles opcional (ver também figura 11.18):** ``` Public Sub New (ByVal N As String, Optional ByVal D As Date = %1/1/2000#) Nome = N DataN = D End Sub ``` **Nesta versão, cabeçalho construtor New incluiu dois parâmetros:** - **ByVal N As String** - este parâmetro _N_ é tipo _String_ faz entrar um nome para campo _Nome_ instrução _Nome = N_; - **Optional ByVal D As Date = #1/1/2000#** - aqui temos exemplo um parâmetro opcional (Optional); parâmetro _D_ tipo _Date_ (data) faz entrar uma data para campo _DataN_ com instrução _DataN = D_. **A partir deste construtor, podemos criar objetos classe Pessoa duas formas distintas:** **2) utilização construtor com parâmetro:** ``` Dim P2 As New Pessoa ("Ana") ``` - neste caso, objeto P2 é criado apenas com valor "Ana" para parâmetro _N_ e esse valor entra para campo _Nome_; como não foi utilizado parâmetro _D_, campo _DataN_ fica com valor default indicado construtor, ou seja: #1/1/2000# (ver figura 11.19). **3) utilização construtor com dois parâmetros:** ``` Dim P3 As New Pessoa ("Rui", %31/1/1995#) ``` - neste caso, objeto P3 é criado com valores para dois parâmetros; assim, para além "Rui" que entra para campo _Nome_, entra também data 1/1/1995 para campo _DataN_. **Na figura 11.19, temos programa exemplifica criação objetos classe Pessoa utilizando diferentes construtores.** **1 - Utilização construtor sem parâmetros:** ``` Dim P1 As New Pessoa MsgBox (Pl. NomeP & " : " & Pl.DataP) ``` **Neste caso, mensagem apresentada é:** >"Sem nome: 00:00:00" **2 - Utilização construtor com parâmetro:** ``` Dim P2 As New Pessoa ("Ana") MsgBox (P2. NomeP & ": " & P2.DataP) ``` **Neste caso, mensagem apresentada é:** >"Ana: 01:01:2000" **3 - Utilização construtor com dois parâmetros:** ``` Dim P3 As New Pessoa ("Rui", %1/1/1995#) MsgBox (P3. NomeP & ": " & P3.DataP) ``` **Neste caso, mensagem apresentada é:** >"Rui: 01:01:1995" ## Criação de classes derivadas (com herança) **FIG. 11.20.** Esquematização derivação classes com herança. Classes derivadas herdam membros classe-base e podem acrescentar seus próprios membros específicos. **Quando começámos estudo Programação Orientada por Objetos (Módulo 8, página 20), vimos que uma suas características principais era herança.** **Recordemos que herança tem ver com criar ou derivar classes partir outras já existentes - partimos uma classe-base criamos uma mais classes derivadas.** **As classes derivadas herdam membros classe-base partir qual são criadas (ver esquema figura 11.20) e, normalmente, acrescentam seus próprios membros.** **FIG. 11.21.** À esquerda, código Pessoa que vai ser tomada como classe-base para criação uma classe derivada. À direita cima, início criação classe Aluno como derivada classe Pessoa. **Para exemplificar esta técnica fundamental POO, vamos partir classe-base Pessoa criar classe derivada Aluno (figura 11.21).** **Na figura 11.21, direita, está exemplificado como se inicia criação uma classe derivada.** **Escreve-se cabeçalho classe e, em seguida, palavra Inherits seguida nome classe-base; neste caso: Inherits Pessoa.** **No nosso exemplo, classe Aluno está ser criada mesmo módulo sua classe-base Pessoa (Class1.vb). Mas também poderia ser criada num módulo próprio parte.** **FIG. 11.22.** À esquerda, programa para testar classe derivada Aluno. À direita, interface resultados teste. **É interessante observar que estas simples linhas código:** ``` Public Class Aluno Inherits Pessoa End Class ``` **são suficientes para criar nova classe Aluno.** **Na figura 11.22, voltamos programa para testar nossas classes. No código botão comando começamos por escrever:** ``` Dim Al As New Aluno ``` **Esta declaração cria A1 como um objeto classe Aluno (mesmo sem termos escrito qualquer novo código para esta classe).** **Como classe Aluno herda todos membros classe Pessoa, podemos ter certeza que A1 tem dois campos privados daquela classe (Nome e DataN), bem como suas propriedades públicas (NomeP, Datap Idade).** **Assim, instrução que se segue:** ``` MsgBox (A1. NomeP & " : " & Al.DataP) ``` **faz escrever dados de A1.** **Porque é que dados A1 são, neste caso: "Sem nome: 00:00:00"? (Ver figura 11.22, direita, primeira caixa mensagem.)** **O que instrução Dim A1 As New Aluno fez foi usar construtor classe-base Pessoa criar A1 com valores default para aquela classe.** **A nossa classe Aluno ainda não tem definido nenhum construtor. Por isso, criação objetos Aluno tem recorrer construtor classe-base Pessoa (seu construtor sem parâmetros).** **Voltando programa figura 11.22, após primeira MsgBox, temos duas instruções que atribuem dados propriedades públicas A1:** ``` A1. NomeP Al.DataP = = "Joana" #1/1/1994# ``` **Assim, com segunda MsgBox já são apresentados dados atribuídos A1.** **Nota:** Como se pode ver figura 11.22, quando escrevemos A1, seguido ponto (.), Visual Basic apresenta membros disponíveis para este tipo objeto. Por agora, só estão disponíveis membros públicos classe-base (Pessoa), pois classe Aluno ainda não qualquer membro próprio. **O interesse criar classes derivadas partir uma classe-base passa reaproveitar código já escrito para classe-base. Mas, para que estas classes derivadas tenham realmente interesse, devem acrescentar algo novo. É o que vamos ver seguida.** ## Acrescentar novos membros a uma classe derivada **FIG. 11.23.** Código classe Aluno com novo campo (Curso), uma nova propriedade (CursoAluno) e um novo método (MostraAluno). **FIG. 11.24.** Código interface para testar nova classe Aluno. **Nas páginas anteriores, vimos como seguintes linhas código eram suficientes para criar uma nova classe com nome Aluno (herdando membros classe Pessoa):** ``` Public Class Aluno Inherits Pessoa End Class ``` **Agora (como se pode ver figura 11.23), vamos exemplificar como podemos acrescentar novos membros (campos dados, propriedades, métodos) esta classe derivada.** **Começamos por acrescentar novo campo:** ``` Private Curso As String ``` **Curso é um campo privado, tipo String.** **Em seguida, definimos propriedade para aceder esse campo privado:** ``` Public Property CursAluno As String ``` **Esta propriedade tem habituais métodos Get e Set (se necessário, rever páginas 113 115).** **Apresentamos também novo método:** ``` Public Sub MostraAluno () Dim s As String s = NomeP & vbCrLf & Idade & vbCrLf & Curso MsgBox(s) End Sub ``` **O método MostraAluno limita-se apresentar, numa MsgBox, string _s_, que junta três dados: NomeP, Idade Curso. (Recordar constante vbCrLf faz uma mudança linha.)** **Na figura 11.24, voltamos código nossa interface, para testar nova classe Aluno. A seguinte declaração cria A1 como novo Aluno:** ``` Dim A1 As New Aluno ``` **E instrução:** ``` A1. MostraAluno () ``` **chama método MostraAluno() para mostrar dados A1; como A1 ainda não recebeu dados, aparecem dados default atribuídos pelo construtor New() classe-base Pessoa.** ## 11.2. CONSTRUTORES E CLASSES DERIVADAS ### Métodos construtores das classes **FIG. 11.25.** À esquerda, novo código classe Aluno, já com construtores próprios. À direita, código para novos testes à classe Aluno. **A classe Aluno deverá ter seus próprios construtores. Na figura 11.25, temos dois construtores para classe Aluno.** ``` Public Sub New () Curso = "não definido" NomeP = "não definido" Datap = Now () End Sub ``` **Este é construtor sem parâmetros. Optámos por escrever "não definido" em dois campos (Curso e NomeP) data corrente Now() na data nascimento (DataP).** **Repare-se que acesso aos campos classe-base Pessoa não é feito aos campos privados (Nome e DataN), mas propriedades públicas (NomeP e DataP). Classe Aluno, como derivada de Pessoa, herda todos membros desta classe. No entanto, não tem acesso membros privados sua classe-base; apenas membros públicos.** **Agora vejamos um exemplo de um construtor com parâmetros. Neste exemplo utilizámos três parâmetros, sendo dois últimos opcionais:** ``` Public Sub New (ByVal N As String, Optional ByVal D As Date = #1/1/2000#, Optional ByVal C As String = "Informática") MyBase.New(N, D) Curso = C End Sub ``` **O parâmetro _N_ do tipo String destina-se passar um dado para campo _Nome_.** **O parâmetro _D_ do tipo Date destina-se passar um dado para campo _DataN_.** **O parâmetro _C_ do tipo String destina-se passar um dado para campo _Curso_.** **Repare-se na instrução MyBase.New(N, D). Trata-se uma chamada construtor (New) classe-base (MyBase), com parâmetros _N_ e _D_ para dados campos _Nome_ e _DataN_.** **Na figura 11.25, direita, podemos ver dois exemplos criação objetos: A1 criado sem parâmetros: _Dim A1 As New Aluno()_; A2 criado com dois parâmetros (e omissão terceiro):** ``` Dim A2 As New Aluno ("Ana", #1/1/1995#) ``` **FIG. 11.16.** Nova versão classe Retangulo, neste caso definida construtores. **É claro que valores atribuídos construtor Sub New() podiam ser outros quaisquer ou mesmo nenhuns.** **Um dos objetivos construtores é atribuir valores aos campos dos objetos no momento em que são criados (valores por defeito). Isso, normalmente, é feito com parâmetros. Vejamos um exemplo:** ``` Public Sub New (ByVal C As Single) Comprimento End Sub = C ``` **Neste caso, após palavra New surge um parâmetro (ByVal C As Single). Este parâmetro permite passar valor C para atribuir ao campo Comprimento (Comprimento = C). Assim, já temos duas opções para criar objetos da classe Retangulo. Além da referida na página anterior, também podemos usar esta:** ``` Dim R 2 As New Retangulo (10) ``` **Neste caso, ao criarmos objeto R2, atribuímos-lhe um valor para o comprimento.** **A terceira versão do construtor desta classe (ver também figura 11.16) inclui dois parâmetros (um para o comprimento e outro para a largura).** ``` Public Sub New (ByVal C As Single, ByVal L As Single) Comprimento = C Largura = L End Sub ``` **Vejamos um exemplo de utilização desta versão:** ``` Dim R3 As New Retangulo (10, 5) ``` **Este objeto R3 foi criado com o valor 10 no seu campo Comprimento e 5 no seu campo Largura.** **Como vimos, uma classe pode ter diversos construtores. O seu nome será sempre o mesmo: New. Cada construtor terá os seus parâmetros próprios, diferentes entre si no número ou nos tipos de dados usados.** **Se criarmos construtores incluindo parâmetros, teremos de definir também a versão sem parâmetros para podermos usar esta última.** **Agora também podemos compreender porque é necessário usar a palavra New para criar um objeto de uma classe. Essa é a forma de chamar o seu construtor. E, como este pode ter várias versões, temos também aqui uma situação de polimorfismo (várias formas para um mesmo método).** ## 11.3. BIBLIOTECAS DE CLASSES, DLL E NAMESPACES ### Bibliotecas de classes e DLL **FIG. 11.26.** Janela New Project (Novo Projeto), partir da qual vamos selecionar Class Library (Biblioteca de classes). **FIG. 11.27.** O Visual Basic com novo projeto tipo Class Library (Biblioteca classes). **Nas páginas anteriores, aprendemos criar classes em Visual Basic trabalhar com objetos criados partir dessas classes.** **Neste ponto vamos ver como se cria uma biblioteca classes ou Class Library.** **Uma Class Library é um projeto programação diferente uma aplicação. Enquanto nesta última criamos programa podemos executar, uma library não pode ser executada autonomamente, mas, apenas, incluída numa aplicação, para aí suas classes componentes poderem ser usadas.** **Para criar um projeto tipo Class Library pedimos um novo projeto Visual Basic - que faz abrir janela New Project.** **Na janela New Project (figura 11.26), pedimos opção Class Library clicamos OK. Isto faz-nos entrar num módulo próprio para classes, como se pode ver figura 11.27. Podemos, então, escrever aí as classes que desejarmos.** **É claro que razão de ser das bibliotecas classes ou _class libraries_ é podermos reutilizar código escrito uma vez diferentes projetos.** **FIG. 11.28.** O novo projeto tipo Class Library com classes Pessoa Aluno que desenvolvemos nas páginas anteriores. **FIG. 11.29.** Quadro Save Project, onde podemos guardar ficheiro com projeto ClassLibrary1. Se quisermos, podemos mudar nome e/ou local onde guardar este projeto. **FIG. 11.30.** Menu Debug, onde pedimos comando Build ClassLibrary1 para compilar DLL. **Nota:** Ao pedirmos comando Build ClassLibrary1 não vemos acontecer nada. No entanto, acontece compilação Class Library para uma DLL. Uma DLL ou _Dynamic Link Library_ é uma unidade código compilada pronta ser usada aplicações que incluam como referência. Esta é uma formas mais usadas para criar código reutilizável novos projetos de programação. ## Inclusão uma referência a uma DLL numa aplicação cliente **FIG. 11.31.** Um novo projeto tipo WindowsApplication para testar Class Library1 criada página anterior. Na janela Solution Explorer, abriu-se menu com botão secundário rato sobre WindowsApplication1 para aceder comando Add Reference. **FIG. 11.32.** No quadro Add Reference, separador Browse, procuramos DLL ClassLibrary1, encontra numa subpasta nossos projetos, algo como ...\[Projects]\Class Library1\[bin]\Release, com nome ClassLibrary1.dll. **FIG. 11.33.** Janela Solution Explorer, onde clicou botão Show All Files ver todos ficheiros que fazem parte projeto. Como foi incluída referência ClassLibrary1, ela tem aparecer na lista References. **FIG. 11.34.** Janela código formulário onde vai declarar Imports ClassLibrary1 para código desta aplicação reconheça classes existentes naquela biblioteca ou DLL. **FIG. 11.35.** Código para criar testar um objeto classe Pessoa, importada através declaração colocada antes cabeçalho formulário: Imports ClassLibrary1. Repare-se que classe Pessoa não está incluída diretamente neste projeto, mas sim através DLL importada. No entanto, Visual Basic dá-nos indicações precisas sobre membros objetos classe Pessoa. Repare-se ajudas após escrevermos P1. **Como pode