Programação

Orientada a Objetos II
Autor: Prof. Salatiel Luz Marinho
Colaborador: Prof. Luciano Soares de Souza
 Professor conteudista: Salatiel Luz Marinho

Pós‑graduado em Gestão de Projetos pelo Instituto Brasileiro de tecnologia Avançada (IBTA) e formado em
Engenharia da Computação pela Universidade Paulista (UNIP), trabalha há mais de dez anos no desenvolvimento
de aplicações desktop e web, tendo prestado serviços a instituições financeiras, de varejo, acadêmicas e de seguros.
Leciona há mais de oito anos as disciplinas de Programação Orientada a Objetos na UNIP.

Dados Internacionais de Catalogação na Publicação (CIP)

M338p Marinho, Salatiel Luz.

Programação Orientada a Objetos II. / Salatiel Luz Marinho. –

São Paulo: Editora Sol, 2015.

164 p., il.

Nota: este volume está publicado nos Cadernos de Estudos e

Pesquisas da UNIP, Série Didática, ano XXI, n. 2-150/15, ISSN 1517-9230.

1. Linguagem de programação. 2. Camada de apresentação. 3.

Desenvolvimento de software. I. Título.

CDU 681.3.062

© Todos os direitos reservados. Nenhuma parte desta obra pode ser reproduzida ou transmitida por qualquer forma e/ou
quaisquer meios (eletrônico, incluindo fotocópia e gravação) ou arquivada em qualquer sistema ou banco de dados sem
permissão escrita da Universidade Paulista.
 Prof. Dr. João Carlos Di Genio
Reitor

Prof. Fábio Romeu de Carvalho

Vice-Reitor de Planejamento, Administração e Finanças

Profa. Melânia Dalla Torre

Vice-Reitora de Unidades Universitárias

Prof. Dr. Yugo Okida

Vice-Reitor de Pós-Graduação e Pesquisa

Profa. Dra. Marília Ancona-Lopez

Vice-Reitora de Graduação

Unip Interativa – EaD

Profa. Elisabete Brihy

Prof. Marcelo Souza
Prof. Dr. Luiz Felipe Scabar
Prof. Ivan Daliberto Frugoli

Material Didático – EaD

Comissão editorial:
Dra. Angélica L. Carlini (UNIP)
Dra. Divane Alves da Silva (UNIP)
Dr. Ivan Dias da Motta (CESUMAR)
Dra. Kátia Mosorov Alonso (UFMT)
Dra. Valéria de Carvalho (UNIP)

Apoio:
Profa. Cláudia Regina Baptista – EaD
Profa. Betisa Malaman – Comissão de Qualificação e Avaliação de Cursos

Projeto gráfico:
Prof. Alexandre Ponzetto

Revisão:
Rose Castilho
Juliana Mendes
Sumário
Programação Orientada a Objetos II
APRESENTAÇÃO.......................................................................................................................................................7
INTRODUÇÃO............................................................................................................................................................7

Unidade I
1 Programação Orientada a Objetos II..............................................................................................9
1.1 Lógica de programação.........................................................................................................................9
1.1.1 Algoritmo.................................................................................................................................................... 10
1.1.2 Programas....................................................................................................................................................11
1.1.3 Pseudocódigo............................................................................................................................................ 12
1.2 O que é Programação Orientada a Objetos................................................................................ 12
1.3 Linguagem de Programação C#...................................................................................................... 14
2 Plano de Desenvolvimento de Software.................................................................................... 17
2.1 Diagrama de Caso de Uso.................................................................................................................. 18
2.2 Diagrama de Classe.............................................................................................................................. 19
2.3 Diagrama de Sequência...................................................................................................................... 20

