APOSTILA - PROGRAMAÇÃO ORIENTADA A OBJETOS II

Prévia do material em texto

Autor: Prof. Salatiel Luz Marinho 
Colaborador: Prof. Luciano Soares de Souza
Programação 
Orientada a Objetos II
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
© 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.
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
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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
7
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
8
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
9
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
10
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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	
Usuario
Realce
11
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
Usuario
Realce
12
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
Usuario
Realce
13
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
14
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
Usuario
Realce
Usuario
Realce
Usuario
Realce
15
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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 DevelopmentEnvironments – 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 
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
16
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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>.
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
17
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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	
insucesso
•	Padronizar	e	 
treinar no 
sucesso
•	Verificar	 
atingimento 
de meta
•	Acompanhar	
indicadores
•	Localizar	
problemas
•	Estabelecer	
planos de ação
•	Execução	
do plano
•	Colocar	
plano em 
prática
Action
Agir
Check
Checar
Plan
Planejar
Do
Fazer
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.
18
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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	doNome	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.
19
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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()
Usuario
Realce
Usuario
Realce
20
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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).
Usuario
Realce
21
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
22
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
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.
Usuario
Realce
23
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Unidade II
Iniciaremos os nossos estudos apresentando técnicas de programação aplicando‑se a plataforma 
desktop. Iremos aprender como segregar a estrutura de código C# para que possamos garantir qualidade 
de desenvolvimento e performance de manutenção.
Entendendo as aplicações, torna‑se fácil entender os passos necessários para dar suporte a 
aplicações e identificar as diversas maneiras pelas quais essas aplicações Windows Form são fornecidas 
ou implementadas.
3 Linguagem de Programação C#
A linguagem de programação C# foi criada para que desenvolvedores pudessem atuar de maneira 
mais ágil com aplicações web. Dentre os pontos da linguagem, podemos destacar os seguintes:
•	 Linguagem	de	programação	orientada	a	objetos	ideal	para	desenvolvimento	de	aplicações	web.
•	 É	 considerada	 uma	 evolução	 do	 C++,	 do	 qual	 são	 utilizadas	 algumas	 características,	 como	
declarações, expressões e operadores.
•	 Utiliza	muitas	regras	de	programação	para	reduzir	a	possibilidade	de	erros.
•	 C#	também	tem	como	objetivo	permitir	o	desenvolvimento	de	qualquer	tipo	de	aplicação:	web 
service, aplicação Windows convencional, aplicações para serem executadas num palmtop ou 
handheld, aplicações para internet etc.
3.1 Histórico e curiosidades
•	 Criada	pela	Microsoft	especificamente	para	a	plataforma	.NET.
•	 Iniciada	em	1999	por	Anders	Hejlsberg	e	equipe,	com	nome	de	Cool.
•	 .NET	é	apresentada	em	2000	e	linguagem	Cool	é	renomeada	para	C#.
•	 O	símbolo	real	seria	o	♯, e não o #. Porém, devido a limitação de telas, fontes, teclados e alguns 
navegadores,	no	momento	da	normalização	junto	à	ECMA,	foi	feita	a	opção	pelo	#.
•	 Foi	criada	com	base	nas	linguagens	C++	e	Java.
•	 Tem	como	um	dos	principais	editores	o	Visual	Studio.
Usuario
Realce
24
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 Saiba mais
Para saber mais a respeito do tema, sugerimos a leitura do seguinte artigo:
ARAÚJO,	 E.	 C.	 Introdução	 à	 linguagem	 C#.	 DevMedia, Rio 
de	 Janeiro,	 [s.d.].	 Disponível	 em:	 <http://www.devmedia.com.br/
introducao‑a‑linguagem‑c/27711>.	Acesso	em:	9	jun.	2015.
3.2 microsoft Visual Studio
O	Microsoft Visual Studio	 é	 um	 pacote	 de	 programas	 da	 Microsoft	 para	 desenvolvimento,	
dedicado ao framework	.NET	e	às	linguagens	Visual	Basic	(VB),	C,	C++,	C#	e	J#.	Trata	também	de	
desenvolvimento web	na	plataforma	do	ASP.NET,	tendo	como	linguagens	mais	frequentes	VB.NET	
(Visual	Basic	.Net)	e	C#.
3.3 Herança
Trata‑se	 da	 característica	 mais	 poderosa	 e	 importante	 da	 orientação	 a	 objetos,	 pois	 permite	 o	
reaproveitamento	 de	 atributos	 e	 de	 métodos,	 otimizando	 o	 tempo	 de	 desenvolvimento.	 Com	 isso,	
podemos	reduzir	significativamente	a	linha	de	código.
O	conceitode	herança	trabalha	com	o	conceito	de	superclasse	e	 subclasse.	A	superclasse	é	uma	
classe que possui classes derivadas a partir dela, chamadas de subclasses. Estas, ao serem derivadas de 
uma superclasse, herdam seus atributos e métodos.
Figura	9 – Diagrama de Classe
Usuario
Realce
Usuario
Realce
25
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
A	seguir	podemos	observar	alguns	exemplos	que	contextualizam	a	explicação	de	herança:
Exemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
 class Program
 {
 static void Main(string[] args)
 {
 
 Console.WriteLine (“ Instancia da Classe Pessoa, {0}!”, Console.
ReadLine());
 __________.__________ pessoa = new Heranca.______________();
 pessoa._______ = “professor unip”;
 ______.idade = 40;
 
 Console.WriteLine (“Pessoa: Nome={0},Idade={1}”, __________.nome, 
pessoa.__________);
 Console.WriteLine();
 Console.WriteLine();
 
 Console.WriteLine(“ Instancia da Classe Aluno, {0}!”, Console.Read‑
Line());
 Heranca.___________ __________ = new Heranca.Aluno();
 _____________.nome = “Joaquim”;
 _____________.idade = 30;
 aluno.___________________ = “AX3601223‑1”;
 
 Console.WriteLine(“Aluno: Nome={0},Idade={1}, Matricula={2}”, alu‑
no._____, ____._____, _____._____);
 Console.WriteLine();
 Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
 }
 }
}
namespace Heranca
{
 public class _____________
 {
 //atributos
 public string __________;
 public int _____________;
 