Unidade II
3 Linguagem de Programação C#...................................................................................................... 23
3.1 Histórico e curiosidades...................................................................................................................... 23
3.2 Microsoft Visual Studio...................................................................................................................... 24
3.3 Herança..................................................................................................................................................... 24
3.4 Polimorfismo........................................................................................................................................... 27
4 Camada de Apresentação..................................................................................................................... 34
4.1 Funções específicas da Camada de Apresentação................................................................... 36
4.2 Criando a Camada de Apresentação............................................................................................. 36
4.3 Desvios condicionais............................................................................................................................ 84
4.3.1 Desvios condicionais (Comandos de Seleção).............................................................................. 84
4.3.2 Condição...................................................................................................................................................... 84
4.3.3 Decisão......................................................................................................................................................... 85
4.3.4 Desvio condicional simples.................................................................................................................. 85
4.3.5 Desvio condicional composto............................................................................................................. 86
4.3.6 Operadores Lógicos................................................................................................................................. 87
Unidade III
5 Efetuando incrementos na solução............................................................................................ 92
6 Desenvolvimento de Aplicação em Camadas........................................................................119
6.1 Camada Modelo...................................................................................................................................119
6.1.1 Método Cadastrar................................................................................................................................. 129
6.1.2 Método ObterConexão........................................................................................................................131
6.1.3 Método FecharConexao......................................................................................................................131
6.1.4 Método Alterar...................................................................................................................................... 138
6.1.5 Método Excluir....................................................................................................................................... 139
6.1.6 Método ObterAluno............................................................................................................................. 140

Unidade IV
7 Persistência..................................................................................................................................................144
7.1 Reporting Service................................................................................................................................145
7.2 Windows Presentation Foundation.............................................................................................146
7.3 Trabalhando com CommandBuilder............................................................................................146
7.4 DataSet....................................................................................................................................................147
8 Introdução ao XML.................................................................................................................................149
8.1 Criar XML................................................................................................................................................150
8.2 DataGridView........................................................................................................................................152
8.3 Exportando com CSV.........................................................................................................................156
 APRESENTAÇÃO

Programação Orientada a Objetos II é uma das disciplinas‑base para o profissional formado nos
cursos de Análise e Desenvolvimento de Sistemas, Ciência da Computação, Engenharia da Computação,
entre outros.

O livro‑texto de Programação Orientada a Objetos II tem por finalidade customizar o processo de

aprendizagem do aluno, tendo como premissa proporcionar uma leitura comparada a um guia passo a
passo de desenvolvimento.

A concepção do livro‑texto se deu a partir da otimização do aprendizado, simulando, em diversos

momentos dessa elaboração, situações que proporcionam ao aluno visualizar o ambiente real de
desenvolvimento de softwares por meio de exemplos e desafios.

Pensando nesse cenário de aprendizagem, o livro‑texto foi dividido em unidades, possibilitando a

divisão de capítulos, de forma que garanta o crescimento gradativo do conhecimento da disciplina.

Inicialmente, abordaremos os conceitos básicos de Programação Orientada a Objetos, tais como:

apresentação de sua história, vantagens e desvantagens de se trabalhar com programação procedural,
definição de conexão com banco de dados e a importância do trabalho de desenvolvimento de softwares
enxergando o cenário documentação versus desenvolvimento.

Em seguida será apresentada, de maneira mais aprofundada, a linguagem C#, bem como a relação
de seus componentes por meio de exemplos com aplicações práticas, abordando as principais técnicas
de mercado no desenvolvimento de software, utilizando conceitos de programação orientada a objetos.

Mais adiante cada item sobre a disciplina de programação orientada a objetos será apresentado mais
profundamente, como trabalho de desenvolvimento de software utilizando camadas e a interconexão
de trabalho desktop e web.

Por fim, serão apresentados conceitos mais detalhados, trabalhando‑se com desenvolvimento
amigável e reutilização de código, bem como serão abordados, por meio de exemplos práticos, como
desenvolver softwares e a preocupação com o ciclo de vida e a manutenção do software

Bom estudo!

INTRODUÇÃO

Esta disciplina apresentará, de forma estruturada, os principais conceitos teóricos e práticos de