 //construtor
 public _____________()
 {
 Console.WriteLine(“Construção do objeto Pessoa.”);
 } 
 }
26
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 public class _____________ : _____________
 {
 //atributo
 public String __________________;
 
 //construtor
 public Aluno()
 {
 Console.WriteLine(“Construção do objeto Aluno.”);
 }
 }
}
Exemplo 2
using System;
namespace ConsoleApplication2
{
 class Program
 {
 static void Main(string[] args)
 {
 
 //Início‑com base na herança 
 Console.WriteLine(“ Instancia da Classe Pessoa, {0}!”, Console.Read‑
Line());
 ____________.___________ _________ = new ___________.______(“Joa‑
quim”);
 Console.WriteLine (“Pessoa: Nome {0}”,_________.__________);
 Console.WriteLine();
 
 Console.WriteLine(“ Instancia da Classe Aluno com base na herança, 
{0}!”, Console.ReadLine());
 __________.________ aluno = new HerancaBase.__________(“090909‑x”, 
“Silva”);
 Console.WriteLine(“Aluno com nome {0} e matrícula {1}», aluno.nome, 
aluno.matricula);
 //Fim‑com base na herança
 Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
 }
 }
}
namespace HerancaBase
{
 public class __________
 {
 //atributos
 public string _________;
27
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 public int ____________;
 //construtor
 public __________()
 {
 //nada
 }
 public Pessoa(string n)
 {
 this.nome = n;
 Console.WriteLine(“Construção do objeto Pessoa com parâmetro.”);
 }
 }
 public class _________ : ___________
 {
 //atributo
 public String ____________;
 //construtor com base na herança
 public Aluno(string m, string n)
 : base(n)
 {
 this.matricula = m;
 Console.WriteLine(“Construção do objeto Aluno com base na herança.”);
 }
 }
}
3.4 Polimorfismo
O	conceito	está	associado	à	herança	e	trabalha	com	a	redeclaração	de	métodos	previamente	herdados	
por	uma	classe.	O	ponto	principal	é	evitar	ter	de	modificar	o	código‑fonte;	 inserindo	uma	chamada	
em um método com um nome diferente, redeclara‑se o método com o mesmo nome declarado na 
superclasse.
A	seguir	podemos	observar	alguns	exemplos	que	contextualizam	a	explicação	de	polimorfismo:
Exemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication3
{
 class ProgramP
 {
 static void Main(string[] args)
 {
Usuario
Realce
28
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 Console.WriteLine(“ Instancia da Classe Familia, {0}!”, Console.
ReadLine());
 _________._________ familia = new _____________.__________();
 familia.pais();
 Console.WriteLine(“ Instancia da Classe Continente, {0}!”, Console.
ReadLine());
 ______________.Continente ____________ = new Polimorfismo. 
_______________();
 continente.________();
 Console.WriteLine(“ Instancia da Classe Hemisferio, {0}!”, Console.
ReadLine());
 Polimorfismo.Hemisferio ______________ = new Polimorfismo.Hemisferio();
 ____________.pais();
 Console.ReadLine();
 }
 }
}
namespace Polimorfismo
{
 public class ______________
 {
 public virtual void ___________()
 {
 Console.WriteLine(“ Método ‘pais’ do objeto ‘Familia’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class ____________ : Familia
 {
 public override void ________()
 {
 Console.WriteLine(“ Método ‘pais’ do objeto ‘Continente’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class Hemisferio : _____________
 {
 public override void _________()
 {
 Console.WriteLine(“ Método ‘pais’ do objeto ‘Hemisferio’ “);
 }
 }
}
Figura	10	–	Tela	Windows	Form
29
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	11	–	Tela	Windows	Form:	Label
Figura	12	–	Tela	Windows	Form:	CheckBox selecionado
Exemplo 2
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
 public partial class Form1 : Form
 {
 public Form1()
 {
 InitializeComponent();
 checkBox1.Checked = false;
 label1.Text = “”;
 }
 
 private void button1_Click(object sender, EventArgs e)
 {
 Polimo.Movimenta __________ = new Polimo.Movimenta();
 if (this.checkBox1.Checked){
 _________.carro_em_movimento(new Polimo._______());
 label1.Text = “O Carro está acelerando.”;
 }
 else
30
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 {
 movimenta.carro_em_movimento(new Polimo.________());
 label1.Text = “O Carro está freando.”;
 } 
 }
 }
}
namespace Polimo
{
 //Classe
 public abstract class Carro
 {
 public abstract bool __________();
 }
 //Classe
 public class Acelerar:Carro 
 {
 //Usa o mesmo nome do método da Classe Carro 
 public ______________ bool _________()
 {
 Console.WriteLine(“O Carro está acelerando.”);
 return true;
 }
 }
 
 //Classe
 public class Frear:Carro
 {
 //Usa o mesmo nome dométodo da Classe Carro 
 public override bool acao()
 {
 Console.WriteLine(“O Carro está freando.”);
 return true;
 } 
 }
 
 //Classe
 public class Movimenta
 {
 public bool carro_em_movimento(_________ car)
 {
 return car.___________();
 }
 }
} 
Exemplo 3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication2
{
 class Programh
31
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 {
 static void Main(string[] args)
 {
 //Início‑com base na herança 
 Console.WriteLine(“ Instancia da Classe Pessoa, {0}!”, Console.Read‑
Line());
 HerancaBase.Pessoa pessoa = new HerancaBase.Pessoa(“LUIZ”);
 Console.WriteLine(“Pessoa: Nome {0}”, pessoa.nome);
 Console.WriteLine();
 Console.WriteLine(“ Instancia da Classe Aluno com base na herança, 
{0}!”, Console.ReadLine());
 HerancaBase.Aluno aluno = new HerancaBase.Aluno(“090909‑x”, “Lui‑
gi”);
 Console.WriteLine(“Aluno com nome {0} e matícula {1}”, aluno.nome, 
aluno.matricula);
 //Fim‑com base na herança
 Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
 }
 }
}
namespace HerancaBase
{
 public class Pessoa
 {
 //atributos
 public string nome;
 public int idade;
 //construtor
 public Pessoa()
 {
 //nada
 }
 public Pessoa(string n)
 {
 this.nome = n;
 Console.WriteLine(“Construção do objeto Pessoa com parâmetro.”);
 }
 }
 public class Aluno : Pessoa
 {
 //atributo
 public String matricula;
 //construtor com base na herança
 public Aluno(string m, string n)
 : base(n)
 {
 this.matricula = m;
 Console.WriteLine(“Construção do objeto Aluno com base na her‑
ança.”);
 }
 }
}
32
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Exemplo 4
using System;
namespace ConsoleApplication3
{
 class ProgramP
 {
 static void Main(string[] args)
 {
 Console.WriteLine (“ Instancia da Classe Familia, {0}!”, Console.
ReadLine());
 Polimorfismo.Familia familia = new Polimorfismo.Familia();
 familia.pais();
 Console.WriteLine(“ Instancia da Classe Continente, {0}!”, Console.
ReadLine());
 Polimorfismo.Continente continente = new Polimorfismo.Continente();
 continente.pais();
 Console.WriteLine(“ Instancia da Classe Hemisferio, {0}!”, Console.
ReadLine());
 Polimorfismo.Hemisferio hemisferio = new Polimorfismo.Hemisferio();
 hemisferio.pais();
 Console.ReadLine();
 }
 }
}
namespace Polimorfismo
{
 public class Familia
 {
 //método pais [País ou Pais]
 public virtual void pais()
 {
 Console.WriteLine (“ Método ‘pais’ do objeto ‘Familia’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class Continente : Familia
 {
 public override void pais()
 {
 Console.WriteLine (“ Método ‘pais’ do objeto ‘Continente’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class Hemisferio : Familia
 {
 public override void pais()
 {
 Console.WriteLine (“ Método ‘pais’ do objeto ‘Hemisferio’ “);
 }
 }
33
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 
Figura	13	–	Tela	Windows	Form	–	Label
Figura	14	–	Tela	Windows	Form	–	CheckBox selecionado
Exemplo 5
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
 public partial class Form1 : Form
 {
 public Form1()
 {
 InitializeComponent();
 checkBox1.Checked = false;
 label1.Text = “”;
 }
 private void button1_Click(object sender, EventArgs e)
 {
 Polimo.Movimenta movimenta = new Polimo.Movimenta();
 if (this.checkBox1.Checked)
 {
34
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 movimenta.carro_em_movimento(new Polimo.Acelerar());
 label1.Text = “O Carro está acelerando.”;
 }
 else
 {
 movimenta.carro_em_movimento(new Polimo.Frear());
 label1.Text = “O Carro está freando.”;
 }
 }
 }
}
namespace Polimo
{
 //Classe
 public abstract class Carro
 {
 public abstract bool acao();
 }
 //Classe
 public class Acelerar : Carro
 {
 //Usa o mesmo nome do método da Classe Carro 
 public override bool acao()
 {
 Console.WriteLine(“O Carro está acelerando.”);
 return true;
 }
 }
 //Classe
 public class Frear : Carro
 {
 //Usa o mesmo nome do método da Classe Carro 
 public override bool acao()
 {
 Console.WriteLine(“O Carro está freando.”);
 return true;
 }
 }
 //Classe
 public class Movimenta
 {
 public bool carro_em_movimento(Carro car)
 {
 return car.acao();
 }
 }
}
4 Camada de aPreSentação
Em primeiro lugar, é importante sabermos que a Camada de Apresentação é a entrada de dados 
de	uma	aplicação.	Em	muitos	momentos	ela	é	apresentada	em	projetos	de	software como Front‑End, 
definida como protótipo na fase de levantamento de requisitos.
Usuario
Realce
35
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	15 – Camada de Apresentação
Quadro 2 – Relação Controle versus Tela
Controle Name do Controle Text do Controle
Form frmNotasUnip Cadastro	de	Notas
GroupBox1 grpNotasSemestre Notas	do	Semestre
Label1 lblNotasP1 NotaP1:
Label2 lblNotasP2 NotaP2:
Label3 lblMedia Média:
ComboBox1 cbxNotaP1 ‑
ComboBox2 cbxNotaP2 ‑
GroupBox2 grpExameFinal Exame Final
Label4 lblNotaExame Nota	Exame:
Button1 btnCalcularMedia Calcular	Mé&dia
Button2 btnLimpar Lim&par
Button3 btnSair Sai&r
Button4 btnCalcularExame Calcular &Exame
 Saiba mais
Para saber mais sobre esse assunto, sugerimos a leitura do artigo:
JOMORI,	S.	M.;	VOLPE,	R.	L.	D;	ZABEU,	A.	C.	P.	Qualidade	de	software.	
Revista	Banas	Qualidade,	São	Paulo,	ano	13,	n.	141,	fev.	2004.
36
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
4.1 Funções específicas da Camada de apresentação
A camada de apresentação é responsável por diversas funções importantes no processo de execução 
do software:
•	 Pode	ser	categorizada	por	processos	de	aplicação.
•	 Processamento	de	transações.
•	 Acesso	a	banco	de	dados.
•	 Gerência	de	ações	sistêmicas	etc.
 observação
Software ou aplicação podem, por meio de uma boa análise efetuada, 
gerar	frutos	excepcionais.	Uma	boa	análise	equivale	a	80%	da	execução	de	
um	projeto,	restando	apenas	20%,	que	se	destinam	à	programação.
Estudar	uma	linguagem	específica	garante	conhecimento	da	tecnologia,	
ou	 seja,	 ganho	 técnico.	 Porém,	 se	 a	 análise	 não	 andar	 em	 paralelo	 com	
o	 código,	não	 será	possível	 aplicar	 todo	o	 conhecimento	 técnico	para	o	
sucesso da execução do desenvolvimento do software	e/ou	da	aplicação.
A camada de apresentação contém os elementos da interface do usuário do site e inclui toda a 
lógica,	que	compreende	a	interação	do	visitante	e	das	regras	de	negócio	(Windows	Form).
Podemos	definir	a	Camada	de	Apresentação,	ou	Camada	do	Cliente,ou	até	mesmo	Camada	Superior,	
como	a	interface	com	o	usuário,	que	poderia	ser	considerada	até	mesmo	como	as	janelas	do	Windows	
do nosso aplicativo, por exemplo.
Essa	camada	interage	com	a	Camada	de	Controle	(intermediária)	para	fazer	solicitações	e	recuperar	
informações da camada de dados, exibindo‑as para os usuários.
Uma	segregação	de	camadas	certamente	deixa	o	código	com	uma	leitura	e	um	controle	mais	fáceis,	
pois toda a regra está alocada em uma camada isolada.
4.2 Criando a Camada de apresentação
Iremos	apresentar	como	será	feita	a	criação	da	nossa	primeira	camada	de	apresentação.	A	princípio	
será criado um form para que possamos conhecer alguns componentes.
Como	primeiro	passo,	abriremos	nosso	IDE	de	programação,	chamado	Microsoft	Visual	Studio.
Usuario
Realce
Usuario
Realce
37
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 observação
Neste	livro‑texto	iremos	utilizar	o	Microsoft	Visual	Studio	2012.	Todo	e	
qualquer	exemplo	e/ou	exercício	deverá	ser	executado	nessa	versão	ou	em	
uma superior.
Figura	16	–	IDE	de	programação	Microsoft	Visual	Studio	2012
 Lembrete
Para	 efeito	 de	 padronização	 e	 arquitetura	 de	 solução,	 a	 estrutura	
de desenvolvimento de softwares	 terá	 como	 referência	 o	 MVC	 (Model,	
View,	Controller),	conforme	mencionado	anteriormente.	No	entanto,	essa	
arquitetura	 dará	 ao	 estudante	 uma	 visualização	 melhor	 sobre	 todos	 os	
recursos	utilizados	neste	livro‑texto.
Podemos	destacar,	dentro	do	Microsoft	Visual	Studio,	pontos	que	são	essenciais	para	a	execução	de	
um bom trabalho para o desenvolvedor:
•	 Solution	 Explorer (Gerenciador de Soluções): aba em que irá ficar concentrada toda 
a nossa estrutura de aplicação, desde a camada de apresentação até as classes que serão 
utilizadas	na	aplicação.
Usuario
Realce
Usuario
Realce
38
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	17	–	Solution	Explorer:	Gerenciador	de	Soluções
•	 Toolbox	(Barra	de	Ferramentas):	utilizada	para	que	o	desenvolvedor	possa	criar	suas	telas	com	
base	em	protótipos	elaborados	na	fase	de	levantamento	de	requisitos	do	projeto	de	software.
Figura	18	–	ToolBox:	Barra	de	Ferramentas
Para	criamos	um	projeto	Windows	Form,	ou	seja,	um	projeto	em	que	a	premissa	será	elaborar	uma	
aplicação que será executada em ambiente desktop, teremos de seguir estes passos:
•	 Ao	iniciar	o	Microsoft	Visual	Studio,	devemos	acionar	o	link New	Project	(Novo	Projeto),	ou	no	
menu superior File	(Arquivo)	 New	(Novo)	Project	(Projeto).
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
39
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	19	–	Tela	inicial	para	adicionar	um	novo	projeto
Figura	20	–	Rota	de	menu	para	adicionar	um	novo	projeto
 observação
A	 versão	 do	 Microsoft	 Visual	 Studio	 utilizada	 para	 ilustração	 deste	
livro‑texto	está	em	inglês.	O	autor	recomenda	a	utilização	dessa	versão,	pois	
ela é encontrada na maioria das empresas que atuam com desenvolvimento 
de software.
40
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
•	 Após	executar	a	ação	anterior,	a	seguinte	tela	deverá	ser	apresentada:
Figura	21	–	Caixa	inicial	de	criação	de	um	novo	projeto
Na	figura,	podemos	nos	atentar	para	alguns	detalhes,	tais	como:
•	 Do	lado	esquerdo	existe	um	item	chamado	Templates, onde podemos, por exemplo, definir em 
qual	linguagem	iremos	atuar.	É	muito	importante	atentarmos	à	linguagem	escolhida	para	que,	no	
momento da codificação, não possamos programar em linguagens diferentes.
Figura	22	–	Aplicação	Visual	Basic	com	código	C#
41
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	23 – Templates	contidos	dentro	do	Visual	C#
Podemos notar que existem diversos templates,	porém	o	que	 iremos	utilizar	será	o	Windows 
Form Application.
Para	que	possamos	finalizar	o	processo	de	criação	do	nosso	projeto,	será	necessário	atentar	para	
mais alguns itens:
•	 Name	(Nome):	nome	que	será	colocado	no	projeto	desenvolvido.
•	 Location	(Localização):	onde	ficará	alocado	o	novo	projeto.
•	 Solution	Name	(Nome	da	Solução):	será	replicado	o	Name	(Nome)	informado	para	o	novo	projeto.
 observação
Recomendamos que nunca informe um diretório de pen drive para 
salvar	ou	abrir	um	projeto	Windows	Form.	Como	parte	das	boas	práticas,	o	
projeto	deve	ser	criado	e/ou	alocado	em	disco	local	e	só	depois	de	todas	as	
alterações efetuadas ser transferido para o pen drive.
42
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	24	–	Definição	do	projeto	inicial
Após a execução desse passo será apresentada a seguinte tela:
Figura	25 – Ambiente de Desenvolvimento Windows Form
Quando	 um	 projeto	 Windows	 Form	 é	 adicionado,	 temos	 a	 visualização	 do	 Form1,	 que	 é	
adicionado automaticamente.
O	 Form1	 nada	 mais	 é	 do	 que	 a	 tela	 onde	 o	 desenvolvedor	 irá	 adicionar	 todos	 os	 componentes	
necessários para a sua funcionalidade.
Existe	 também,	 dentro	 do	 projeto	 Windows	 Form,	 a	 aba	 Solution	 Explorer, que detalha toda a 
estrutura	do	projeto.
43
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	26 – Apresentação da Solution	Explorer
Dentro da Solution	Explorer existem alguns itens como:
•	 AplicacaoTeste:	nome	da	aplicação,	definida	no	momento	da	criação	do	projeto.
•	 Properties	 (propriedades):	propriedades	do	projeto.	Dentro	dela,	podemos	visualizar	 cada	 label 
utilizado	no	projeto	e	configurações	realizadas	para	o	funcionamento	da	aplicação.
•	 References	(referências):	local	onde	se	armazenam	todas	as	referências	utilizadas	na	execução	
da aplicação.
•	 App.config:	 classe	 que	 centraliza	 endereçamentos	 utilizados	 no	 projeto,	 dentro	 deles,	 o	
endereçamento de banco de dados.
•	 Form1:	formulário	inicial	para	desenvolver	o	layout.
•	 Program: classe que define qual formulário será executado primeiro.
Figura	27	–	Nome	da	aplicação	–	AplicacaoTeste
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
Usuario
Realce
44
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	28 – Properties	(Propriedades)	–	AplicacaoTeste
Figura	29 – References	(Referências)	–	AplicacaoTeste
Figura	30 – App.config	–	AplicacaoTeste
45
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	31 – Classe App.config	–	AplicacaoTeste
Figura	32	–	Form1.cs	–	AplicacaoTeste
Figura	33	–	Form1	–	AplicacaoTeste
46
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	34	–	Program.cs	–	AplicacaoTeste
Figura	35	–	Classe	program.cs	–	AplicacaoTeste
Podemos	 alterar	 algumas	 propriedades	 do	 formulário.	 Na	 camada	 de	 apresentação	 podemos	
adicionar n	projetos,	ou	seja,	não	existe	limitação	de	formulários	dentro	desse	projeto.
Para adicionarmos um novo formulário podemos seguir por esta rota:
47
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
•	 Em	cima	do	projeto	AplicacaoTeste,	devemos	clicar	 com	o	botão	direito.	A	 seguinte	 tela	
será apresentada:
Figura	36	–	Menu	com	itens	a	serem	selecionados
Figura	37	–	Selecionar	o	item	Add  Windows Form
48
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Em seguida acionaremos a rota Add  New	Item, a tela a seguir será apresentada:
Figura	38	–	Tela	para	adicionar	um	novo	item	ao	projeto	–	AplicacaoTeste
Nessa	tela,	podemosnotar	que	é	possível	adicionar	ao	projeto:
•	 classe;
•	 formulário;
•	 classe	de	componente;
•	 diagrama	de	classe.
Figura	39 – Templates	que	podem	ser	adicionados	ao	projeto	–	AplicacaoTeste
49
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Após ser adicionado o novo formulário, a Solution	Explorer	é	atualizada	com	o	novo	item:
Figura	40	–	Form2	adicionado	à	Solution	Explorer
Podemos	alterar	o	nome	do	Form1	para	que	possamos	especificar	melhor	nosso	projeto.
 observação
Dentro da Solution	Explorer	podemos	adicionar	muitos	formulários.	No	
entanto,	 é	muito	 importante	que	 todos	os	 formulários	 sejam	nomeados	
para	 que,	 no	 futuro,	 cada	 um	 possa	 ser	 atribuído	 como	 funcionalidade	
sistêmica	da	aplicação.
Para que essa ação possa ser efetuada, podemos clicar com o botão direito em cima do nome do 
formulário e acionar a ação rename	(renomear).
Figura	41	–	Renomear	Form1	dentro	da	Solution	Explorer
50
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 observação
Como	 forma	 de	 padronização,	 nomearemos	 as	 interfaces	 iniciando	
sempre com as letras “frm”, representando a abreviação do termo 
“formulário”, de forma que auxilie os desenvolvedores a saberem que tudo o 
que estiver escrito dessa forma deverá ser entendido como implementação 
de interfaces.
Figura	42	–	frmMensagem:	nome	do	novo	formulário
Após ser alterado o nome, acionar o botão enter	 do	 teclado.	 Será	 apresentada	 a	 tela	 a	 seguir,	
perguntando	se	todas	as	classes	poderão	ser	renomeadas;	acionamos	o	botão	“sim”:
Figura	43	–	Confirmação	da	alteração	de	nome	de	Form1	para	frmMensagem
51
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Para	alterarmos	o	nome	da	barra	de	títulos	do	formulário,	deveremos	clicar	com	o	botão	direito	em	
cima	do	formulário	frmMensagem	e	acionar	o	item	properties.
Figura	44 – Properties	(propriedades)	do	formulário	Form1
Será	apresentada,	ao	lado	direito	da	tela,	uma	aba	na	qual	todas	as	propriedades	serão	apresentadas.
Figura	45 – Propriedades do formulário
52
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Todo	formulário	adicionado	contém	suas	respectivas	propriedades.	Dentre	elas,	podemos	alterar:
•	 Nome	do	título.
•	 Cor	de	fundo.
•	 Tamanho	do	formulário.
•	 Fonte.
•	 Controles	do	formulário.
Figura	46 – Propriedade Text	alterada	para	frmMensagem
Quando	a	propriedade	Text	foi	alterada,	automaticamente	o	título	do	formulário	foi	alterado	para	
frmMensagem;	assim,	no	momento	de	execução,	esse	é	o	título	que	será	apresentado.
 Lembrete
Para	efeito	de	padronização,	nomeamos	as	interfaces	iniciando	sempre	
com as letras “frm”, representando a abreviação do termo “formulário”. Isso 
auxilia os desenvolvedores a saberem que tudo o que estiver descrito dessa 
maneira será entendido como implementação de interfaces.
53
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	47 – Formulário em modo de execução
Podemos, por meio de um protótipo desenvolvido na fase de levantamento de requisitos, iniciar a 
construção	da	camada	de	apresentação.	Um	protótipo	é	uma	visão	de	como	a	camada	de	apresentação	
será	construída	dentro	do	projeto	de	software.
Figura	48 – Protótipo
Com	base	no	protótipo,	podemos	replicar	a	figura	dentro	da	camada	de	apresentação	utilizando	
alguns	componentes‑padrão	do	Microsoft	Visual	Studio.
Os	componentes	que	serão	utilizados	para	a	construção	da	camada	de	apresentação	são:
Usuario
Realce
54
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
•	 Label: responsável por alocar um rótulo na camada de apresentação.
•	 TextBox:	responsável	por	adicionarmos	dados	de	entrada	e	saída	na	camada	de	apresentação.
•	 Button: responsável por executar a ação desenvolvida na linguagem determinada.
Esses componentes estão contidos no ToolBox	(barra	de	ferramentas).
Figura	49 – Componente Label
Figura	50 – Componente TextBox
Figura	51 – Componente Button
 observação
Os	 componentes	 estão	 alocados	 na	 barra	 de	 ferramentas,	 no	 item	
Common Controls.
Iremos iniciar clicando no componente Label	e	arrastando	para	o	formulário.	Todos	os	componentes	
têm	como	premissa	o	comportamento	de	orientação	a	objeto,	ou	seja,	todos	os	componentes	são	objetos	
com as suas respectivas propriedades.
Todo	componente	tem,	em	suas	propriedades,	cor,	tamanho,	posicionamento	etc.
Usuario
Realce
Usuario
Realce
Usuario
Realce
55
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	52	–	Formulário	com	label1
Para	que	o	label1	seja	apresentado	conforme	o	protótipo	anterior	devemos	alterar	a	sua	propriedade	
de nome. Para isso, em cima do label, iremos clicar com o botão direito do mouse, assim sendo apresentado 
um menu.
Figura	53	–	Menu	de	ações	do	label1
Ao	ser	apresentado	esse	menu,	iremos	clicar	em	Propriedades.	Nesse	momento,	para	o	label1,	serão	
visualizadas	todas	as	propriedades	para	esse	componente.
56
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	54	–	Propriedades	do	componente	label1
Podemos	visualizar	diversas	propriedades	atribuídas	ao	componente	label1.	Nesse	primeiro	momento	
iremos alterar as propriedades Name e Text.
Figura	55 – Propriedade Text	do	componente	label1
Nesse	momento,	ao	ser	alterada	a	propriedade	text	do	componente	label1,	automaticamente,	no	
formulário,	é	replicada	e	visualizada	a	alteração.	Após	essa	ação	iremos	alterar	a	propriedade	name do 
componente	label1,	que	será	chamado	de	lblDigiteMensagem.
57
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	56 – Propriedade Name do componente label
Essa	alteração	é	necessária	para	um	bom	entendimento	do	código.	Iremos	acompanhar	mais	à	frente	
que todos os componentes deverão ser nomeados de uma maneira amigável para que possa facilitar o 
desenvolvimento e a manutenção do código.
Quadro 3 – Detalhes de componentes
Componente Name Text 
Label lblDigiteMensagem Digite	uma	Mensagem:
TextBox txtDigiteMensagem N/A
Button btnOk Ok
Podemos perceber que, para cada componente, sempre o seu name irá se iniciar com uma 
identificação	que	remeta	ao	nome	do	componente.	Exemplo:	no	caso	do	nome	lblDigiteMensagem,	as	
letras “lbl” seriam uma espécie de abreviação de label;	já	no	caso	de	btnDigiteMensagem,	as	letras	“btn”	
seriam	a	referência	ao	componente	button.
 observação
Não	 é	 uma	 regra	 trabalhar	 com	 abreviação	 de	 componentes.	 Caso	
o desenvolvedor se sinta confortável, nem precisa alterar o seu name. 
Porém, devemos pensar que podem existir aplicações nas quais, dentro do 
formulário,	podem	existir	dez	TextBox	e,	como	cada	vez	que	é	adicionado	
um	 componente	 o	 Microsoft	 Visual	 Studio	 adiciona	 o	 número	 1	 (como	
textbox1,	 textbox2,	 textbox3	 etc.),	 como	 identificar,	 por	 exemplo,	 qual	
textbox equivale ao nome do usuário ou ao login do usuário?
58
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Agora será adicionado o Textbox.	Para	isso,	iremos	localizar	o	componente	na	barra	de	ferramentas	
e arrastar para o nosso formulário.
Figura	57 – Text adicionado ao formulário
Para esse componente, será alterado o seu name. Para essa ação, iremos clicar com o botão direito 
do mouse e será aberto um menu de ações desse componente:
Figura	58	–	Menu	de	ações	do	componente	TextBox
Após esta ação será acionada a propriedade do componente TextBox.	 Serão	 abertas	 todas	 as	
propriedades desse componente:
59
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
ação
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	59 – Propriedades do componente TextBox
Após	 a	 janela	 de	 propriedades	 ser	 apresentada,	 iremos	 alterar	 a	 sua	 propriedade	 name para 
txtDigiteMensagem.
Figura	60 – Propriedade Name	alterada	para	txtDigiteMensagem
Agora iremos adicionar o nosso terceiro componente no formulário chamado button. Para isso iremos 
até a barra de ferramentas, clicaremos no componente button e vamos arrastá‑lo até o formulário.
60
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	61 – Componente button adicionado ao formulário
Depois, iremos acessar as propriedades do componente button. Para isso, iremos clicar com o botão 
direito em cima do componente button e acionar o item Propriedades.
Figura	62	–	Menu	de	ações	do	componente	button
61
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	63 – Propriedades do componente button
Para esse componente iremos alterar as propriedades name e text, conforme protótipo 
apresentado anteriormente.
Figura	64 – Propriedade name do componente button alterada
62
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	65 – Propriedade text do componente button alterada
Após serem efetuadas todas as inclusões de componentes no formulário, teremos nossa camada de 
apresentação fiel ao protótipo apresentado.
Figura	66 – Camada de apresentação
63
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Para	que	possamos	visualizar	a	nossa	aplicação	devemos	acionar	o	botão	“executar”,	que	fica	no	
menu	superior	do	Microsoft	Visual	Studio.	Nesse	instante	acontecerá	uma	simulação	do	comportamento	
da aplicação, como se ela estivesse instalada, por exemplo, em uma estação de trabalho.
Figura	67	–	Botão	Start, que executa aplicação
Figura	68	–	AplicacaoTeste	sendo	executada
Podemos imprimir a mensagem “Professor” dentro de um label. Para isso seguiremos o escopo a seguir:
•	 Digitar	uma	mensagem	na	caixa	de	texto.
64
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
•	 Acionar	o	botão	Ok.
•	 Apresentar	a	mensagem	por	meio	de	uma	label.
Iremos adicionar uma label logo abaixo da caixa de texto:
Figura	69	–	Label1	inserida	no	formulário
Serão	 alteradas	 as	 propriedades	 Name e Text para identificarmos o componente adicionado 
ao	 formulário.	 Para	 essa	 ação	 iremos	 clicar	 com	 o	 botão	 direito	 em	 cima	 do	 componente	 label1	 e	
acionaremos o item Properties	(Propriedades).
Figura	70	–	Menu	de	ações	do	componente	label1
65
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	71 – Text	lblMensagem
Figura	72 – Name	lblMensagem
Nesse	 momento,	 atendemos	 parcialmente	 o	 requisito	 solicitado.	 Nesse	 instante	 iremos	 iniciar	 a	
codificação.	Para	isso,	acionaremos	o	botão	OK,	efetuando	um	duplo	clique.
66
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	73	–	Modo	de	codificação
Para que possamos entender melhor o cenário proposto, quando o usuário digitar uma mensagem e 
acionar	o	botão	Ok,	a	mensagem	deverá	ser	apresentada	dentro	do	label lblmensagem.
Inicialmente, para que possamos efetuar o entendimento do código, vamos pensar em um 
código estruturado.
Início  Digite uma mensagem  Mensagem é transferida para label	lblMensagem		Fim
Para	que	essa	ação	possa	ser	concretizada	no	código,	digitaremos	a	seguinte	instrução:
Figura	74	–	Código	do	botão	OK
67
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
O	entendimento	do	código	poderia	ser	feito	da	seguinte	maneira:
•	 lblMensagem.Text: neste trecho estamos informando ao código C# o nome do componente 
(lblMensagem)	e	sua	propriedade	(Text).	Quando	a	propriedade	 informada	for	Text, poderemos 
entender	que	ela	irá	receber	dados	alfanuméricos	(String).
•	 txtDigiteMensagem.Text: neste trecho estamos informando ao código C# o nome do 
componente	(txtDigiteMensagem)	e	sua	propriedade	(Text).	Quando	a	propriedade	informada	for	
Text,	poderemos	entender	que	ela	irá	receber	dados	alfanuméricos	(String).
Resumido	a	ação	codificada,	tudo	o	que	estiver	sendo	informado	no	componente	txtDigiteMensagem	
será	enviado	para	o	componente	lblMensagem.
Vamos	executar	nossa	aplicação:
Figura	75	–	AplicacaoTeste	sendo	executada
Após	digitar	a	palavra	“Professor”	na	caixa	de	texto,	acionaremos	o	botão	OK.	Perceba	que	existe	no	
formulário o label	lblMensagem.
68
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	76 – Label recebe palavra digitada na caixa de texto
Nesse	instante,	após	o	botão	Ok	ser	acionando,	o	label	lblMensagem	mudou	para	a	palavra	“Professor”,	
que foi digitada na caixa de texto.
Vamos	exercitar.	A	partir	de	um	protótipo	construído	após	efetuado	um	levantamento	de	requisitos,	
iremos construir uma calculadora, onde teremos as operações básicas da matemática: adição, subtração, 
divisão	e	multiplicação.	Vamos	observar	o	protótipo	construído:
Figura	77 – Protótipo Calculadora
69
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Para	a	efetivação	do	código,	iremos	iniciar	pela	análise	do	protótipo.	Na	figura	podemos	observar	
que existem:
•	 Três	labels.
•	 Quatro	botões.
Quadro 4 – Componentes
Componente Nome Texto 
Label lblDigitePrimeiroNumero Digite	o	primeiro	número
Label lblDigiteSegundoNumero Digite	o	segundo	número
Label lblResultado Resultado
Button btnAdicao +
Button btnSubtracao ‑
Button btnMultiplicação *
Button btnDivisao /
Vamos	programar:
1.	Crie	um	novo	projeto	(Windows	FormApplication),	com	o	nome	de	Calculadora.
2.	Altere	a	propriedade	Text do formulário para Calculadora.
Figura	78	–	Projeto	Windows	Form	Application:	calculadora
70
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
3.	 Agora	 iremos	 inserir	 os	 componentes	 dentro	 do	 formulário,	 conforme	 protótipo	 apresentado	
anteriormente.
Figura	79 – Formulário Calculadora
Podemos	notar	que	todos	os	componentes	inseridos	no	formulário	estão	sem	o	nome;	para	isso,	em	
todos os componentes, iremos alterar as propriedades Name e Text:
Figura	80 – Alterando propriedade Text do botão Adicionar
71
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	81 – Propriedade Name alterada no botão Adicionar
Para todos os componentes de tela iremos alterar as propriedades Name e Text e, para isso, iremos 
para cada componente, clicar com o botão direito e, em seguida, em Properties:
Figura	82 – Properties	(propriedades)	do	botão	Adicionar
Após a execução desse passo, todos os componentes serão alterados e apresentados conforme figura 
a seguir:
72
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	83 – Calculadora com todos os componentes adicionados
Vamos	iniciar	a	codificação	dos	botões	da	nossa	calculadora,	mas,	antes,	precisamos	entender	alguns	
pontos importantes:
•	 Todo	número,	a	princípio,	só	poderá	ser	matematicamente	operado	se	for,	no	mínimo,	do	tipo	inteiro.
•	 Caixas	de	texto	recebem	somente	string.
Para iniciarmos o entendimento de como as operações matemáticas serão efetuadas, precisamos 
entender	 o	 conceito	 de	 Tipos	 Primitivos,	 que	 são	 atribuições	 dadas	 a	 variáveis	 que	 auxiliam	 na	
codificação C#.
Exemplo: precisamos somar dois valores contidos em caixas de texto.
Valor	A:	10.
Valor	B:	10.