Programação Orientada a Objetos. Nossa jornada se inicia com a exposição dos elementos e componentes
básicos de desenvolvimento utilizando a linguagem C#. Em seguida apresentaremos a forma pela qual a
informação é distribuída por meio da codificação. Será levado em consideração o modelo de referência
MVC (Model, View, Controller), um modelo de camadas didático que permite fazer uso de padrões para
implementar os diversos níveis.
7
 A abordagem deste livro‑texto tem como foco o aprendizado top‑down do modelo de camadas,
que compreende uma visão geral, desde as aplicações que fazem parte do nosso dia a dia até as mais
avançadas, no âmbito de desenvolvimento de sistemas. Para tanto, serão considerados os conceitos de
comunicação entre as camadas e apresentadas as principais arquiteturas que embasam o desenvolvimento
de sistemas.

Observação

Estudar análise de sistemas orientada a objetos é uma mistura de regras

de negócio e desenvolvimento de software.

8
Programação Orientada a Objetos II

Unidade I
1 Programação Orientada a Objetos II

Nesta unidade inicial, iremos nos familiarizar com alguns conceitos interessantes que envolvem
programação, estruturação e modelagem de um software utilizando a linguagem C#. Este livro‑texto foi
elaborado pensando em trazer o que há de mais recente para você, usando uma linguagem agradável e
prazerosa. Boa leitura!

1.1 Lógica de programação

Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo.

A importância da lógica de programação é necessária quando programadores necessitam desenvolver

softwares, pois permite‑se definir, por meio de uma sequência lógica, a evolução do desenvolvimento.

Uma sequência lógica é formada pelos passos executados até atingir um objetivo ou a solução de
um problema, ou seja, por meio de uma sequência lógica determinada por diagramas e/ou fluxogramas
que irão garantir o entendimento inicial do desenvolvedor.

Entrada

Processamento

Saída

Figura 1 – Fluxo de sistema procedural

Instruções executadas dentro de uma sequência lógica são um conjunto de regras ou normas definidas
para a realização de ações. Podemos destacar também que apenas uma instrução, isoladamente, não
garante a finalização de um processo, pois um conjunto de instruções pode, por exemplo, efetivar um
ciclo completo de uma funcionalidade sistêmica.

9
 Unidade I

Para efetivarmos nosso entendimento, podemos comparar, essas instruções, em uma sequência lógica, com o
ato de fazer um bolo, no qual é necessário pôr algumas instruções em prática: colocar ovos, farinha, fermento etc.

• Mexer os ovos com a farinha.

• Adicionar leite e continuar a misturar.

• Mexer durante alguns minutos.

• Adicionar, aos poucos, açúcar e fermento.

• Mexer durante alguns minutos.

Para garantirmos a plena execução do bolo, devemos cumprir essas instruções em uma ordem
adequada, caso contrário podemos, por exemplo, deixar a massa do bolo muito seca ou inconsistente.

Sendo assim, não existe sentido algum em efetuar instruções separadas e sem nexo, pois é o conjunto
de instruções de tarefas que garantirá a qualidade final do conjunto de instruções executadas.

Em desenvolvimento de softwares, o resultado da execução de instruções nada mais é do que uma

ação elementar a ser executada.

Entrada =
Variável A,
Variável B

Processamento
(Efetuar Soma)

Saída –
Apresentar
resultadoSoma

Figura 2 – Fluxograma de sistemas

1.1.1 Algoritmo

Podemos definir um algoritmo como uma sequência finita de passos que direcionam a execução
de uma tarefa. Um algoritmo pode ser comparado, por exemplo, a uma receita, uma sequência de
instruções que identificam uma meta específica.

A definição de algoritmo pode ser visualizada pelo exemplo de algoritmos das operações básicas
(adição, subtração, divisão e multiplicação) de números reais e decimais. Também podemos agregar, dentro
10
Programação Orientada a Objetos II

da cadeia de exemplos, manuais eletrônicos, como uma máquina fotográfica, que explicam passo a passo,
por exemplo, como especificar e demonstrar modos de tirar fotos com melhor qualidade de imagem.

Alguns exemplos simples do nosso dia a dia podem ser descritos por uma sequência lógica:

• Comer um bombom

— Pegar o bombom.

— Retirar o papel do bombom.

— Comer o bombom.

— Identificar qual cesto de lixo corresponde a papel (reciclagem).

— Jogar o papel no lixo.

• Multiplicar dois números quaisquer

— Escrever o primeiro número no retângulo A.

— Escrever o segundo número no retângulo B.

— Multiplicar o número do retângulo A pelo número do retângulo B e colocar o resultado no

retângulo C.

Retângulo A
* Retângulo B = Retângulo C

Figura 3 – Demonstração de operação de multiplicação

Algoritmo é como o programador imagina toda a estrutura de código que será desenvolvida.
Muito importante colocar em prática o desenvolvimento de fluxograma, para que toda a lógica possa
transcorrer de maneira amigável, tornando‑se assim a aplicação de algoritmo satisfatória.

1.1.2 Programas

Por meio das linguagens de computador (C#, Java, Cobol, Visual Basic etc.), podem‑se derivar
algoritmos para a linguagem de programação específica.

Atualmente existem diversas linguagens, o que possibilita ao programador definir a linguagem mais
adequada e cada uma será interpretada por uma máquina, que, no caso, será um computador.

11
 Unidade I

1.1.3 Pseudocódigo

Todos os algoritmos descritos são derivados de uma linguagem denominada pseudocódigo. Esse
título é atribuído posteriormente a uma linguagem de programação, por exemplo, ao ser programado
um código C#, será gerado um código C#.

Todo algoritmo construído deve ser de fácil entendimento e fácil de programar, ou seja, deve ser o
intermediador entre linguagem falada e linguagem de programação.

Existem algumas regras que podem descrever a sequência de instruções de maneira simples e objetiva:

• Usar somente um verbo por frase.

• Imaginar que você está desenvolvendo um algoritmo para pessoas que não trabalham com informática.

• Usar frases curtas e simples.

• Ser objetivo.

• Procurar usar palavras que não tenham sentido dúbio.

Lembrete

Algoritmo é como o programador imagina toda a estrutura de

código que será desenvolvida. É muito importante colocar em prática o
desenvolvimento de fluxograma para que toda a lógica possa transcorrer
de maneira amigável, tornando‑se satisfatória a aplicação de algoritmo.

1.2 O que é Programação Orientada a Objetos

O desenvolvimento de aplicações C# pode ser considerado um estudo baseado na interação e na

composição, bem como a disseminação pelo projeto de software denominado de camada de objetos.

Em muitos cenários leva‑se em consideração a utilização da modelagem de programação orientada

a objetos em vez da programação procedural. O paradigma de orientação a objetos aproxima‑se de
itens conceituais e, principalmente, da origem do campo de estudo da cognição, que por muitas vezes
exerceu influência nas áreas de inteligência artificial e da linguística, sobretudo no âmbito da abstração
de conceitos do mundo real.

Com base em estudos, podemos afirmar que, com o conceito de modelagem de programação
orientada a objetos, pode-se garantir a diminuição de gaps semânticos, bem como a estruturação da
lógica e o ganho de performance sistêmica.

12
Programação Orientada a Objetos II

Existem linguagens, tais como Java, Visual Basic, C#, C++, dentre outras, que são concebidas com os
conceitos de programação orientada a objetos.

Exemplo de aplicação

Uma agência de veículos tem diversos clientes. Pode, então, criar facilmente uma classe, mensurando
para o computador o que é um cliente. Porém, para que todo o entendimento seja abstraído de maneira
amigável, apresenta‑se a classe Cliente com os seguintes atributos:

• Nome.

• Data de nascimento.

• CNH.

Deve‑se considerar que um cliente vai muito além de dados contidos em uma base; ele pode sofrer
ações dentro do sistema. Dentro do universo de programação orientada a objetos, toda e qualquer ação
que um agente sofre deriva‑se para um método:

• AlugarVeículo.

• DevolverVeículo.

• ReservarVeículo.

É importante perceber que, por questões de boas práticas de desenvolvimento de software, todo
e qualquer método é escrito no verbo infinitivo para exemplificar melhor as ações que determinado
agente pode realizar dentro do sistema.

Sendo assim, entenda‑se a construção de uma classe por um dos seguintes requisitos:

• Todo e qualquer atributo é um dado que será inserido, alterado, excluído ou consultado de uma tabela.

• Todo e qualquer método descreve quais são as possíveis ações que um agente pode realizar.

Um software pode ter uma ou mais classes com métodos e atributos. No exemplo, cada agente
terá seu nome, data de nascimento e CNH realizando os métodos: AlugarVeículo, DevolverVeículo e
ReservarVeiculo.

13
 Unidade I

1.3 Linguagem de Programação C#

A linguagem C# vem crescendo a cada dia, aumentando sua disseminação no mercado de

desenvolvimento de software. A partir da sua concepção até os dias atuais, nota-se a preocupação em
garantir a evolução da linguagem, acompanhando o crescimento exponencial do mercado de software,
como podemos conferir no texto a seguir:

A evolução do C#

Cada geração do C# tem trazido adicionais relevantes à linguagem, com poucas excelentes
funções. Talvez a mais significativa função adicionada para o C# 2.0 tenha sido Generics
(permitindo um aperfeiçoamento de segurança de tipo ao lidar com collections – coleções).
Desta forma, a adição mais significativa ao C# 3.0 deve ser a extensão de Consulta de
Linguagem Integrada (LINQ – Language‑Integrated Query), que adiciona ao C# extensões de
consulta de dados de finalidade geral, embora não seja a única melhoria do C#.

Outras novas características incluídas:

• Expressões Lambda (delegates anônimos nos steroids).

• Métodos de Extensão.

• Inicializadores de Objeto.

• Tipos anônimos.

• Variáveis locais de tipo implícito.

• Vetores de tipo implícito.

• Árvores de Expressão.

• Propriedades Automáticas (uma pequena joia).

A Linguagem C#

A essência da linguagem C# é tranquilizadoramente simples, com pouco mais de cem

palavras‑chave e uma dúzia de tipos internos de variáveis, mas é altamente expressiva
quando vem a implementar conceitos modernos de programação. A linguagem C# inclui
todo o suporte para programação estruturada, com componentes funcionais e de orientação
a objetos que você espera de uma linguagem moderna construída a partir de C++ e Java. A
versão 3.0 tem sido estendida de três formas muito importantes:

Total suporte para LINQ – consultas em relação a dados agora fazem parte da linguagem.
14
Programação Orientada a Objetos II

• Total suporte para sintaxes declarativas do Windows Presentation Foundation (WPF;

para criação de aplicações ricas do Windows), Work Flow (WF) e Silverlight (para
criação multiplataforma e multinavegadores de aplicações ricas de internet).

• Muitas funções convenientes adicionadas para auxiliar a produtividade do

programador e para funcionar e rodar corretamente no Visual Studio 2013.

Um pouquinho de história

A linguagem C# foi originalmente desenvolvida por um pequeno time conduzido por

dois engenheiros da Microsoft, Anders Hejlsberg e Scott Wiltamuth. Hejlsberg é também
conhecido pela criação do Turbo Pascal, uma linguagem popular para programação PC, e
por liderar o time que arquitetou o Borland Delphi, um dos primeiros vitoriosos Ambientes
de Desenvolvimento Integrados (Integrated Development Environments – IDEs) para
programação cliente/servidor.

Características do C#

No coração de qualquer linguagem orientada a objetos, está seu suporte para definir
e trabalhar com classes. Classes determinam novos tipos, permitindo que você estenda a
linguagem e consiga manipular melhor o problema que você está tentando solucionar. C#
contém palavras‑chave para declaração de novas classes e de seus métodos e propriedades
e para implementação de encapsulamento, polimorfismo, os três pilares da programação
orientada a objetos.

No C#, tudo relacionado a uma declaração de classe localiza‑se na própria declaração.

Definições de classe C# não necessitam de arquivos de cabeçalho ou arquivos separados
(IDL – Interface Definition Language). Além disso, o C# permite documentação direta (inline)
que simplifica a criação online e impressa de documentação para um aplicativo.

[O] C# também permite interfaces, um meio de fazer um contrato com uma classe
para processos que a interface determina. No C#, uma classe pode herdar de apenas um
objeto-pai (parent), mas uma classe pode implementar múltiplas interfaces. Quando uma
classe implementa uma interface, na prática promete proporcionar funcionalidade que as
interfaces especificam.

[A linguagem] C# proporciona também um suporte a structs (estruturas), um conceito que

tem mudado seu significado de forma relevante a partir do C++. No C#, uma estrutura é um
limitado tipo supérfluo que[,] quando instanciado, faz menos pedidos ao sistema operacional
e à memória do que uma classe convencional faz. Uma struct pode herdar de uma classe ou
ser herdada por uma classe, mas um struct pode implementar uma interface. [...].

C# proporciona suporte total de delegates (delegados): para invocação de métodos

indiretamente. Em outras palavras, como no C++[,] você pode achar funcionalidade
15
 Unidade I

similar (como em ponteiros para funções de membros), mas delegates são referência de
tipos seguros que encapsulam métodos com assinaturas e tipos de retorno específicos.
Delegates têm sido estendidas significativamente, primeiro no C# 2.0 e novamente no C#
3.0, primeiramente com anonymous delegates e agora com as Expressões Lambda (Lambda
Expressions), colocando a base para o LINQ. [...].

[O] C# proporciona características orientadas a componentes, como propriedades,

eventos e construtores declarativos (como atributos). Programação orientada a componente
é sustentada pelo armazenamento de metadado com o código para a classe. O metadado
descreve a classe, incluindo seus métodos e propriedades, bem como sua necessidade de
segurança e outros atributos, assim como será que pode ser serializado, o código contém a
lógica suficiente para executar suas funções.

Dessa forma, uma classe compilada é uma unidade independente. Então um ambiente de
armazenamento de dados que sabe como ler um metadado e um código de uma classe não
precisa de nenhuma outra informação para fazer utilização disso. Isso é possível, usando o C# e
o Commom Language Runtime (CLR, Tempo de Execução de Linguagem Comum) para adicionar
um metadado personalizado a uma classe pela criação de atributos personalizados. Dessa mesma
forma, é possível ler um metadado de classe utilizando os tipos do CLR que suportam reflexão.

Quando você compila seu código, cria um assembly. Um assembly é uma coleção de arquivos
que aparecem ao programador como uma única DLL, biblioteca de link dinâmico (Dynamic Link
Library) ou executável (EXE). Em .NET, um assembly é a unidade básica de reutilização, versionamento,
segurança e implantação. O CLR proporciona um número de classes para manipulação de assemblies.

Uma nota final sobre o C# é que ele também proporciona suporte para:

• Acesso direto à Memória utilizando ponteiros do estilo C ++.

• Palavras‑chave para incluir operações como inseguras.

• Avisa o coletor de lixo CLR para não coletar objetos referenciados por ponteiros até
que eles sejam liberados.

Fonte: Liberty; Xie (2009, p. 3‑5).

Saiba mais

Fique sempre por dentro das novidades e lançamentos de versões

atualizadas do Visual Studio. Eles se encontram no seguinte endereço:

<https://www.visualstudio.com/pt‑br/visual‑studio‑homepage‑vs.aspx>.

16
Programação Orientada a Objetos II

2 Plano de Desenvolvimento de Software

Atualmente, o desenvolvimento de software cresce exponencialmente. Planejamento,

Desenvolvimento, Construção e Avaliação (PDCA) são as constantes utilizadas para que o ciclo de
desenvolvimento permaneça ativo no dia a dia.

Observação

PDCA (Plan – planejar, Do – fazer, Check – checar, Action – agir): é

um conceito de boas práticas na gestão, podendo ser aplicado no
desenvolvimento de softwares (Planejar, Desenvolver, Construir e Avaliar)
a fim de se gerar evidências de todo o ciclo de análise e desenvolvimento
de um software.

• Ação corretiva no • Localizar

insucesso problemas
• Padronizar e • Estabelecer
treinar no planos de ação
sucesso Action Plan
Agir Planejar

Check Do
• Verificar Checar Fazer • Execução
atingimento do plano
de meta • Colocar
• Acompanhar plano em
indicadores prática

Figura 4 – Exemplo de execução do PDCA

Para o desenvolvimento de um software, são necessárias algumas perguntas:

• Como entender o requisito solicitado e “traduzir” em linguagem de programação?

• Como atender a todas as necessidades de um projeto de software utilizando linguagem de

programação?

Para que todas as respostas possam ser apresentadas, um dos recursos que irão conduzir o
desenvolvimento do software e auxiliar na visualização das etapas será o UML. Dessa metodologia,
iremos absorver:

• Diagrama de Caso de Uso.

17
 Unidade I

• Diagrama de Classe.

• Diagrama de Sequência.

Saiba mais

Para saber mais a respeito do tema, sugerimos a leitura do seguinte artigo:

REIS, D. F. UML (Unified Modeling Language) e Unified

Software Development Process (Unified Process). DevMedia, Rio
de Janeiro, [s.d.]. Disponível em: <http://www.devmedia.com.br/
uml‑unified‑modeling‑language‑e‑unified‑software‑development
‑process‑unified‑process/11217>. Acesso em: 9 jun. 2015.

2.1 Diagrama de Caso de Uso

Para que o desenvolvimento de software possa ser melhor entendido, após a análise de requisitos
ser efetuada, o programador pode, por meio dos seus conhecimentos técnicos, efetuar o entendimento
inicial do seu desenvolvimento.

O exemplo a seguir demonstra como podemos retirar informações preciosas do Diagrama de Caso de Uso:

Descrição Sucinta
Este caso de uso descreve os procedimentos que devem ser realizados para efetuar a inclusão de um relatório
dinâmico.
Pré‑Requisito: Verifica se o usuário tem permissão.
Fluxo de Eventos
Fluxo Básico B1 – (Incluir Relatório)
Por meio do número da funcional do usuário autenticado, o Sistema verifica que o usuário logado possui acesso
para incluir relatórios;
O Sistema apresenta a opção Gerenciar Relatório;
O usuário seleciona a opção Gerenciar Relatório e em seguida a opção “Incluir Relatório”;
O sistema abre a tela de inclusão de relatório com as seguintes informações:
Nome, Descrição e Conteúdo
O usuário seleciona incluir.
O sistema verifica quais campos obrigatórios estão preenchidos.
O sistema valida se a instrução cadastrada no campo Conteúdo é uma instrução de Select.
O Sistema valida se os parâmetros passados no conteúdo são parâmetros válidos (formato de passagem dos
parâmetros: @{Número da RS;int;5} – onde @{ delimita o início do Nome do Dado; o primeiro símbolo “;” delimita
o término do Nome do Dado e após o “ponto e vírgula” é o início do Tipo do Dado).
O sistema efetiva a inclusão do relatório.
O sistema apresenta a mensagem “Relatório incluído com sucesso!”.
O caso de uso termina.

18
Programação Orientada a Objetos II

Pode‑se observar que, por meio do Diagrama de Caso de Uso, podemos retirar:

• Entendimento da funcionalidade.

• Entendimento do fluxo de navegação da funcionalidade.

• Mensagens que serão exibidas no software, por meio de caixa de mensagem.

Para que se possa traçar um paralelo entre a linguagem de programação e o Diagrama de Caso de
Uso, observe a figura a seguir:

Figura 5 – MessageBox utilizado para exibir caixa de mensagem

Figura 6 – Caixa de Mensagem utilizada no C#

2.2 Diagrama de Classe

Este diagrama irá auxiliar o desenvolvedor a entender os seguintes itens no processo de construção
do software:

• Criação de classe(s) para cada funcionalidade(s).

• Criação de método(s) para cada funcionalidade(s).

Quadro 1 – Diagrama de Classe: funcionalidade IncluirRelatorio

1 – ClsRelatorio
2 – Nome
3 – Descricao
4 – Conteudo
5 – IncluirRelatorio()

19
 Unidade I

Observação

A nomenclatura utilizada no diagrama de classe (clsIncluirRelatorio)

foi adotada para facilitar o entendimento entre documentação e
desenvolvimento do software.

Figura 7 – Classe clsRelatorio desenvolvida em C#

Com os atributos declarados no Diagrama de Classe, pode‑se definir, por exemplo, a construção da
tabela que irá receber os valores de entrada informados no software.

Observação

Apesar de a lógica de programação ser uma variante entre os

programadores atuais, não se faz necessário a nomenclatura adotada neste
livro‑texto ser seguida em todo o desenvolvimento; porém, atualmente,
quanto mais o código-fonte do seu software for fiel à documentação
disponibilizada para o desenvolvimento, melhor o tempo de construção e
manutenção de cada funcionalidade.

2.3 Diagrama de Sequência

Este diagrama irá auxiliar o desenvolvedor a entender os seguintes itens na construção do software:

• Integração de classe(s) para cada funcionalidade(s).

• Integração de método(s) para cada funcionalidade(s).

20
Programação Orientada a Objetos II

Figura 8 – Diagrama de Sequência: funcionalidade IncluirRelatorio

Todos os recursos apresentados auxiliam o desenvolvedor a otimizar o tempo de construção,

garantindo uma entrega com qualidade e fiel à especificação atribuída.

Lembrete

Estudar análise de sistemas orientada a objetos é uma mistura

de regras de negócio e desenvolvimento de software. Embora sejam
necessários os conceitos e teorias, somente a prática levará o estudante
ao verdadeiro aprendizado!

Resumo

Abordamos a concepção de códigos e uma breve passagem da linguagem

de programação C#. É importante entender que todos os exemplos
apresentados foram concebidos por meio do Visual Studio, utilizando a
ferramenta console application.

Para que todo o aprendizado da linguagem de programação orientada

a objetos seja mais efetivo, recomenda‑se estudar também a Unified
Modeling Language (UML), que irá guiar o estudante a entender todo o
conceito teórico da linguagem e como será visualizado no ambiente de
trabalho entre análise e desenvolvimento de sistemas.

Diagramas essenciais para desenvolvimento de sistemas são: Diagrama

de Caso de Uso, Diagrama de Sequência e Diagrama de Classe.

21
 Unidade I

Estudar conceitos voltados à análise de sistemas garante a excelência

no desenvolvimento e a proximidade entre requisitos solicitados, análise
efetuada e aplicação desenvolvida.

Dentro do universo, por exemplo, de uma fábrica de software, podemos

encontrar a figura do Diagrama de Caso de Uso, que é importante para
o desenvolvedor na captura de informações que serão inseridas em uma
caixa de mensagem. No Diagrama de Sequência, o estudante pode ter a
visão de toda a interação sistêmica entre classes e métodos. Por fim, o
Diagrama de Classe é composto por atributos e métodos, ou seja, todo
atributo descreve as características de uma classe, e os métodos, por sua
vez, são ações que toda a classe pode executar.

Uma classe é uma representação de um objeto que será trabalhado

dentro de um sistema, sofrendo ações e, principalmente, tratando dados de
persistências e conexões futuras.

Por fim, não se pode evoluir tecnicamente sem que o estudante tenha,
ao menos, compreendido aspectos considerados pré‑requisitos para o
entendimento da disciplina, tendo a certeza de que uma análise efetuada
com sucesso pode garantir a excelência da execução de uma codificação.
Estudos comprovam que quanto mais tempo gasto em análise, menos
tempo precisará para se codificar.

22